revisit some easy / mid questions

metanet · metanet · commit 07f4c5b3380f · 2023-05-08T21:48:02.000+01:00
diff --git a/src/problems/leetcode/FourSum.java b/src/problems/leetcode/FourSum.java
@@ -0,0 +1,73 @@
+package problems.leetcode;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+// https://leetcode.com/problems/4sum/description/
+public class FourSum {
+
+    public static void main(String[] args) {
+        System.out.println(fourSum(new int[] { 1, 0, -1, 0, -2, 2 }, 0));
+        System.out.println(fourSum(new int[] { 1000000000, 1000000000, 1000000000, 1000000000 }, -294967296));
+    }
+
+    // runtime: O(N^3)
+    public static List<List<Integer>> fourSum(int[] nums, int target) {
+        // 0, 1, 2, 3, 4, 5
+        // -2, -1, 0, 0, 1, 2
+        // target = 0
+        // i j
+        // remainingTarget = 3
+        // i j k l
+        // i j k l
+        // i j k l
+        // i j k l
+
+        if (nums.length < 4) {
+            return Collections.emptyList();
+        }
+
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            for (int j = i + 1; j < nums.length; j++) {
+                if (j > i + 1 && nums[j] == nums[j - 1]) {
+                    continue;
+                }
+
+                long remaining = (long) target - (nums[i] + nums[j]);
+                int k = j + 1, l = nums.length - 1;
+                while (k < l) {
+                    int sum = nums[k] + nums[l];
+                    if (sum > remaining) {
+                        l--;
+                    } else if (sum < remaining) {
+                        k++;
+                    } else {
+                        result.add(Arrays.asList(nums[i], nums[j], nums[k], nums[l]));
+
+                        k++;
+                        while (k < l && nums[k] == nums[k - 1]) {
+                            k++;
+                        }
+
+                        l--;
+                        while (k < l && nums[l] == nums[l + 1]) {
+                            l--;
+                        }
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+}
diff --git a/src/problems/leetcode/IntegerToRoman.java b/src/problems/leetcode/IntegerToRoman.java
@@ -10,7 +10,48 @@ public static void main(String[] args) {
         System.out.println(intToRoman(num));
     }
 
+    private static String digitToString(int n, String s, String m, String l) {
+        switch (n) {
+            case 0:
+                return "";
+            case 1:
+                return s;
+            case 2:
+                return s + s;
+            case 3:
+                return s + s + s;
+            case 4:
+                return s + m;
+            case 5:
+                return m;
+            case 6:
+                return m + s;
+            case 7:
+                return m + s + s;
+            case 8:
+                return m + s + s + s;
+            case 9:
+                return s + l;
+            default:
+                throw new IllegalArgumentException("Cannot convert " + n);
+        }
+    }
+
     public static String intToRoman(int num) {
+        if (num < 1 || num > 3999) {
+            throw new IllegalArgumentException("Cannot convert " + num + " to Roman!");
+        }
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(digitToString(num / 1000, "M", "", ""));
+        sb.append(digitToString((num % 1000) / 100, "C", "D", "M"));
+        sb.append(digitToString(((num % 100) / 10), "X", "L", "C"));
+        sb.append(digitToString(num % 10, "I", "V", "X"));
+        
+        return sb.toString();
+    }
+
+    public static String intToRoman2(int num) {
         if (num < 1 || num > 3999) {
             throw new IllegalArgumentException("invalid num: " + num + " to convert!");
         }
diff --git a/src/problems/leetcode/LongestCommonPrefix.java b/src/problems/leetcode/LongestCommonPrefix.java
@@ -1,42 +1,42 @@
 package problems.leetcode;
 
+import java.util.Optional;
+
 /**
  * https://leetcode.com/problems/longest-common-prefix/
  */
 public class LongestCommonPrefix {
 
     public static void main(String[] args) {
-        String[] strs = {"c", "c"};
+        String[] strs = { "c", "c" };
         System.out.println(longestCommonPrefix(strs));
     }
 
+    // runtime: O(N)
+    // space: O(1)
     public static String longestCommonPrefix(String[] strs) {
         if (strs == null || strs.length == 0) {
             return "";
         }
 
         StringBuilder sb = new StringBuilder();
-
-        int i = 0;
-        while (true) {
-            if (i == strs[0].length()) {
-                break;
-            }
-
-            char c = strs[0].charAt(i);
-            for (int j = 1; j < strs.length; j++) {
-                String s = strs[j];
-                if (i == s.length() || c != s.charAt(i)) {
-                    i = -1;
+        for (int i = 0;; i++) {
+            Optional<Character> c = Optional.empty();
+            for (String s : strs) {
+                if (i >= s.length()) {
+                    c = Optional.empty();
+                    break;
+                } else if (c.isEmpty()) {
+                    c = Optional.of(s.charAt(i));
+                } else if (c.get() != s.charAt(i)) {
+                    c = Optional.empty();
                     break;
                 }
             }
-
-            if (i != -1) {
-                sb.append(c);
-                i++;
-            } else {
+            if (c.isEmpty()) {
                 break;
+            } else {
+                sb.append(c.get());
             }
         }
 
diff --git a/src/problems/leetcode/MergeKSortedLists.java b/src/problems/leetcode/MergeKSortedLists.java
@@ -17,52 +17,42 @@ private static class ListNode {
         }
     }
 
-    private static class ListNodeHolder {
-        final ListNode node;
-        final int index;
-
-        ListNodeHolder(ListNode node, int index) {
-            this.node = node;
-            this.index = index;
+    // runtime: O(NlgN) where N is number of lists
+    // space: O(N)
+    public static ListNode mergeKLists(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
         }
-    }
 
-    public static ListNode mergeKLists(ListNode[] lists) {
-        PriorityQueue<ListNodeHolder> heap = new PriorityQueue<>(Comparator.comparingInt(holder -> holder.node.val));
+        PriorityQueue<ListNode> heap = new PriorityQueue<>(new Comparator<ListNode>() {
+            public int compare(ListNode a, ListNode b) {
+                return Integer.compare(a.val, b.val);
+            }
+        });
 
-        for (int i = 0; i < lists.length; i++) {
-            ListNode node = next(lists, i);
+        for (ListNode node : lists) {
             if (node != null) {
-                heap.add(new ListNodeHolder(node, i));
+                heap.add(node);
             }
         }
-
+        
         ListNode head = null, tail = null;
-        while (heap.size() > 0) {
-            ListNodeHolder holder = heap.poll();
+        while (!heap.isEmpty()) {
+            ListNode node = heap.poll();
+            ListNode next = node.next;
+            node.next = null;
             if (head == null) {
-                head = tail = holder.node;
+                head = tail = node;
             } else {
-                tail.next = holder.node;
-                tail = holder.node;
+                tail.next = node;
+                tail = node;
             }
-
-            ListNode next = next(lists, holder.index);
             if (next != null) {
-                heap.add(new ListNodeHolder(next, holder.index));
+                heap.add(next);
             }
         }
-
+        
         return head;
     }
 
-    private static ListNode next(ListNode[] lists, int index) {
-        ListNode next = lists[index];
-        if (next != null) {
-            lists[index] = next.next;
-            next.next = null;
-        }
-
-        return next;
-    }
 }
diff --git a/src/problems/leetcode/MergeTwoSortedLists.java b/src/problems/leetcode/MergeTwoSortedLists.java
@@ -14,6 +14,8 @@ private static class ListNode {
         }
     }
 
+    // runtime: O(N)
+    // space: O(1)
     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
         if (l1 == null) {
             return l2;
diff --git a/src/problems/leetcode/RemoveNthNodeFromEndOfList.java b/src/problems/leetcode/RemoveNthNodeFromEndOfList.java
@@ -22,6 +22,8 @@ public String toString() {
 
     private int i;
 
+    // runtime: O(N)
+    // space: O(N) due to recursive calls till tail
     public ListNode removeNthFromEnd(ListNode head, int n) {
         return remove(head, n);
     }
diff --git a/src/problems/leetcode/RomanToInteger.java b/src/problems/leetcode/RomanToInteger.java
@@ -11,6 +11,26 @@ public static void main(String[] args) {
     }
 
     public static int romanToInt(String s) {
+        int num = 0, buf = 0;
+        for (int i = 0, j = s.length(); i < j; i++) {
+            int n = toArabicNumber(s.charAt(i));
+            if (buf == 0) {
+                buf = n;
+            } else if (buf / n >= 10) {
+                num += buf;
+                buf = n;
+            } else if (n <= buf) {
+                buf += n;
+            } else {
+                num += (n - buf);
+                buf = 0;
+            }
+        }
+
+        return num + buf;
+    }
+
+    public static int romanToInt2(String s) {
         if (s == null || s.length() == 0) {
             return 0;
         }
diff --git a/src/problems/leetcode/SwapNodesInPairs.java b/src/problems/leetcode/SwapNodesInPairs.java
@@ -22,27 +22,17 @@ public String toString() {
         }
     }
 
+    // runtime: O(N)
+    // space: O(N) due to recursive call stack
     public static ListNode swapPairs(ListNode head) {
         if (head == null || head.next == null) {
             return head;
         }
 
-        ListNode prev = head, newHead = head.next, n1 = head.next.next;
-
-        newHead.next = head;
-        head.next = n1;
-
-        while (n1 != null && n1.next != null) {
-            ListNode n2 = n1.next;
-            ListNode n3 = n1.next.next;
-            prev.next = n2;
-            n2.next = n1;
-            n1.next = n3;
-            prev = n1;
-            n1 = n3;
-        }
-
-        return newHead;
+        ListNode next = head.next;
+        head.next = swapPairs(next.next);
+        next.next = head;
+        return next;
     }
 
     public static void main(String[] args) {
diff --git a/src/problems/leetcode/ThreeSum.java b/src/problems/leetcode/ThreeSum.java
@@ -14,17 +14,19 @@ public static void main(String[] args) {
         System.out.println(threeSum(nums));
     }
 
+    // runtime: O(N^2)
     public static List<List<Integer>> threeSum(int[] nums) {
         List<List<Integer>> indices = new ArrayList<>();
-        Arrays.sort(nums);
+        Arrays.sort(nums); // O(NlgN)
 
-        for (int i = 0, len = nums.length; i < len - 2; i++) {
+        // O(N^2)
+        for (int i = 0, len = nums.length; i < len - 2; i++) { // O(N)
             if (i != 0 && nums[i] == nums[i - 1]) {
                 continue;
             }
 
             int j = i + 1, k = len - 1;
-            while (j < k) {
+            while (j < k) { // O(N)
                 if (nums[i] + nums[j] + nums[k] > 0) {
                     k--;
                 } else if (nums[i] + nums[j] + nums[k] < 0) {
@@ -48,4 +50,34 @@ public static List<List<Integer>> threeSum(int[] nums) {
         return indices;
     }
 
+    // runtime: O(N^3)
+    public List<List<Integer>> threeSumBruteForce(int[] nums) {
+        List<List<Integer>> indices = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }            
+            for (int j = i + 1; j < nums.length; j++) {
+                if (j > i + 1 && nums[j] == nums[j - 1]) {
+                    continue;
+                }
+                for (int k = j + 1; k < nums.length; k++) {
+                    if (k > j + 1 && nums[k] == nums[k - 1]) {
+                        continue;
+                    } else if (nums[i] + nums[j] + nums[k] == 0) {
+                        List<Integer> l = new ArrayList();
+                        l.add(nums[i]);
+                        l.add(nums[j]);
+                        l.add(nums[k]);
+                        indices.add(l);
+                    }
+                }
+            }
+        }
+
+        return indices;
+    }
+
 }
diff --git a/src/problems/leetcode/ThreeSumClosest.java b/src/problems/leetcode/ThreeSumClosest.java
diff --git a/src/problems/leetcode/ValidParentheses.java b/src/problems/leetcode/ValidParentheses.java

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ private static class ListNode {`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
	`17`	`+ // runtime: O(N)`
	`18`	`+ // space: O(1)`
`17`	`19`	`public ListNode mergeTwoLists(ListNode l1, ListNode l2) {`
`18`	`20`	`if (l1 == null) {`
`19`	`21`	`return l2;`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ public String toString() {`
`22`	`22`
`23`	`23`	`private int i;`
`24`	`24`
	`25`	`+ // runtime: O(N)`
	`26`	`+ // space: O(N) due to recursive calls till tail`
`25`	`27`	`public ListNode removeNthFromEnd(ListNode head, int n) {`
`26`	`28`	`return remove(head, n);`
`27`	`29`	`}`