Fixed one and added one new solution

Author: Мето Трајковски

Diff for: Arrays/jump_game.py

@@ -5,10 +5,10 @@
 Each element in the array represents your maximum jump length at that position.
 Determine if you are able to reach the last index.
 
-Input: [2,3,1,1,4]
+Input: [2, 3, 1, 1, 4]
 Output: True
 
-Input: [3,2,1,0,4]
+Input: [3, 2, 1, 0, 4]
 Output: False
 
 =========================================
@@ -28,17 +28,17 @@ def can_jump(nums):
     if n == 0:
         return False
 
-    last = 0
+    max_jump = 0
     for i in range(n):
         # if this field isn't reachable return False
-        if last < i:
+        if max_jump < i:
             return False
 
-        max_jump = i + nums[i]
-        last = max(last, max_jump)
+        this_jump = i + nums[i]
+        max_jump = max(max_jump, this_jump)
 
         # if the jump is greater or equal to the last element return True
-        if last >= n - 1:
+        if max_jump >= n - 1:
             return True
 
 
@@ -48,8 +48,8 @@ def can_jump(nums):
 
 # Test 1
 # Correct result => True
-print(can_jump([2,3,1,1,4]))
+print(can_jump([2, 3, 1, 1, 4]))
 
 # Test 2
 # Correct result => False
-print(can_jump([3,2,1,0,4]))
+print(can_jump([3, 2, 1, 0, 4]))

Diff for: Arrays/trapped_watter.py

@@ -14,6 +14,7 @@
 Output explanation: We can hold 3 units in the first index, 2 in the second, and 3 in the fourth index (we cannot hold 5 since it would run off to the left), so we can trap 8 units of water.
 
 =========================================
+The goal is to find the max wall and make 2 iterations starting from front and from back looking for the next bigger wall.
 First search for the max wall from front, after that correct the left water starting from the back side
     Time Complexity:    O(N)
     Space Complexity:   O(1)
@@ -26,25 +27,28 @@
 
 def trapped_water(elevation_map):
     n = len(elevation_map)
+    if n == 0:
+        return 0
+
     water = 0
 
     # start from front of the array
     # and look for the max wall
-    last_idx = 0
+    max_idx = 0
     max_height = elevation_map[0]
 
     for i in range(1, n):
         if elevation_map[i] >= max_height:
-            last_idx = i # save the highest wall index for later
+            max_idx = i # save the highest wall index for later
             max_height = elevation_map[i]
 
         water += max_height - elevation_map[i]
 
-    # after that start from back and go reverse to the max wall
+    # after that start from back and go reverse to the max wall idx
     # and correct the result (pour the extra water if there is smaller wall on the right side)
     back_max_height = elevation_map[-1]
 
-    for i in reversed(range(last_idx + 1, n - 1)):
+    for i in range(n - 1, max_idx, -1):
         if elevation_map[i] > back_max_height:
             back_max_height = elevation_map[i]
 
@@ -63,4 +67,8 @@ def trapped_water(elevation_map):
 
 # Test 2
 # Correct result => 8
-print(trapped_water([3, 0, 1, 3, 0, 5]))
+print(trapped_water([3, 0, 1, 3, 0, 5]))
+
+# Test 3
+# Correct result => 6
+print(trapped_water([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]))

Diff for: Dynamic Programming/jump_game_2.py

@@ -0,0 +1,82 @@
+'''
+Jump Game 2
+
+Given an array of non-negative integers, you are initially positioned at the first index of the array.
+Each element in the array represents your maximum jump length at that position.
+Your goal is to reach the last index in the minimum number of jumps.
+
+Input: XXX
+Output: XXX
+Output explanation: XXX
+
+=========================================
+Classical 1D Dynamic Programming solution.
+    Time Complexity:    O(N)    , maybe looks like O(N^2) but that's not possible
+    Space Complexity:   O(N)
+If you analyze the previous solution, you'll see that you don't need the whole DP array.
+    Time Complexity:    O(N)
+    Space Complexity:   O(1)
+'''
+
+
+##############
+# Solution 1 #
+##############
+
+def min_jumps_1(nums):
+    n = len(nums)
+    if n <= 1:
+        return 0
+
+    dp = [-1]*n
+    dp[0] = 0
+
+    for i in range(n):
+        this_jump = i + nums[i]
+        jumps = dp[i] + 1
+
+        if this_jump >= n - 1:
+            return jumps
+
+        # starging from back, go reverse and
+        # change all -1 values and break when first positive is found
+        for j in range(this_jump, i, -1):
+            if dp[j] != -1:
+                break
+            dp[j] = jumps
+
+
+##############
+# Solution 2 #
+##############
+
+def min_jumps_2(nums):
+    n = len(nums)
+    if n <= 1:
+        return 0
+
+    jumps = 0
+    max_jump = 0
+    new_max_jump = 0
+
+    for i in range(n):
+        if max_jump < i:
+            max_jump = new_max_jump
+            jumps += 1
+
+        this_jump = i + nums[i]
+        if this_jump >= n - 1:
+            return jumps + 1
+
+        new_max_jump = max(new_max_jump, this_jump)
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => 2
+nums = [2, 3, 1, 1, 4]
+print(min_jumps_1(nums))
+print(min_jumps_2(nums))