Add 5 more solutions for array/string problems and 4 solutions for common two-pointers problems

Author: teamlead

.gitignore

@@ -1,3 +1,4 @@
 .idea
 out
 src/**/*.md
+tmp

.run/Solution.run.xml

@@ -0,0 +1,16 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="CanPlaceFlowers" type="Application" factoryName="Application" nameIsGenerated="true">
+    <option name="MAIN_CLASS_NAME" value="array_string.CanPlaceFlowers" />
+    <module name="leetcode-75-qs-solutions-java" />
+    <option name="VM_PARAMETERS" value="-ea" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="array_string.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>

.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "java",
+            "name": "Current File",
+            "request": "launch",
+            "mainClass": "${file}",
+            "vmArgs": "-ea"
+        }
+    ]
+}

README.md

@@ -65,16 +65,23 @@ leetcode-75-solutions-java/
 
 | Category       | Problem                                                                                                             | Solution                                                                                    | Difficulty |
 |----------------|---------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|------------|
-| Array / String | [Merge Strings Alternately](https://leetcode.com/problems/merge-strings-alternately/)                               | [MergeStringsAlternately.java](src/array_string/MergeStringsAlternately.java)               | Easy       |            |
-| Array / String | [Greatest Common Divisor of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings/)             | [GreatestCommonDivisorOfStrings.java](src/array_string/GreatestCommonDivisorOfStrings.java) | Easy       |            |
-| Array / String | [Kids With the Greatest Number of Candies](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/) | [GreatestNumberOfCandies.java](src/array_string/GreatestNumberOfCandies.java)               | Easy       |            |
-| Array / String | [Can Place Flowers](https://leetcode.com/problems/can-place-flowers/)                                               | [CanPlaceFlowers.java](src/array_string/CanPlaceFlowers.java)                               | Easy       |            |
-| Array / String | [Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/)                             | [ReverseVowelsOfString.java](src/array_string/ReverseVowelsOfString.java)                   | Easy       |            |
-| Array / String | [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/)                               | [ReverseWordsInString.java](src/array_string/ReverseWordsInString.java)                     | Medium     |            |
-| ...            | ...                                                                                                                 | ...                                                                                         | ...        |            |
-| Trie           | [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree)                            | [PrefixTrie.java](src/trie/PrefixTrie.java)                                                 | Medium     |            |
-| Trie           | [Search Suggestions System](https://leetcode.com/problems/search-suggestions-system)                                | [SearchSuggestionsSystem.java](src/trie/SearchSuggestionsSystem.java)                       | Medium     |            |
-| ...            | ...                                                                                                                 | ...                                                                                         | ...        |            |
+| Array / String | [Merge Strings Alternately](https://leetcode.com/problems/merge-strings-alternately/)                               | [MergeStringsAlternately.java](src/array_string/MergeStringsAlternately.java)               | Easy       |
+| Array / String | [Greatest Common Divisor of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings/)             | [GreatestCommonDivisorOfStrings.java](src/array_string/GreatestCommonDivisorOfStrings.java) | Easy       |
+| Array / String | [Kids With the Greatest Number of Candies](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/) | [GreatestNumberOfCandies.java](src/array_string/GreatestNumberOfCandies.java)               | Easy       |
+| Array / String | [Can Place Flowers](https://leetcode.com/problems/can-place-flowers/)                                               | [CanPlaceFlowers.java](src/array_string/CanPlaceFlowers.java)                               | Easy       |
+| Array / String | [Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/)                             | [ReverseVowelsOfString.java](src/array_string/ReverseVowelsOfString.java)                   | Easy       |
+| Array / String | [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/)                               | [ReverseWordsInString.java](src/array_string/ReverseWordsInString.java)                     | Medium     |
+| Array / String | [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)                         | [ProductExceptSelf.java](src/array_string/ProductExceptSelf.java)                           | Medium     | 
+| Array / String | [Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/)                     | [IncreasingTriplet.java](src/array_string/IncreasingTriplet.java)                           | Medium     |
+| Array / String | [String Compression](https://leetcode.com/problems/string-compression/)                                             | [StringCompressor.java](src/array_string/StringCompressor.java)                             | Medium     |
+| Two Pointers   | [Move Zeroes](https://leetcode.com/problems/move-zeroes/)                                                           | [ZeroMover.java](src/two_pointers/ZeroMover.java)                                           | Easy       |
+| Two Pointers   | [Is Subsequence](https://leetcode.com/problems/is-subsequence/)                                                     | [SubsequenceChecker.java](src/two_pointers/SubsequenceChecker.java)                         | Easy       |
+| Two Pointers   | [Container With Most Water](https://leetcode.com/problems/container-with-most-water/)                               | [WaterContainer.java](src/two_pointers/WaterContainer.java)                                 | Medium     |
+| Two Pointers   | [Max Number of K-Sum Pairs](https://leetcode.com/problems/max-number-of-k-sum-pairs/)                               | [MaxOperationsCounter.java](src/two_pointers/MaxOperationsCounter.java)                     | Medium     |
+| ...            | ...                                                                                                                 | ...                                                                                         | ...        |
+| Trie           | [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree)                            | [PrefixTrie.java](src/trie/PrefixTrie.java)                                                 | Medium     |
+| Trie           | [Search Suggestions System](https://leetcode.com/problems/search-suggestions-system)                                | [SearchSuggestionsSystem.java](src/trie/SearchSuggestionsSystem.java)                       | Medium     |
+| ...            | ...                                                                                                                 | ...                                                                                         | ...        |
 
 ## Usage
 
@@ -98,7 +105,13 @@ javac ProblemName.java
 java -ea ProblemName
 ```
 
-If using IDEA, right-click the src folder, then select "Mark Directory" as "Sources Root". Now, Java files should benefit from all the Java IDE features of IntelliJ IDEA, including autocomplete, syntax highlighting, and more.
+or if you use Java11+ run the source code file directly, without intermediate compilation:
+
+```bash
+java -ea ProblemName.java
+```
+
+If using IDEA, right-click the src folder, then select **"Mark Directory"** as **"Sources Root"**. Now, Java files should benefit from all the Java IDE features of IntelliJ IDEA, including autocomplete, debug, syntax highlighting, and more.
 
 Remember, when using assertions in Java, ensure that you've enabled them by using the `-ea` flag when running the Java program.
 

src/array_string/CanPlaceFlowers.java

@@ -30,4 +30,5 @@ public static void main(String[] args) {
 
         System.out.println("All tests passed!");
     }
+
 }

src/array_string/IncreasingTriplet.java

@@ -0,0 +1,34 @@
+package array_string;
+
+public class IncreasingTriplet {
+
+    public boolean hasIncreasingTriplet(int[] numbers) {
+        int firstMin = Integer.MAX_VALUE, secondMin = Integer.MAX_VALUE;
+        for (int number : numbers) {
+            if (number <= firstMin) {
+                firstMin = number;
+            } else if (number <= secondMin) {
+                secondMin = number;
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+
+        IncreasingTriplet checker = new IncreasingTriplet();
+
+        int[] testInput1 = {1,2,3,4,5};
+        assert checker.hasIncreasingTriplet(testInput1) == true : "Test case 1 failed";
+
+        int[] testInput2 = {5,4,3,2,1};
+        assert checker.hasIncreasingTriplet(testInput2) == false : "Test case 2 failed";
+
+        int[] testInput3 = {2,1,5,0,4,6};
+        assert checker.hasIncreasingTriplet(testInput3) == true : "Test case 3 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/array_string/ProductExceptSelf.java

@@ -0,0 +1,42 @@
+package array_string;
+
+public class ProductExceptSelf {
+
+    public int[] calculateProduct(int[] nums) {
+        int length = nums.length;
+        int[] result = new int[length];
+
+        int leftMultiplier = 1;
+        for (int idx = 0; idx < length; idx++) {
+            if (idx > 0) {
+                leftMultiplier = leftMultiplier * nums[idx - 1];
+            }
+            result[idx] = leftMultiplier;
+        }
+
+        int rightMultiplier = 1;
+        for (int idx = length - 1; idx >= 0; idx--) {
+            if (idx < length - 1) {
+                rightMultiplier = rightMultiplier * nums[idx + 1];
+            }
+            result[idx] *= rightMultiplier;
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+
+        ProductExceptSelf calculator = new ProductExceptSelf();
+
+        int[] testInput1 = {1,2,3,4};
+        int[] expectedOutput1 = {24,12,8,6};
+        assert java.util.Arrays.equals(calculator.calculateProduct(testInput1), expectedOutput1) : "Test case 1 failed";
+
+        int[] testInput2 = {-1,1,0,-3,3};
+        int[] expectedOutput2 = {0,0,9,0,0};
+        assert java.util.Arrays.equals(calculator.calculateProduct(testInput2), expectedOutput2) : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/array_string/ReverseWordsInString.java

@@ -23,7 +23,6 @@ public String reverseWords(String input) {
     public static void main(String[] args) {
         ReverseWordsInString reverser = new ReverseWordsInString();
 
-        // Sample assertions
         assert reverser.reverseWords("the sky is blue").equals("blue is sky the") : "Test case 1 failed";
         assert reverser.reverseWords("  hello world  ").equals("world hello") : "Test case 2 failed";
         assert reverser.reverseWords("a good   example").equals("example good a") : "Test case 3 failed";

src/array_string/StringCompressor.java

@@ -0,0 +1,40 @@
+package array_string;
+
+public class StringCompressor {
+
+    public int compress(char[] chars) {
+        int writeIdx = 0;  // index to write the compressed result
+        int readIdx = 0;   // index to read from the original array
+        while (readIdx < chars.length) {
+            char current = chars[readIdx];
+            int freq = 0;
+            while (readIdx < chars.length && chars[readIdx] == current) {
+                readIdx++;
+                freq++;
+            }
+            chars[writeIdx++] = current;
+            if (freq > 1) {
+                for (char ch : Integer.toString(freq).toCharArray()) {
+                    chars[writeIdx++] = ch;
+                }
+            }
+        }
+        return writeIdx;
+    }
+
+    public static void main(String[] args) {
+
+        StringCompressor compressor = new StringCompressor();
+
+        char[] testInput1 = {'a','a','b','b','c','c','c'};
+        assert compressor.compress(testInput1) == 6 && new String(testInput1, 0, 6).equals("a2b2c3") : "Test case 1 failed";
+
+        char[] testInput2 = {'a'};
+        assert compressor.compress(testInput2) == 1 && new String(testInput2, 0, 1).equals("a") : "Test case 2 failed";
+
+        char[] testInput3 = {'a','b','b','b','b','b','b','b','b','b','b','b','b'};
+        assert compressor.compress(testInput3) == 4 && new String(testInput3, 0, 4).equals("ab12") : "Test case 3 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/two_pointers/MaxOperationsCounter.java

@@ -0,0 +1,32 @@
+package two_pointers;
+
+import java.util.HashMap;
+
+public class MaxOperationsCounter {
+
+    public int maxOperations(int[] nums, int k) {
+        HashMap<Integer, Integer> numberCount = new HashMap<>();
+        int operations = 0;
+
+        for (int num : nums) {
+            if (numberCount.getOrDefault(k - num, 0) > 0) {
+                operations++;
+                numberCount.put(k - num, numberCount.get(k - num) - 1);
+            } else {
+                numberCount.put(num, numberCount.getOrDefault(num, 0) + 1);
+            }
+        }
+
+        return operations;
+    }
+
+    public static void main(String[] args) {
+
+        MaxOperationsCounter counter = new MaxOperationsCounter();
+
+        assert counter.maxOperations(new int[]{1,2,3,4}, 5) == 2 : "Test case 1 failed";
+        assert counter.maxOperations(new int[]{3,1,3,4,3}, 6) == 1 : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/two_pointers/SubsequenceChecker.java

@@ -0,0 +1,28 @@
+package two_pointers;
+
+public class SubsequenceChecker {
+
+    public boolean isSubsequence(String sub, String mainStr) {
+        if (sub.isEmpty()) return true;
+        int subIndex = 0, mainIndex = 0;
+
+        while (mainIndex < mainStr.length()) {
+            if (mainStr.charAt(mainIndex) == sub.charAt(subIndex)) {
+                subIndex++;
+                if (subIndex == sub.length()) return true;
+            }
+            mainIndex++;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+
+        SubsequenceChecker checker = new SubsequenceChecker();
+
+        assert checker.isSubsequence("abc", "ahbgdc") : "Test case 1 failed";
+        assert !checker.isSubsequence("axc", "ahbgdc") : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/two_pointers/WaterContainer.java

@@ -0,0 +1,36 @@
+package two_pointers;
+
+public class WaterContainer {
+
+    public int maxArea(int[] heights) {
+        int start = 0;
+        int end = heights.length - 1;
+        int maxVolume = 0;
+
+        while(start < end) {
+            int width = end - start;
+            int height = Math.min(heights[start], heights[end]);
+            int volume = height * width;
+
+            maxVolume = Math.max(maxVolume, volume);
+
+            if(heights[start] < heights[end]) {
+                start++;
+            } else {
+                end--;
+            }
+        }
+
+        return maxVolume;
+    }
+
+    public static void main(String[] args) {
+
+        WaterContainer container = new WaterContainer();
+
+        assert container.maxArea(new int[]{1,8,6,2,5,4,8,3,7}) == 49 : "Test case 1 failed";
+        assert container.maxArea(new int[]{1,1}) == 1 : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/two_pointers/ZeroMover.java

@@ -0,0 +1,35 @@
+package two_pointers;
+
+public class ZeroMover {
+
+    public void moveZeroes(int[] arr) {
+        int nonZeroIndex = 0;
+
+        for (int num : arr) {
+            if (num != 0) {
+                arr[nonZeroIndex] = num;
+                nonZeroIndex++;
+            }
+        }
+
+        while (nonZeroIndex < arr.length) {
+            arr[nonZeroIndex] = 0;
+            nonZeroIndex++;
+        }
+    }
+
+    public static void main(String[] args) {
+
+        ZeroMover mover = new ZeroMover();
+
+        int[] testInput1 = {0,1,0,3,12};
+        mover.moveZeroes(testInput1);
+        assert java.util.Arrays.equals(testInput1, new int[]{1,3,12,0,0}) : "Test case 1 failed";
+
+        int[] testInput2 = {0};
+        mover.moveZeroes(testInput2);
+        assert java.util.Arrays.equals(testInput2, new int[]{0}) : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}