code is Added

Author: anjha1

0018.4sum/FourSum.java

@@ -0,0 +1,45 @@
+import java.util.*;
+
+class FourSum {
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        HashSet<List<Integer>> hashSet = new HashSet<>();
+
+        if (nums == null || nums.length < 4) {
+            return res;
+        }
+
+        int len = nums.length;
+        Arrays.sort(nums);
+
+        for (int i = 0; i <= len - 4; i++) {
+            for (int j = i + 1; j <= len - 3; j++) {
+                int l = j + 1;
+                int r = len - 1;
+                while (l < r) {
+                    int sum = nums[i] + nums[j] + nums[l] + nums[r];
+                    if (sum < target) {
+                        l++;
+                    } else if (sum > target) {
+                        r--;
+                    } else {
+                        List<Integer> list = new ArrayList<>();
+                        list.add(nums[i]);
+                        list.add(nums[j]);
+                        list.add(nums[l]);
+                        list.add(nums[r]);
+                        // Remove duplicates
+                        if (!hashSet.contains(list)) {
+                            hashSet.add(list);
+                            res.add(list);
+                        }
+                        l++;
+                        r--;
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+}

0018.4sum/README.md

@@ -0,0 +1 @@
+# [18. 4Sum](https://leetcode.com/problems/4sum/)

0019.remove-nth-node-from-end-of-list/README.md

@@ -0,0 +1 @@
+# [19. Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/)

0019.remove-nth-node-from-end-of-list/RemoveNthNodeFromEndOfList.java

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class RemoveNthNodeFromEndOfList {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        if (head == null) return null;
+        ListNode fast = head;
+        while (n-- > 0) {
+            fast = fast.next;
+        }
+        if (fast == null) return head.next;
+        ListNode slow = head;
+        while (fast.next != null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+        slow.next = slow.next.next;
+        return head;
+    }
+}

0020.valid-parentheses/README.md

@@ -0,0 +1,6 @@
+# [20. Valid Parentheses](https://leetcode.com/problems/valid-parentheses/)
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of s.
+- Space Complexity: $O(n + m)$. $m$ is the size of hash table which is 6 in this question. The max amount of stack is $O(n)$, $n$ is the length of $s$.

0020.valid-parentheses/ValidParentheses.java

@@ -0,0 +1,26 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+class ValidParentheses {
+    public boolean isValid(String s) {
+        if (s.length() % 2 == 1) return false;
+
+        Map<Character, Character> pairs = new HashMap<>(){{
+            put(')', '(');
+            put(']', '[');
+            put('}', '{');
+        }};
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (pairs.containsKey(c)) {
+                if (stack.isEmpty() || stack.peek() != pairs.get(c))
+                    return false;
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        return stack.isEmpty();
+    }
+}

0021.merge-two-sorted-lists/MergeTwoSortedLists.java

@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class MergeTwoSortedLists {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        if (list1 == null) return list2;
+        if (list2 == null) return list1;
+
+        if (list1.val < list2.val) {
+            list1.next = mergeTwoLists(list1.next, list2);
+            return list1;
+        }
+        list2.next = mergeTwoLists(list1, list2.next);
+        return list2;
+    }
+}

0021.merge-two-sorted-lists/README.md

@@ -0,0 +1 @@
+# [21. Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/)

0022.generate-parentheses/GenerateParentheses.java

@@ -0,0 +1,27 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class GenerateParentheses {
+    private void backtrack(List<String> res, StringBuilder cur, int open, int close, int max) {
+        if (cur.length() == max * 2) {
+            res.add(cur.toString());
+            return;
+        }
+        if (open < max) {
+            cur.append("(");
+            backtrack(res, cur, open + 1, close, max);
+            cur.deleteCharAt(cur.length() - 1);
+        }
+        if (close < open) {
+            cur.append(")");
+            backtrack(res, cur, open, close + 1, max);
+            cur.deleteCharAt(cur.length() - 1);
+        }
+    }
+
+    public List<String> generateParenthesis(int n) {
+        List<String> res = new ArrayList<>();
+        backtrack(res, new StringBuilder(), 0, 0, n);
+        return res;
+    }
+}

0022.generate-parentheses/README.md

@@ -0,0 +1 @@
+# [22. Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)

0024.swap-nodes-in-pairs/README.md

@@ -0,0 +1 @@
+# [24. Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)

0024.swap-nodes-in-pairs/SwapNodesInPairs.java

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class SwapNodesInPairs {
+    public ListNode swapPairs(ListNode head) {
+        ListNode node = new ListNode(-1);
+        node.next = head;
+        ListNode pre = node;
+        while (pre.next != null && pre.next.next != null) {
+            ListNode l1 = pre.next, l2 = pre.next.next;
+            l1.next = l2.next;
+            l2.next = l1;
+            pre.next = l2;
+
+            pre = l1;
+        }
+        return node.next;
+    }
+}

0026.remove-duplicates-from-sorted-array/README.md

@@ -0,0 +1 @@
+# [26. Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)

0026.remove-duplicates-from-sorted-array/RemoveDuplicatesFromSortedArray.java

@@ -0,0 +1,12 @@
+class RemoveDuplicatesFromSortedArray {
+    public int removeDuplicates(int[] nums) {
+        int insertIndex = 1;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] != nums[i - 1]) {
+                nums[insertIndex] = nums[i];
+                insertIndex++;
+            }
+        }
+        return insertIndex;
+    }
+}

0028.find-the-index-of-the-first-occurrence-in-a-string/FindTheIndexOfTheFirstOccurrenceInAString.java

@@ -0,0 +1,30 @@
+class FindTheIndexOfTheFirstOccurrenceInAString {
+    public int strStr(String haystack, String needle) {
+        int n = haystack.length(), m = needle.length();
+        if (m == 0)
+            return 0;
+
+        int[] pi = new int[m];
+        for (int i = 1, j = 0; i < m; i++) {
+            while (j > 0 && needle.charAt(i) != needle.charAt(j)) {
+                j = pi[j - 1];
+            }
+            if (needle.charAt(i) == needle.charAt(j)) {
+                j++;
+            }
+            pi[i] = j;
+        }
+        for (int i = 0, j = 0; i < n; i++) {
+            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
+                j = pi[j - 1];
+            }
+            if (haystack.charAt(i) == needle.charAt(j)) {
+                j++;
+            }
+            if (j == m) {
+                return i - m + 1;
+            }
+        }
+        return -1;
+    }
+}

0028.find-the-index-of-the-first-occurrence-in-a-string/README.md

@@ -0,0 +1,7 @@
+# [28. Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m)$. $n$ is the length of haystack and $m$ is the length of needle. We need to iterate them twice, so the time complexity is $O(n+m)$.
+- Space Complexity: $O(m)$.

0030.substring-with-concatenation-of-all-words/README.md

@@ -0,0 +1 @@
+# [30. Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/)

0030.substring-with-concatenation-of-all-words/SubstringWithConcatenationOfAllWords.java

@@ -0,0 +1,45 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+class SubstringWithConcatenationOfAllWords {
+    private final HashMap<String, Integer> wordCount = new HashMap<>();
+    private int wordLength, substringSize, k;
+
+    private boolean check(int i, String s) {
+        HashMap<String, Integer> remaining = new HashMap<>(wordCount);
+        int wordsUsed = 0;
+
+        for (int j = i; j < i + substringSize; j+= wordLength) {
+            String sub = s.substring(j, j + wordLength);
+            if (remaining.getOrDefault(sub, 0) != 0) {
+                remaining.put(sub, remaining.get(sub) - 1);
+                wordsUsed++;
+            } else {
+                break;
+            }
+        }
+
+        return wordsUsed == k;
+    }
+
+    public List<Integer> findSubstring(String s, String[] words) {
+        int n = s.length();
+        k = words.length;
+        wordLength = words[0].length();
+        substringSize = wordLength * k;
+
+        for (String word : words) {
+            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
+        }
+
+        List<Integer> answer = new ArrayList<>();
+        for (int i = 0; i < n - substringSize + 1; i++) {
+            if (check(i, s)) {
+                answer.add(i);
+            }
+        }
+
+        return answer;
+    }
+}

0033.search-in-rotated-sorted-array/README.md

@@ -0,0 +1 @@
+# [33. Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/)

0033.search-in-rotated-sorted-array/SearchInRotatedSortedArray.java

@@ -0,0 +1,18 @@
+class SearchInRotatedSortedArray {
+    public int search(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] == target) return mid;
+            if (nums[mid] < nums[right]) {
+                if (nums[mid] < target && nums[right] >= target) left = mid + 1;
+                else right = mid - 1;
+            } else {
+                if (nums[left] <= target && nums[mid] > target) right = mid - 1;
+                else left = mid + 1;
+            }
+        }
+        return -1;
+    }
+}

0034.find-first-and-last-position-of-element-in-sorted-array/FindFirstAndLastPositionOfElementInSortedArray.java

@@ -0,0 +1,24 @@
+class FindFirstAndLastPositionOfElementInSortedArray {
+    private int findFirst(int[] nums, int target) {
+        int l = 0, h = nums.length;
+        while (l < h) {
+            int m = l + (h - l) / 2;
+            if (nums[m] >= target) {
+                h = m;
+            } else {
+                l = m + 1;
+            }
+        }
+        return l;
+    }
+
+    public int[] searchRange(int[] nums, int target) {
+        int first = findFirst(nums, target);
+        int last = findFirst(nums, target + 1) - 1;
+        if (first == nums.length || nums[first] != target) {
+            return new int[]{-1, -1};
+        } else {
+            return new int[]{first, Math.max(first, last)};
+        }
+    }
+}

0034.find-first-and-last-position-of-element-in-sorted-array/README.md

@@ -0,0 +1 @@
+# [34. Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)

0035.search-insert-position/README.md

@@ -0,0 +1,7 @@
+# [35. Search Insert Position](https://leetcode.com/problems/search-insert-position/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(\log n)$. $n$ is the length of `nums`.
+- Space Complexity: $O(1)$.

0035.search-insert-position/SearchInsertPosition.java

@@ -0,0 +1,11 @@
+class SearchInsertPosition {
+    public int searchInsert(int[] nums, int target) {
+        int l = 0, h = nums.length;
+        while (l < h) {
+            int m = l + (h - l) / 2;
+            if (nums[m] >= target) h = m;
+            else l = m + 1;
+        }
+        return l;
+    }
+}

0036.valid-sudoku/README.md

@@ -0,0 +1 @@
+# [36. Valid Sudoku](https://leetcode.com/problems/valid-sudoku/)