Update

Author: ex01tus

README.md

@@ -2,7 +2,7 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 537 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 541 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 19 topics:
@@ -11,17 +11,17 @@ Problems are separated into 19 topics:
 |---:|:--------------------|:-----------------------------------------------|---------:|
 |  1 | Array               | [array](src/array)                             |       76 |
 |  2 | Binary              | [binary](src/binary)                           |       13 |
-|  3 | Binary Search       | [binary_search](src/binary_search)             |       18 |
+|  3 | Binary Search       | [binary_search](src/binary_search)             |       19 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
 |  5 | Binary Tree         | [binary_tree](src/binary_tree)                 |       47 |
 |  6 | Design              | [design](src/design)                           |       18 |
-|  7 | Dynamic Programming | [dynamic_programming](src/dynamic_programming) |       48 |
+|  7 | Dynamic Programming | [dynamic_programming](src/dynamic_programming) |       49 |
 |  8 | Graph               | [graph](src/graph)                             |       66 |
 |  9 | Greedy Algorithms   | [greedy](src/greedy)                           |       21 |
 | 10 | Heap                | [heap](src/heap)                               |       21 |
 | 11 | Interval            | [interval](src/interval)                       |       11 |
-| 12 | Linked List         | [linked_list](src/linked_list)                 |       33 |
-| 13 | Math                | [math](src/math)                               |       20 |
+| 12 | Linked List         | [linked_list](src/linked_list)                 |       34 |
+| 13 | Math                | [math](src/math)                               |       21 |
 | 14 | Matrix              | [matrix](src/matrix)                           |       18 |
 | 15 | Quad Tree           | [quad_tree](src/quad_tree)                     |        1 |
 | 16 | Recursion           | [recursion](src/recursion)                     |       24 |

src/binary_search/PeakIndexInMountainArray.java

@@ -0,0 +1,29 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/peak-index-in-a-mountain-array
+ * Difficulty: Medium
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class PeakIndexInMountainArray {
+
+    public int peakIndexInMountainArray(int[] arr) {
+        int left = 0;
+        int right = arr.length - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+
+            if (arr[mid] < arr[mid + 1]) {
+                left = mid + 1;
+            } else if (arr[mid] < arr[mid - 1]) {
+                right = mid - 1;
+            } else {
+                return mid;
+            }
+        }
+
+        return -1;
+    }
+}

src/dynamic_programming/PredictWinner.java

@@ -0,0 +1,36 @@
+package dynamic_programming;
+
+/**
+ * Description: https://leetcode.com/problems/predict-the-winner
+ * Difficulty: Medium
+ * Time complexity: O(n^2)
+ * Space complexity: O(n^2)
+ */
+public class PredictWinner {
+
+    private static final int FIRST_PLAYER = 0;
+    private static final int SECOND_PLAYER = 1;
+
+    public boolean predictTheWinner(int[] nums) {
+        // we track FIRST_PLAYER's score as positive and SECOND_PLAYER's as negative
+        // if total score is greater or equal than 0 -> FIRST_PLAYER wins
+        return play(nums, 0, nums.length - 1, FIRST_PLAYER, new int[nums.length][nums.length]) >= 0;
+    }
+
+    private int play(int[] nums, int left, int right, int player, int[][] memo) {
+        if (left > right) return 0;
+        if (memo[left][right] != 0) return memo[left][right];
+
+        if (player == FIRST_PLAYER) {
+            int takeLeft = nums[left] + play(nums, left + 1, right, SECOND_PLAYER, memo);
+            int takeRight = nums[right] + play(nums, left, right - 1, SECOND_PLAYER, memo);
+            memo[left][right] = Math.max(takeLeft, takeRight);
+        } else {
+            int takeLeft = -nums[left] + play(nums, left + 1, right, FIRST_PLAYER, memo);
+            int takeRight = -nums[right] + play(nums, left, right - 1, FIRST_PLAYER, memo);
+            memo[left][right] = Math.min(takeLeft, takeRight);
+        }
+
+        return memo[left][right];
+    }
+}

src/linked_list/PlusOneLinkedList.java

@@ -0,0 +1,78 @@
+package linked_list;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * Description: https://leetcode.com/problems/plus-one-linked-list
+ * Difficulty: Medium
+ */
+public class PlusOneLinkedList {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public ListNode plusOneOptimalApproach(ListNode head) {
+        ListNode dummy = new ListNode(0, head);
+
+        ListNode nonNine = dummy;
+        while (head != null) {
+            if (head.val != 9) nonNine = head;
+            head = head.next;
+        }
+
+        nonNine.val += 1;
+
+        ListNode nine = nonNine.next;
+        while (nine != null) {
+            nine.val = 0;
+            nine = nine.next;
+        }
+
+        return dummy.val == 0 ? dummy.next : dummy;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public ListNode plusOneViaStack(ListNode head) {
+        ListNode dummy = new ListNode(0, head);
+
+        Deque<ListNode> stack = buildStack(dummy);
+
+        int carry = 0;
+        while (!stack.isEmpty()) {
+            ListNode current = stack.pop();
+            int sum = current.val + carry;
+            current.val = sum % 10;
+            carry = sum / 10;
+        }
+
+        return dummy.val == 0 ? dummy.next : dummy;
+    }
+
+    private Deque<ListNode> buildStack(ListNode dummy) {
+        Deque<ListNode> stack = new LinkedList<>();
+
+        ListNode current = dummy;
+        while (current != null) {
+            stack.push(current);
+            if (current.next == null) current.val += 1;
+            current = current.next;
+        }
+
+        return stack;
+    }
+
+    private static class ListNode {
+        int val;
+        ListNode next;
+
+        public ListNode(int val, ListNode next) {
+            this.val = val;
+            this.next = next;
+        }
+    }
+}

src/math/CountOddNumbersInIntervalRange.java

@@ -0,0 +1,19 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/count-odd-numbers-in-an-interval-range
+ * Difficulty: Easy
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+public class CountOddNumbersInIntervalRange {
+
+    public int countOdds(int low, int high) {
+        int count = (high - low) / 2;
+        if (low % 2 != 0 || high % 2 != 0) {
+            count++;
+        }
+
+        return count;
+    }
+}