Add complete support (rough-untested) for Java and C++

Author: jwl-7

src/code/cpp/array/prefix_sum.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+
+vector<int> fn(vector<int>& arr) {
+    int n = arr.size();
+    vector<int> prefix;
+    prefix.push_back(arr[0]);
+
+    for (int i = 1; i < n; ++i) {
+        prefix.push_back(prefix.back() + arr[i]);
+    }
+
+    return prefix;
+}

src/code/cpp/array/sliding_window.cpp

@@ -0,0 +1,26 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr) {
+    int n = arr.size();
+    int window = 0;
+    int left = 0;
+    int ans = 0;
+
+    for (int right = 0; right < n; right++) {
+        // TODO: add arr[right] to window
+        window += arr[right];
+
+        while (WINDOW_CONDITION_BROKEN) {
+            // TODO: remove arr[left] from window
+            window -= arr[left];
+            left += 1;
+        }
+
+        // TODO: update ans
+    }
+
+    return ans;
+}

src/code/cpp/array/string_building.cpp

@@ -0,0 +1,3 @@
+string fn(vector<char>& arr) {
+    return string(arr.begin(), arr.end())
+}

src/code/cpp/array/two_pointers_one_input.cpp

@@ -0,0 +1,21 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr) {
+    int ans = 0;
+    int left = 0;
+    int right = arr.size() - 1;
+
+    while (left < right) {
+        // TODO: logic with left and right
+        if (CONDITION) {
+            left += 1;
+        } else {
+            right -= 1;
+        }
+    }
+
+    return ans;
+}

src/code/cpp/array/two_pointers_two_inputs.cpp

@@ -0,0 +1,31 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr1, vector<int>& arr2) {
+    int i = 0;
+    int j = 0;
+    int ans = 0;
+
+    while (i < arr1.size() && j < arr2.size()) {
+        // TODO: logic
+        if (CONDITION) {
+            i += 1;
+        } else {
+            j += 1;
+        }
+    }
+
+    while (i < arr1.size()) {
+        // TODO: logic
+        i += 1;
+    }
+
+    while (j < arr2.size()) {
+        // TODO: logic
+        j += 1;
+    }
+
+    return ans;
+}

src/code/cpp/backtracking/backtracking.cpp

@@ -0,0 +1,16 @@
+int backtrack(int curr, OTHER_ARGUMENTS...) {
+    if (BASE_CASE) {
+        // TODO: modify answer
+        return 0;
+    }
+
+    int ans = 0;
+
+    for (ITERATE_OVER_INPUT) {
+        // TODO: modify current state
+        ans += backtrack(curr, OTHER_ARGUMENTS...);
+        // TODO: undo modification of current state
+    }
+
+    return ans;
+}

src/code/cpp/binary_search/binary_search.cpp

@@ -0,0 +1,25 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr, int target) {
+    int left = 0;
+    int right = arr.size() - 1;
+
+    while (left <= right) {
+        int mid = left + (right - left) / 2;
+
+        if (arr[mid] == target) {
+            // TODO: logic
+            return;
+        }
+        if (arr[mid] > target) {
+            right = mid - 1;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return left;
+}

src/code/cpp/binary_search/duplicate_elements_left_insertion.cpp

@@ -0,0 +1,21 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr, int target) {
+    int left = 0;
+    int right = arr.size();
+
+    while (left < right) {
+        int mid = left + (right - left) / 2;
+
+        if (arr[mid] >= target) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return left;
+}

src/code/cpp/binary_search/duplicate_elements_right_insertion.cpp

@@ -0,0 +1,21 @@
+#include <vector>
+
+using namespace std;
+
+
+int fn(vector<int>& arr, int target) {
+    int left = 0;
+    int right = arr.size();
+
+    while (left < right) {
+        int mid = left + (right - left) / 2;
+
+        if (arr[mid] > target) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return left;
+}

src/code/cpp/binary_search/greedy_maximum.cpp

@@ -0,0 +1,25 @@
+#include <vector>
+
+using namespace std;
+
+
+bool check(int x) {
+    return BOOLEAN;
+}
+
+int fn(vector<int>& arr) {
+    int left = MINIMUM_POSSIBLE_ANSWER;
+    int right = MAXIMUM_POSSIBLE_ANSWER;
+
+    while (left <= right) {
+        int mid = left + (right - left) / 2;
+
+        if (check(mid)) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+
+    return right;
+}