Added solutions 11-25

Author: javadev

src/main/java/g0001_0100/s0011_container_with_most_water/readme.md

@@ -38,4 +38,60 @@ Given `n` non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n
 
 * `n == height.length`
 * <code>2 <= n <= 10<sup>5</sup></code>
-* <code>0 <= height[i] <= 10<sup>4</sup></code>
+* <code>0 <= height[i] <= 10<sup>4</sup></code>
+
+To solve the Container With Most Water problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `maxArea` that takes an array of integers `height` as input and returns the maximum area of water that can be contained.
+2. Initialize two pointers, `left` pointing to the start of the array and `right` pointing to the end of the array.
+3. Initialize a variable `maxArea` to store the maximum area encountered so far, initially set to 0.
+4. Iterate while `left` is less than `right`.
+5. Calculate the current area using the formula: `(right - left) * min(height[left], height[right])`.
+6. Update `maxArea` if the current area is greater than `maxArea`.
+7. Move the pointer pointing to the smaller height towards the other pointer. If `height[left] < height[right]`, increment `left`, otherwise decrement `right`.
+8. Continue the iteration until `left` becomes greater than or equal to `right`.
+9. Return `maxArea`.
+
+Here's the implementation:
+
+```java
+public class Solution {
+ public int maxArea(int[] height) {
+ int left = 0;
+ int right = height.length - 1;
+ int maxArea = 0;
+
+ while (left < right) {
+ int currentArea = (right - left) * Math.min(height[left], height[right]);
+ maxArea = Math.max(maxArea, currentArea);
+
+ if (height[left] < height[right]) {
+ left++;
+ } else {
+ right--;
+ }
+ }
+
+ return maxArea;
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ // Test cases
+ int[] height1 = {1, 8, 6, 2, 5, 4, 8, 3, 7};
+ System.out.println("Example 1 Output: " + solution.maxArea(height1));
+
+ int[] height2 = {1, 1};
+ System.out.println("Example 2 Output: " + solution.maxArea(height2));
+
+ int[] height3 = {4, 3, 2, 1, 4};
+ System.out.println("Example 3 Output: " + solution.maxArea(height3));
+
+ int[] height4 = {1, 2, 1};
+ System.out.println("Example 4 Output: " + solution.maxArea(height4));
+ }
+}
+```
+
+This implementation provides a solution to the Container With Most Water problem in Java.

src/main/java/g0001_0100/s0015_3sum/readme.md

@@ -27,4 +27,83 @@ Notice that the solution set must not contain duplicate triplets.
 **Constraints:**
 
 * `0 <= nums.length <= 3000`
-* <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+* <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+
+To solve the 3Sum problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `threeSum` that takes an array of integers `nums` as input and returns a list of lists representing the triplets that sum up to zero.
+2. Sort the input array `nums` to ensure that duplicate triplets are avoided.
+3. Initialize an empty list `result` to store the triplets.
+4. Iterate over the elements of the sorted array `nums` up to the second to last element.
+5. Within the outer loop, initialize two pointers, `left` and `right`, where `left` starts at the next element after the current element and `right` starts at the last element of the array.
+6. While `left` is less than `right`, check if the sum of the current element (`nums[i]`), `nums[left]`, and `nums[right]` equals zero.
+7. If the sum is zero, add `[nums[i], nums[left], nums[right]]` to the `result` list.
+8. Move the `left` pointer to the right (increment `left`) and the `right` pointer to the left (decrement `right`).
+9. If the sum is less than zero, increment `left`.
+10. If the sum is greater than zero, decrement `right`.
+11. After the inner loop finishes, increment the outer loop index while skipping duplicates.
+12. Return the `result` list containing all the valid triplets.
+
+Here's the implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+ public List<List<Integer>> threeSum(int[] nums) {
+ Arrays.sort(nums);
+ List<List<Integer>> result = new ArrayList<>();
+
+ for (int i = 0; i < nums.length - 2; i++) {
+ if (i > 0 && nums[i] == nums[i - 1]) {
+ continue; // Skip duplicates
+ }
+
+ int left = i + 1;
+ int right = nums.length - 1;
+
+ while (left < right) {
+ int sum = nums[i] + nums[left] + nums[right];
+ if (sum == 0) {
+ result.add(Arrays.asList(nums[i], nums[left], nums[right]));
+
+ // Skip duplicates
+ while (left < right && nums[left] == nums[left + 1]) {
+ left++;
+ }
+ while (left < right && nums[right] == nums[right - 1]) {
+ right--;
+ }
+
+ left++;
+ right--;
+ } else if (sum < 0) {
+ left++;
+ } else {
+ right--;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ // Test cases
+ int[] nums1 = {-1, 0, 1, 2, -1, -4};
+ System.out.println("Example 1 Output: " + solution.threeSum(nums1));
+
+ int[] nums2 = {};
+ System.out.println("Example 2 Output: " + solution.threeSum(nums2));
+
+ int[] nums3 = {0};
+ System.out.println("Example 3 Output: " + solution.threeSum(nums3));
+ }
+}
+```
+
+This implementation provides a solution to the 3Sum problem in Java.

src/main/java/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md

@@ -29,4 +29,77 @@ A mapping of digit to letters (just like on the telephone buttons) is given belo
 **Constraints:**
 
 * `0 <= digits.length <= 4`
-* `digits[i]` is a digit in the range `['2', '9']`.
+* `digits[i]` is a digit in the range `['2', '9']`.
+
+To solve the Letter Combinations of a Phone Number problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `letterCombinations` that takes a string `digits` as input and returns a list of all possible letter combinations.
+2. Create a mapping of digits to letters using a hashmap or an array.
+3. Initialize an empty list `result` to store the combinations.
+4. If the input string `digits` is empty, return an empty list `result`.
+5. Call a recursive function `generateCombinations` to generate combinations for each digit.
+6. Within the recursive function:
+ - Base case: If the current combination length equals the length of the input `digits`, add the combination to the `result` list.
+ - Recursive step: For the current digit, iterate over its corresponding letters and append each letter to the current combination, then recursively call the function with the next digit.
+7. Return the `result` list containing all possible combinations.
+
+Here's the implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+ private static final Map<Character, String> digitToLetters = new HashMap<>();
+ static {
+ digitToLetters.put('2', "abc");
+ digitToLetters.put('3', "def");
+ digitToLetters.put('4', "ghi");
+ digitToLetters.put('5', "jkl");
+ digitToLetters.put('6', "mno");
+ digitToLetters.put('7', "pqrs");
+ digitToLetters.put('8', "tuv");
+ digitToLetters.put('9', "wxyz");
+ }
+
+ public List<String> letterCombinations(String digits) {
+ List<String> result = new ArrayList<>();
+ if (digits.length() == 0) {
+ return result;
+ }
+ generateCombinations(result, digits, "", 0);
+ return result;
+ }
+
+ private void generateCombinations(List<String> result, String digits, String combination, int index) {
+ if (index == digits.length()) {
+ result.add(combination);
+ return;
+ }
+
+ char digit = digits.charAt(index);
+ String letters = digitToLetters.get(digit);
+ for (char letter : letters.toCharArray()) {
+ generateCombinations(result, digits, combination + letter, index + 1);
+ }
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ // Test cases
+ String digits1 = "23";
+ System.out.println("Example 1 Output: " + solution.letterCombinations(digits1));
+
+ String digits2 = "";
+ System.out.println("Example 2 Output: " + solution.letterCombinations(digits2));
+
+ String digits3 = "2";
+ System.out.println("Example 3 Output: " + solution.letterCombinations(digits3));
+ }
+}
+```
+
+This implementation provides a solution to the Letter Combinations of a Phone Number problem in Java.

src/main/java/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md

@@ -31,4 +31,95 @@ Given the `head` of a linked list, remove the `nth` node from the end of the lis
 * `0 <= Node.val <= 100`
 * `1 <= n <= sz`
 
-**Follow up:** Could you do this in one pass?
+**Follow up:** Could you do this in one pass?
+
+To solve the Remove Nth Node From End of List problem in Java with a `Solution` class, we'll follow these steps:
+
+1. Define a `ListNode` class representing the nodes of the linked list.
+2. Define a `Solution` class with a method named `removeNthFromEnd` that takes the head of the linked list and an integer `n` as input and returns the head of the modified list.
+3. Create two pointers, `fast` and `slow`, and initialize them to point to the head of the list.
+4. Move the `fast` pointer `n` steps forward in the list.
+5. If the `fast` pointer reaches the end of the list (`fast == null`), it means that `n` is equal to the length of the list. In this case, remove the head node by returning `head.next`.
+6. Move both `fast` and `slow` pointers simultaneously until the `fast` pointer reaches the end of the list.
+7. At this point, the `slow` pointer will be pointing to the node just before the node to be removed.
+8. Remove the `nth` node by updating the `next` reference of the node pointed to by the `slow` pointer to skip the `nth` node.
+9. Return the head of the modified list.
+
+Here's the implementation:
+
+```java
+public class ListNode {
+ int val;
+ ListNode next;
+ ListNode(int val) { this.val = val; }
+}
+
+public class Solution {
+ public ListNode removeNthFromEnd(ListNode head, int n) {
+ ListNode dummy = new ListNode(0);
+ dummy.next = head;
+ ListNode fast = dummy;
+ ListNode slow = dummy;
+
+ // Move the fast pointer n steps forward
+ for (int i = 0; i <= n; i++) {
+ fast = fast.next;
+ }
+
+ // Move both pointers until the fast pointer reaches the end
+ while (fast != null) {
+ fast = fast.next;
+ slow = slow.next;
+ }
+
+ // Remove the nth node
+ slow.next = slow.next.next;
+
+ return dummy.next;
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ // Example 1
+ ListNode head1 = new ListNode(1);
+ head1.next = new ListNode(2);
+ head1.next.next = new ListNode(3);
+ head1.next.next.next = new ListNode(4);
+ head1.next.next.next.next = new ListNode(5);
+ int n1 = 2;
+ ListNode result1 = solution.removeNthFromEnd(head1, n1);
+ printList(result1); // Output: [1,2,3,5]
+
+ // Example 2
+ ListNode head2 = new ListNode(1);
+ int n2 = 1;
+ ListNode result2 = solution.removeNthFromEnd(head2, n2);
+ printList(result2); // Output: []
+
+ // Example 3
+ ListNode head3 = new ListNode(1);
+ head3.next = new ListNode(2);
+ int n3 = 1;
+ ListNode result3 = solution.removeNthFromEnd(head3, n3);
+ printList(result3); // Output: [1]
+ }
+
+ private static void printList(ListNode head) {
+ if (head == null) {
+ System.out.println("[]");
+ return;
+ }
+ StringBuilder sb = new StringBuilder("[");
+ while (head != null) {
+ sb.append(head.val).append(",");
+ head = head.next;
+ }
+ sb.setLength(sb.length() - 1);
+ sb.append("]");
+ System.out.println(sb.toString());
+ }
+}
+```
+
+This implementation provides a solution to the Remove Nth Node From End of List problem in Java.

src/main/java/g0001_0100/s0020_valid_parentheses/readme.md

@@ -42,4 +42,56 @@ An input string is valid if:
 **Constraints:**
 
 * <code>1 <= s.length <= 10<sup>4</sup></code>
-* `s` consists of parentheses only `'()[]{}'`.
+* `s` consists of parentheses only `'()[]{}'`.
+
+To solve the Valid Parentheses problem in Java with a `Solution` class, we'll use a stack data structure. Here are the steps:
+
+1. Define a `Solution` class with a method named `isValid` that takes a string `s` as input and returns a boolean indicating whether the string contains valid parentheses.
+2. Create a stack to store opening parentheses.
+3. Iterate through each character in the input string `s`.
+4. If the current character is an opening parenthesis (`'('`, `'{'`, or `'['`), push it onto the stack.
+5. If the current character is a closing parenthesis (`')'`, `'}'`, or `']'`), check if the stack is empty. If it is, return `false` because there's no matching opening parenthesis for the current closing parenthesis.
+6. If the stack is not empty, pop the top element from the stack and check if it matches the current closing parenthesis. If it doesn't match, return `false`.
+7. After iterating through all characters in `s`, check if the stack is empty. If it's not empty, return `false` because there are unmatched opening parentheses remaining.
+8. If the stack is empty after processing all characters, return `true` because all parentheses are valid.
+
+Here's the implementation:
+
+```java
+import java.util.Stack;
+
+public class Solution {
+ public boolean isValid(String s) {
+ Stack<Character> stack = new Stack<>();
+
+ for (char c : s.toCharArray()) {
+ if (c == '(' || c == '{' || c == '[') {
+ stack.push(c);
+ } else {
+ if (stack.isEmpty()) {
+ return false;
+ }
+ char top = stack.pop();
+ if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
+ return false;
+ }
+ }
+ }
+
+ return stack.isEmpty();
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ // Test cases
+ System.out.println(solution.isValid("()")); // true
+ System.out.println(solution.isValid("()[]{}")); // true
+ System.out.println(solution.isValid("(]")); // false
+ System.out.println(solution.isValid("([)]")); // false
+ System.out.println(solution.isValid("{[]}")); // true
+ }
+}
+```
+
+This implementation provides a solution to the Valid Parentheses problem in Java using a stack data structure.