Merge pull request ByteByteGoHq#5 from ongshunping/cpp-solutions-two-pointers

Add C++ solutions for Chapter 1 (Two Pointers)

Author: Destiny-02

cpp/Two Pointers/is_palindrome_valid.cpp

@@ -0,0 +1,25 @@
+#include <cctype>
+#include <string>
+
+bool isPalindromeValid(std::string s) {
+    int left = 0;
+    int right = s.length() - 1;
+    while (left < right) {
+        // Skip non-alphanumeric characters from the left.
+        while (left < right && !std::isalnum(s[left])) {
+            left++;
+        }
+        // Skip non-alphanumeric characters from the right.
+        while (left < right && !std::isalnum(s[right])) {
+            right--;
+        }
+        // If the characters at the left and right pointers don't
+        // match, the string is not a palindrome.  
+        if (s[left] != s[right]) {
+            return false;
+        }
+        left++;
+        right--;
+    }
+    return true;
+}

cpp/Two Pointers/largest_container.cpp

@@ -0,0 +1,26 @@
+#include <algorithm> 
+#include <vector>
+
+int largestContainer(std::vector<int>& heights) {
+    int maxWater = 0;
+    int left = 0;
+    int right = heights.size() - 1;
+    while (left < right) {
+        // Calculate the water contained between the current pair of 
+        // lines. 
+        int water = std::min(heights[left], heights[right]) * (right - left); 
+        maxWater = std::max(maxWater, water);
+        // Move the pointers inward, always moving the pointer at the 
+        // shorter line. If both lines have the same height, move both 
+        // pointers inward.
+        if (heights[left] < heights[right]) {
+            left++;
+        } else if (heights[left] > heights[right]) {
+            right--;
+        } else {
+            left++;
+            right--;
+        }
+    }
+    return maxWater;
+}

cpp/Two Pointers/largest_container_brute_force.cpp

@@ -0,0 +1,16 @@
+#include <algorithm>
+#include <vector>
+
+int largestContainerBruteForce(std::vector<int>& heights) {
+    int n = heights.size();
+    int maxWater = 0;
+    // Find the maximum amount of water stored between all pairs of 
+    // lines. 
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            int water = std::min(heights[i], heights[j]) * (j - i);
+            maxWater = std::max(maxWater, water);
+        }
+    }
+    return maxWater;
+}

cpp/Two Pointers/next_lexicographical_sequence.cpp

@@ -0,0 +1,28 @@
+#include <algorithm>
+#include <string>
+
+std::string nextLexicographicalSequence(std::string s) {
+    // Locate the pivot, which is the first character from the right that breaks
+    // non-increasing order. Start searching from the second-to-last position.
+    int pivot = s.size() - 2;
+    while (pivot >= 0 && s[pivot] >= s[pivot + 1]) {
+        pivot --;
+    }
+    // If pivot is not found, the string is already in its largest permutation.
+    // In this case, reverse the string to obtain the smallest permutation.
+    if (pivot == -1) {
+        std::reverse(s.begin(), s.end());
+        return s;
+    }
+    // Find the rightmost successor to the pivot.
+    int rightMostSuccessor = s.size() - 1;
+    while (s[rightMostSuccessor] <= s[pivot]) {
+        rightMostSuccessor--;
+    }
+    // Swap the rightmost successor with the pivot to increase the lexicographical
+    // order of the suffix.
+    std::swap(s[pivot], s[rightMostSuccessor]);
+    // Reverse the suffix after the pivot to minimize its permutation.
+    std::reverse(s.begin() + pivot + 1, s.end());
+    return s;
+}

cpp/Two Pointers/pair_sum_sorted.cpp

@@ -0,0 +1,23 @@
+#include <vector>
+
+std::vector<int> pairSumSorted(std::vector<int>& nums, int target) {
+    int left = 0;
+    int right = nums.size() - 1;
+    while (left < right) {
+        int sum = nums[left] + nums[right];
+        // If the sum is smaller, increment the left pointer, aiming
+        // to increase the sum toward the target value.
+        if (sum < target) {
+            left++;
+        // If the sum is larger, decrement the right pointer, aiming
+        // to decrease the sum toward the target value.
+        } else if (sum > target) {
+            right--;
+        // If the target pair is found, return its indexes.
+        } else {
+            return {left, right};
+        }
+    }
+    // If no valid pair is found, return an empty vector. 
+    return {};
+}

cpp/Two Pointers/pair_sum_sorted_brute_force.cpp

@@ -0,0 +1,13 @@
+#include <vector>
+
+std::vector<int> pairSumSortedBruteForce(std::vector<int>& nums, int target) {
+    int n = nums.size();
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if (nums[i] + nums[j] == target) {
+                return {i, j};
+            }
+        }
+    }
+    return {};
+}

cpp/Two Pointers/shift_zeros_to_the_end.cpp

@@ -0,0 +1,17 @@
+#include <algorithm>
+#include <vector>
+
+void shiftZerosToTheEnd(std::vector<int>& nums) {
+    // The 'left' pointer is used to position non-zero elements.
+    int left = 0;
+    // Iterate through the array using a 'right' pointer to locate non-zero 
+    // elements.
+    for (int right = 0; right < nums.size(); right++) {
+        if (nums[right] != 0) {
+            std::swap(nums[left], nums[right]);
+            // Increment 'left' since it now points to a position already occupied 
+            // by a non-zero element.
+            left++;
+        }
+    }
+}

cpp/Two Pointers/shift_zeros_to_the_end_naive.cpp

@@ -0,0 +1,17 @@
+#include <vector>
+
+void shiftZerosToTheEndNaive(std::vector<int>& nums) {
+    std::vector<int> temp(nums.size(), 0);
+    int i = 0;
+    // Add all non-zero elements to the left of 'temp'.
+    for (int num : nums) {
+        if (num != 0) {
+            temp[i] = num;
+            i++;
+        }
+    }
+    // Set 'nums' to 'temp'.    
+    for (int j = 0; j < nums.size(); j++) {
+        nums[j] = temp[j];
+    }
+}

cpp/Two Pointers/triplet_sum.cpp

@@ -0,0 +1,51 @@
+#include <algorithm>
+#include <vector>
+
+// Helper function to find all pairs that sum to a target in a sorted array
+std::vector<std::vector<int>> pairSumSortedAllPairs(std::vector<int>& nums, int start, int target);
+
+std::vector<std::vector<int>> tripletSum(std::vector<int>& nums) {
+    std::vector<std::vector<int>> triplets;
+    std::sort(nums.begin(), nums.end());
+    for (int i = 0; i < nums.size(); i++) {
+        // Optimization: triplets consisting of only positive numbers 
+        // will never sum to 0.
+        if (nums[i] > 0) {
+            break;
+        }
+        // To avoid duplicate triplets, skip 'a' if it's the same as 
+        // the previous number.        
+        if (i > 0 && nums[i] == nums[i - 1]) {
+            continue;
+        }
+        // Find all pairs that sum to a target of '-a' (-nums[i]).
+        std::vector<std::vector<int>> pairs = pairSumSortedAllPairs(nums, i + 1, -nums[i]);
+        for (auto& pair : pairs) {
+            triplets.push_back({nums[i], pair[0], pair[1]});
+        }
+    }
+    return triplets;
+}
+
+std::vector<std::vector<int>> pairSumSortedAllPairs(std::vector<int>& nums, int start, int target) {
+    std::vector<std::vector<int>> pairs;
+    int left = start;
+    int right = nums.size() - 1;
+    while (left < right) {
+        int sum = nums[left] + nums[right];
+        if (sum == target) {
+            pairs.push_back({nums[left], nums[right]});
+            left++;
+            // To avoid duplicate '[b, c]' pairs, skip 'b' if it's the 
+            // same as the previous number.
+            while (left < right && nums[left] == nums[left - 1]) {
+                left++;
+            }
+        } else if (sum < target) {
+            left++;
+        } else {
+            right--;
+        }
+    }
+    return pairs;
+}

cpp/Two Pointers/triplet_sum_brute_force.cpp

@@ -0,0 +1,24 @@
+#include <algorithm> 
+#include <set>       
+#include <vector>
+
+std::vector<std::vector<int>> tripletSumBruteForce(std::vector<int>& nums) {
+    int n = nums.size();
+    // Use a hash set to ensure we don't add duplicate triplets.
+    std::set<std::vector<int>> triplets;
+    // Iterate through the indexes of all triplets.
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            for (int k = j + 1; k < n; k++) {
+                if (nums[i] + nums[j] + nums[k] == 0) {
+                    // Sort the triplet before including it in the 
+                    // hash set.
+                    std::vector<int> triplet = {nums[i], nums[j], nums[k]};
+                    std::sort(triplet.begin(), triplet.end());
+                    triplets.insert(triplet);
+                }
+            }
+        }
+    }
+    return {triplets.begin(), triplets.end()};
+}