LC 135. Candy (Rust Greedy)

Author: raul-sauco

README.md

@@ -124,7 +124,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [131. Palindrome Partitioning][lc131]                                                         | 🟠 Medium  | [![python](res/py.png)][lc131py]                                                                      |
 | [133. Clone Graph][lc133]                                                                     | 🟠 Medium  | [![python](res/py.png)][lc133py]                                                                      |
 | [134. Gas Station][lc134]                                                                     | 🟠 Medium  | [![python](res/py.png)][lc134py]                                                                      |
-| [135. Candy][lc135]                                                                           | 🔴 Hard    | [![python](res/py.png)][lc135py]                                                                      |
+| [135. Candy][lc135]                                                                           | 🔴 Hard    | [![python](res/py.png)][lc135py] [![rust](res/rs.png)][lc135rs]                                       |
 | [136. Single Number][lc136]                                                                   | 🟢 Easy    | [![python](res/py.png)][lc136py]                                                                      |
 | [138. Copy List with Random Pointer][lc138]                                                   | 🟠 Medium  | [![python](res/py.png)][lc138py]                                                                      |
 | [139. Word Break][lc139]                                                                      | 🟠 Medium  | [![python](res/py.png)][lc139py]                                                                      |
@@ -832,6 +832,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc134py]: leetcode/gas-station.py
 [lc135]: https://leetcode.com/problems/candy/
 [lc135py]: leetcode/candy.py
+[lc135rs]: leetcode/candy.rs
 [lc136]: https://leetcode.com/problems/single-number/
 [lc136py]: leetcode/single-number.py
 [lc138]: https://leetcode.com/problems/copy-list-with-random-pointer/

leetcode/candy.py

@@ -1,12 +1,55 @@
+# 135. Candy
+# 🔴 Hard
+#
 # https://leetcode.com/problems/candy/
-
+#
+# Tags: Array - Greedy
 
 import timeit
 from typing import List
 
 
-# Runtime: 263 ms, faster than 42.85% of Python3 online submissions for Candy.
-# Memory Usage: 16.9 MB, less than 37.74 % of Python3 online submissions for Candy.
+# Use an extra auxiliary vector of the same size as the input vector to
+# store the candy assigned to each child initialized to 1 for each child.
+# Iterate over the input array forward, for each child that has a higher
+# rating that the one to its left, give it one more candy that the one to
+# its left already has. Once we reach the end we traverse backwards, for
+# each child that has a higher rating than the one to its right, if its it
+# not already getting more candy than the one to its right is, we give it
+# the amount of candy that that one gets plus 1. We return the sum of
+# values in the assigned candy array.
+#
+# Time complexity: O(n) - We traverse over n elements twice.
+# Space complexity: O(n) - We store an extra vector of size n in memory.
+#
+# Runtime 141 ms Beats 73.84%
+# Memory 19.15 MB Beats 91.36%
+class TwoArrays:
+    def candy(self, ratings):
+        n = len(ratings)
+        if n < 2:
+            return n
+        nums = [1] * n
+        for i in range(1, n):
+            if ratings[i] > ratings[i - 1]:
+                nums[i] = nums[i - 1] + 1
+        for i in range(n - 1, 0, -1):
+            if ratings[i - 1] > ratings[i]:
+                nums[i - 1] = max(nums[i] + 1, nums[i - 1])
+        return sum(nums)
+
+
+# Similar solution that only uses one pass, keep track of how many
+# previous children's assignments depend on the current child, if it is
+# necessary to increase its assigned candy, increase it by one for it
+# and all previous children that had a higher rating.
+#
+# Time complexity: O(n) - We visit each of the n elements once and do
+# constant time work for each.
+# Space complexity: O(1) - We use constant extra memory.
+#
+# Runtime 136 ms Beats 88.46%
+# Memory 19.26 MB Beats 68.45%
 class DescendingSequence:
     def candy(self, ratings: List[int]) -> int:
         if len(ratings) < 2:
@@ -47,73 +90,50 @@ def candy(self, ratings: List[int]) -> int:
         return min_candy
 
 
-class TwoArrays:
-    def candy(self, ratings):
-        n = len(ratings)
-        if n < 2:
-            return n
-
-        # initial state: each kid gets one candy
-        nums = [1] * n
-        # kids on upwards curve get candies
-        for i in range(1, n):
-            if ratings[i] > ratings[i-1]:
-                nums[i] = nums[i-1] + 1
-
-        # kids on downwards curve get candies
-        # if a kid on both up/down curves, i.e. a peak or a valley
-        # kid gets the maximum candies among the two.
-        # total = 0
-        for i in range(n-1, 0, -1):
-            if ratings[i-1] > ratings[i]:
-                nums[i-1] = max(nums[i]+1, nums[i-1])
-            # total += nums[i]
-
-        # Locally it is quicker to return the sum
-        # total += nums[0]
-        # return total
-        return sum(nums)
-
-
 def test():
-    executor = [
-        {'executor': DescendingSequence, 'title': 'DescendingSequence', },
-        {'executor': TwoArrays, 'title': 'TwoArrays', },
+    executors = [
+        DescendingSequence,
+        TwoArrays,
     ]
     tests = [
+        [[], 0],
+        [[15], 1],
+        [[1, 0, 2], 5],
+        [[1, 2, 2], 4],
         [[0, 0, 0, 0], 4],
         [[0, 0, 0, -1], 5],
         [[7, 1, 0, -1], 10],
-        [[7, 1, 0, -1, -1], 11],
-        [[7, 1, 0, -1, -1, 1], 13],
-        [[7, 1, 0, -1, -1, 1, 2], 16],
-        [[7, 1, 0, -1, -1, 1, 2, 3], 20],
-        [[7, 1, 0, -1, -1, 1, 2, 3, 3], 21],
         [[1, 2, 3, 4, 5], 15],
+        [[7, 1, 0, -1, -1], 11],
         [[1, 2, 3, 4, 5, 4], 16],
+        [[1, 5, 4, 3, 2, 1], 16],
+        [[7, 1, 0, -1, -1, 1], 13],
         [[1, 2, 3, 4, 5, 4, 2], 18],
+        [[7, 1, 0, -1, -1, 1, 2], 16],
         [[1, 2, 3, 4, 5, 4, 3, 2], 21],
+        [[7, 1, 0, -1, -1, 1, 2, 3], 20],
         [[1, 2, 3, 4, 5, 4, 3, 2, 1], 25],
+        [[7, 1, 0, -1, -1, 1, 2, 3, 3], 21],
         [[1, 2, 3, 4, 5, 4, 3, 2, 1, 0], 31],
         [[1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0], 32],
         [[1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0, 1, 2, 4], 41],
-        [[1, 5, 4, 3, 2, 1], 16],
-        [[1, 0, 2], 5],
-        [[1, 2, 2], 4],
-        [[], 0],
-        [[15], 1],
     ]
-    for e in executor:
+    for executor in executors:
         start = timeit.default_timer()
-        for _ in range(int(float('1'))):
-            for t in tests:
-                sol = e['executor']()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
                 result = sol.candy(t[0])
-                expected = t[1]
-                assert result == expected, f'{result} != {expected}'
+                exp = t[1]
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
         stop = timeit.default_timer()
         used = str(round(stop - start, 5))
-        print("{0:20}{1:10}{2:10}".format(e['title'], used, "seconds"))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
 
 
 test()

leetcode/candy.rs

@@ -0,0 +1,51 @@
+// 135. Candy
+// 🔴 Hard
+//
+// https://leetcode.com/problems/candy/
+//
+// Tags: Array - Greedy
+
+struct Solution;
+impl Solution {
+    /// Use an extra auxiliary vector of the same size as the input vector to
+    /// store the candy assigned to each child initialized to 1 for each child.
+    /// Iterate over the input array forward, for each child that has a higher
+    /// rating that the one to its left, give it one more candy that the one to
+    /// its left already has. Once we reach the end we traverse backwards, for
+    /// each child that has a higher rating than the one to its right, if its it
+    /// not already getting more candy than the one to its right is, we give it
+    /// the amount of candy that that one gets plus 1. We return the sum of
+    /// values in the assigned candy array.
+    ///
+    /// Time complexity: O(n) - We traverse over n elements twice.
+    /// Space complexity: O(n) - We store an extra vector of size n in memory.
+    ///
+    /// Runtime 2 ms Beats 89.25%
+    /// Memory 2.14 MB Beats 84.95%
+    pub fn candy(ratings: Vec<i32>) -> i32 {
+        let n = ratings.len();
+        let mut assignments = vec![1; n];
+        for i in 1..n {
+            if ratings[i] > ratings[i - 1] {
+                assignments[i] = assignments[i - 1] + 1;
+            }
+        }
+        let mut res = assignments[n - 1];
+        for i in (0..n - 1).rev() {
+            if ratings[i] > ratings[i + 1] && assignments[i] <= assignments[i + 1] {
+                assignments[i] = assignments[i + 1] + 1;
+            }
+            res += assignments[i];
+        }
+        res
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [(vec![1, 0, 2], 5), (vec![1, 2, 2], 4)];
+    for t in tests {
+        assert_eq!(Solution::candy(t.0), t.1);
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}