Add Greedy

* Candies
* Gas Stations
* Jump To The End

Author: marttp

kotlin/Greedy/Candies.kt

@@ -0,0 +1,24 @@
+fun candies(ratings: List<Int>): Int {
+    val n = ratings.size
+    // Ensure each child starts with 1 candy.
+    val candies = IntArray(n) { 1 }
+    // First pass: for each child, ensure the child has more candies
+    // than their left-side neighbor if the current child's rating is
+    // higher.
+    for (i in 1 until n) {
+        if (ratings[i] > ratings[i - 1]) {
+            candies[i] = candies[i - 1] + 1
+        }
+    }
+    // Second pass: for each child, ensure the child has more candies
+    // than their right-side neighbor if the current child's rating is
+    // higher.
+    for (i in n - 2 downTo 0) {
+        if (ratings[i] > ratings[i + 1]) {
+            // If the current child already has more candies than their
+            // right-side neighbor, keep the higher amount.
+            candies[i] = maxOf(candies[i], candies[i + 1] + 1)
+        }
+    }
+    return candies.sum()
+}

kotlin/Greedy/GasStations.kt

@@ -0,0 +1,22 @@
+fun gasStations(gas: List<Int>, cost: List<Int>): Int {
+    // If the total gas is less than the total cost, completing the
+    // circuit is impossible.
+    if (gas.sum() < cost.sum()) {
+        return -1
+    }
+    var start = 0
+    var tank = 0
+    for (i in 0 until gas.size) {
+        tank += gas[i] - cost[i]
+        // If our tank has negative gas, we cannot continue through the
+        // circuit from the current start point, nor from any station
+        // before or including the current station 'i'.
+        if (tank < 0) {
+            // Set the next station as the new start point and reset the
+            // tank.
+            start = i + 1
+            tank = 0
+        }
+    }
+    return start
+}

kotlin/Greedy/JumpToTheEnd.kt

@@ -0,0 +1,16 @@
+fun jumpToTheEnd(nums: List<Int>): Boolean {
+    // Set the initial destination to the last index in the array.
+    var destination = nums.size - 1
+    // Traverse the array in reverse to see if the destination can be
+    // reached by earlier indexes.
+    for (i in nums.size - 2 downTo 0) {
+        // If we can reach the destination from the current index,
+        // set this index as the new destination.
+        if (i + nums[i] >= destination) {
+            destination = i
+        }
+    }
+    // If the destination is index 0, we can jump to the end from index
+    // 0.
+    return destination == 0
+}