Question Solution Added by Anjha

Author: anjha1

0001.two-sum/README.md

@@ -0,0 +1,8 @@
+# [1. Two Sum](https://leetcode.com/problems/two-sum/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. We use $O(1)$ to find `target - x`.
+- Space Complexity: $O(n)$. The main space is used by hash table.

0001.two-sum/TwoSum.java

@@ -0,0 +1,9 @@
+class TwoSum {
+    public int[] twoSum(int[] nums, int target) {
+        for (int i = 0; i < nums.length; i++)
+            for (int j = i + 1; j < nums.length; j++)
+                if (nums[i] + nums[j] == target)
+                    return new int[]{i, j};
+        return new int[]{};
+    }
+}

0001.two-sum/TwoSum2.java

@@ -0,0 +1,14 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class TwoSum2 {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> hashtable = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (hashtable.containsKey(target - nums[i]))
+                return new int[]{hashtable.get(target - nums[i]), i};
+            hashtable.put(nums[i], i);
+        }
+        return new int[]{};
+    }
+}

0002.add-two-numbers/AddTwoNumbers.java

@@ -0,0 +1,25 @@
+
+class AddTwoNumbers {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode dummyHead = new ListNode(0);
+        ListNode curr = dummyHead;
+        int carry = 0;
+        while(l1 != null || l2 != null || carry != 0) {
+            int val = 0;
+            if (l1 != null && l2 != null) {
+                val = l1.val + l2.val;
+            } else if (l1 != null) {
+                val = l1.val;
+            } else if (l2 != null ){
+                val = l2.val;
+            }
+            val += carry;
+            curr.next = new ListNode((val % 10));
+            curr = curr.next;
+            carry = val / 10;
+            if (l1 != null) l1 = l1.next;
+            if (l2 != null) l2 = l2.next;
+        }
+        return dummyHead.next;
+    }
+}

0002.add-two-numbers/README.md

@@ -0,0 +1 @@
+# [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/)

0003.longest-substring-without-repeating-characters/LongestSubstringWithoutRepeatingCharacters.java

@@ -0,0 +1,14 @@
+class LongestSubstringWithoutRepeatingCharacters {
+    public int lengthOfLongestSubstring(String s) {
+        int n = s.length(), longest = 0;
+        int[] nextIndex = new int[128];
+
+        for (int r = 0, l = 0; r < n; r++) {
+            l = Math.max(nextIndex[s.charAt(r)], l);
+            longest = Math.max(longest, r - l + 1);
+            nextIndex[s.charAt(r)] = r + 1;
+        }
+
+        return longest;
+    }
+}

0003.longest-substring-without-repeating-characters/README.md

@@ -0,0 +1 @@
+# [3. Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/)

0005.longest-palindromic-substring/LongestPalindromicSubstring.java

@@ -0,0 +1,21 @@
+class LongestPalindromicSubstring {
+    public String longestPalindrome(String s) {
+        if (s == null || s.length() == 0) return "";
+        int len = s.length();
+        boolean[][] dp = new boolean[len][len];
+        int start = 0, end = 0, max = 0;
+        for (int i = 0; i < len; i++) {
+            for (int j = 0; j <= i; j++) {
+                if (s.charAt(i) == s.charAt(j) && (i - j <= 2 || dp[j + 1][i - 1])) {
+                    dp[j][i] = true;
+                }
+                if (dp[j][i] && max < i - j + 1) {
+                    max = i - j + 1;
+                    start = j;
+                    end = i;
+                }
+            }
+        }
+        return s.substring(start, end + 1);
+    }
+}

0005.longest-palindromic-substring/README.md

@@ -0,0 +1 @@
+# [5. Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/)

0006.zigzag-conversion/README.md

@@ -0,0 +1,7 @@
+# [6. Zigzag Conversion](https://leetcode.com/problems/zigzag-conversion/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `s`. We iterate s for one time, so the time complexity is $O(n)$.
+- Space Complexity: $O(n)$. We save the data in rows that maximum space is $O(n)$.

0006.zigzag-conversion/ZigzagConversion.java

@@ -0,0 +1,21 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class ZigzagConversion {
+    public String convert(String s, int numRows) {
+        if (numRows < 2) return s;
+        List<StringBuilder> rows = new ArrayList<>();
+        for (int i = 0; i < numRows; i++)
+            rows.add(new StringBuilder());
+        int i = 0, flag = -1;
+        for (char c : s.toCharArray()) {
+            rows.get(i).append(c);
+            if (i == 0 || i == numRows - 1) flag = -flag;
+            i += flag;
+        }
+        StringBuilder res = new StringBuilder();
+        for (StringBuilder row : rows)
+            res.append(row);
+        return res.toString();
+    }
+}