EPI: Dutch flag, and int inc as array (C++ and Py)

Author: jsgoller1

elements-of-programming-interviews/cpp/dutch_national_flag.cc

@@ -7,10 +7,36 @@
 using std::vector;
 enum class Color { kRed, kWhite, kBlue };
 
+int pivotSort(int left, const Color& val, vector<Color>& A) {
+  int curr = left;
+  while (curr < A.size()) {
+    if (A[curr] == val) {
+      Color temp = A[curr];
+      A[curr] = A[left];
+      A[left] = temp;
+      left++;
+    }
+    curr++;
+  }
+  return left;
+}
+
 void DutchFlagPartition(int pivot_index, vector<Color>* A_ptr) {
-  // TODO - you fill in here.
+  /*
+  This solution kind of sucks because the problem kind of sucks; as stated,
+  we want to sort A into [less than pivot, equal to pivot, greater than pivot].
+  However, The test cases here are based on the dutch flag, not arbitrary
+  integers - so the end result is the Dutch flag no matter what, and this code
+  directly solves that (with two passes) by hardcoding the given colors. This
+  approach would not work for a more general Dutch Flag sort akin to quicksort's
+  pivot. See my Python solution for a better approach.
+  */
+  vector<Color>& A = *A_ptr;
+  int i = pivotSort(0, Color::kRed, A);
+  pivotSort(i, Color::kWhite, A);
   return;
 }
+
 void DutchFlagPartitionWrapper(TimedExecutor& executor, const vector<int>& A,
                                int pivot_idx) {
   vector<Color> colors;

elements-of-programming-interviews/cpp/int_as_array_increment.cc

@@ -2,9 +2,36 @@
 
 #include "test_framework/generic_test.h"
 using std::vector;
+vector<int> PlusOneFirstAttempt(vector<int> A) {
+  vector<int> result;
+  bool carry = true;
+
+  for (int i = A.size() - 1; i >= 0; i--) {
+    int val = carry ? (A[i] + 1) % 10 : A[i];
+    result.push_back(val);
+    carry = (carry && (A[i] == 9));
+  }
+  if (carry) {
+    result.push_back(1);
+  }
+  std::reverse(result.begin(), result.end());
+  return result;
+}
+
 vector<int> PlusOne(vector<int> A) {
-  // TODO - you fill in here.
-  return {};
+  int i = A.size() - 1;
+  bool carry = true;
+
+  while (i >= 0) {
+    A[i] = (A[i] + (carry ? 1 : 0)) % 10;
+    carry = carry && (A[i] == 0);
+    i--;
+  }
+  if (carry) {
+    A[0] = 1;
+    A.push_back(0);
+  }
+  return A;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/problem_mapping.js

@@ -186,29 +186,29 @@ problem_mapping = {
         },
         "5.01 The Dutch national flag problem": {
             "C++: dutch_national_flag.cc": {
-                "passed": 1,
+                "passed": 204,
                 "total": 204
             },
             "Java: DutchNationalFlag.java": {
                 "passed": 0,
                 "total": 204
             },
             "Python: dutch_national_flag.py": {
-                "passed": 0,
+                "passed": 204,
                 "total": 204
             }
         },
         "5.02 Increment an arbitrary-precision integer": {
             "C++: int_as_array_increment.cc": {
-                "passed": 0,
+                "passed": 505,
                 "total": 505
             },
             "Java: IntAsArrayIncrement.java": {
                 "passed": 0,
                 "total": 505
             },
             "Python: int_as_array_increment.py": {
-                "passed": 0,
+                "passed": 505,
                 "total": 505
             }
         },

elements-of-programming-interviews/python/dutch_national_flag.py

@@ -8,8 +8,22 @@
 RED, WHITE, BLUE = range(3)
 
 
+def pivot_sort(A, left, test_fn):
+    curr = left
+    while curr < len(A):
+        if test_fn(A[curr]):
+            tmp = A[left]
+            A[left] = A[curr]
+            A[curr] = tmp
+            left += 1
+        curr += 1
+    return left
+
+
 def dutch_flag_partition(pivot_index: int, A: List[int]) -> None:
-    # TODO - you fill in here.
+    val = A[pivot_index]
+    left = pivot_sort(A, 0, lambda x: x < val)
+    pivot_sort(A, left, lambda x: x == val)
     return
 
 
@@ -40,7 +54,15 @@ def dutch_flag_partition_wrapper(executor, A, pivot_idx):
 
 
 if __name__ == '__main__':
+    import random
+    arr = [random.randint(-100, 100) for _ in range(100)]
+    partition = 20
+    print(f"Partitioning on {arr[partition]}")
+    dutch_flag_partition(partition, arr)
+    print(arr)
+    """
     exit(
         generic_test.generic_test_main('dutch_national_flag.py',
                                        'dutch_national_flag.tsv',
                                        dutch_flag_partition_wrapper))
+    """

elements-of-programming-interviews/python/int_as_array_increment.py

@@ -4,8 +4,10 @@
 
 
 def plus_one(A: List[int]) -> List[int]:
-    # TODO - you fill in here.
-    return []
+    # haha list comprehension go brrr
+    # (see my c++ solution for a more traditional answer)
+    val = int("".join([str(val) for val in A])) + 1
+    return [int(char) for char in list(str(val))]
 
 
 if __name__ == '__main__':