Merge pull request ByteByteGoHq#7 from w22116972/java-solutions-two-pointers

Add Java implementations and tests on Chapter 1 Two Pointers

Author: Destiny-02

java/Two Pointers/IsPalindromeValid.java

@@ -0,0 +1,27 @@
+public class IsPalindromeValid {
+
+    public boolean isPalindromeValid(String s) {
+        int left = 0;
+        int right = s.length() - 1;
+        while (left < right) {
+            // Skip non-alphanumeric characters from the left.
+            // Note: isLetterOrDigit() can't handle characters that could not be represented in the original 16-bit design of Unicode.
+            // e.g. emoji characters
+            // Note: str.charAt returns value of the string at the specified index. The data type is char.
+            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
+                left++;
+            }
+            // Skip non-alphanumeric characters from the right.
+            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
+                right--;
+            }
+            // If the characters at the left and right pointers don't match, the string is not a palindrome.
+            if (s.charAt(left) != s.charAt(right)) {
+                return false;
+            }
+            left++;
+            right--;
+        }
+        return true;
+    }
+}

java/Two Pointers/LargestContainer.java

@@ -0,0 +1,23 @@
+public class LargestContainer {
+    public int largestContainer(int[] height) {
+        int maxWater = 0;
+        int left = 0;
+        int right = height.length - 1;
+        while (left < right) {
+            // Calculate the water contained between the current pair of lines.
+            int water = Math.min(height[left], height[right]) * (right - left);
+            maxWater = Math.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 (height[left] < height[right]) {
+                left++;
+            } else if (height[left] > height[right]) {
+                right--;
+            } else {
+                left++;
+                right--;
+            }
+        }
+        return maxWater;
+    }
+}

java/Two Pointers/LargestContainerBruteForce.java

@@ -0,0 +1,16 @@
+public class LargestContainerBruteForce {
+    public int largestContainerBruteForce(int[] height) {
+        int n = height.length;
+        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++) {
+                // Calculate the area of the container formed by the lines at indexes i and j.
+                int water = Math.min(height[i], height[j]) * (j - i);
+                // Update the maximum amount of water stored.
+                maxWater = Math.max(maxWater, water);
+            }
+        }
+        return maxWater;
+    }
+ }

java/Two Pointers/NextLexicographicalSequence.java

@@ -0,0 +1,41 @@
+public class NextLexicographicalSequence {
+    public String nextLexicographicalSequence(String s) {
+        char[] letters = s.toCharArray();
+        // 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.length() - 2;
+        while (pivot >= 0 && letters[pivot] >= letters[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) {
+            reverseCharArray(letters, 0, letters.length - 1);
+            return new String(letters);
+        }
+        // Find the rightmost successor to the pivot.
+        int rightMostSuccessor = s.length() - 1;
+        while (letters[rightMostSuccessor] <= letters[pivot]) {
+            rightMostSuccessor--;
+        }
+        // Swap the rightmost successor with the pivot to increase the lexicographical order of the suffix.
+        char temp = letters[pivot];
+        letters[pivot] = letters[rightMostSuccessor];
+        letters[rightMostSuccessor] = temp;
+
+        // Reverse the suffix after the pivot to minimize its permutation.
+        reverseCharArray(letters, pivot + 1, letters.length - 1);
+        return new String(letters);
+    }
+
+    public void reverseCharArray(char[] chars, int start, int end) {
+        while (start < end) {
+            char temp = chars[start];
+            chars[start] = chars[end];
+            chars[end] = temp;
+
+            start++;
+            end--;
+        }
+    }
+}

java/Two Pointers/PairSumSorted.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+public class PairSumSorted {
+    public int[] pairSumSorted(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 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++;
+            } else if (sum > target) { // If the sum is larger, decrement the right pointer, aiming to decrease the sum toward the target value.
+                right--;
+            } else { // If the target pair is found, return its indexes.
+                return new int[] {left, right};
+            }
+        }
+        return new int[] {};
+    }
+}

java/Two Pointers/PairSumSortedBruteForce.java

@@ -0,0 +1,15 @@
+import java.util.Arrays;
+
+public class PairSumSortedBruteForce {
+    public  int[] pairSumSortedBruteForce(int[] nums, int target) {
+        int n = nums.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[] {i, j};
+                }
+            }
+        }
+        return new int[] {};
+    }
+}

java/Two Pointers/ShiftZerosToTheEnd.java

@@ -0,0 +1,17 @@
+public class ShiftZerosToTheEnd {
+    public void shiftZerosToTheEnd(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.length; right++) {
+            // If the element at the 'right' pointer is non-zero, swap it with the element at the 'left' pointer.
+            if (nums[right] != 0) {
+                int temp = nums[left];
+                nums[left] = nums[right];
+                nums[right] = temp;
+                // Increment 'left' since it now points to a position already occupied by a non-zero element.
+                left++;
+            }
+        }
+    }
+}

java/Two Pointers/ShiftZerosToTheEndNaive.java

@@ -0,0 +1,19 @@
+import java.util.Arrays;
+
+public class ShiftZerosToTheEndNaive {
+    public void shiftZerosToTheEndNaive(int[] nums) {
+        int[] temp = new int[nums.length];
+        int i = 0;
+        // Add all non-zero elements to the left of 'temp'.
+        for (int num : nums) {
+            if (num != 0) {
+                temp[i] = num;
+                i++;
+            }
+        }
+        // Copy 'temp' array to 'nums' array
+        // Note: `System.arraycopy` Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array.
+        System.arraycopy(temp, 0, nums, 0, nums.length);
+    }
+
+}

java/Two Pointers/TripletSum.java

@@ -0,0 +1,48 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class TripletSum {
+    public List<List<Integer>> tripletSum(int[] nums) {
+        List<List<Integer>> triplets = new ArrayList<>();
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length - 1; 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]).
+            List<List<Integer>> pairs = pairSumSortedAllPairs(nums, i + 1, -nums[i]);
+            for (List<Integer> pair : pairs) {
+                // Note: Arrays.asList() creates a fixed-size list by passing the arguments.
+                triplets.add(Arrays.asList(nums[i], pair.get(0), pair.get(1)));
+            }
+        }
+        return triplets;
+    }
+
+    public List<List<Integer>> pairSumSortedAllPairs(int[] nums, int start, int target) {
+        List<List<Integer>> pairs = new ArrayList<>();
+        int left = start, right = nums.length - 1;
+        while (left < right) {
+            int sum = nums[left] + nums[right];
+            if (sum == target) {
+                pairs.add(Arrays.asList(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;
+    }
+}

java/Two Pointers/TripletSumBruteForce.java

@@ -0,0 +1,25 @@
+import java.util.*;
+
+public class TripletSumBruteForce {
+    public List<List<Integer>> tripletSumBruteForce(int[] nums) {
+        int n = nums.length;
+        // Use a hash set to ensure we don't add duplicate triplets.
+        Set<List<Integer>> triplets = new HashSet<>();
+
+        // 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.
+                        List<Integer> triplet = Arrays.asList(nums[i], nums[j], nums[k]);
+                        Collections.sort(triplet);
+                        triplets.add(triplet);
+                    }
+                }
+            }
+        }
+        // Convert the HashSet to a List of Lists.
+        return new ArrayList<>(triplets);
+    }
+}