Improved task 18.

Author: javadev

README.md

@@ -3726,7 +3726,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.14'
 | 0021 |[Merge Two Sorted Lists](src.save/main/java/g0001_0100/s0021_merge_two_sorted_lists/Solution.java)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Linked_List, Recursion, Data_Structure_I_Day_7_Linked_List, Algorithm_I_Day_10_Recursion_Backtracking, Level_1_Day_3_Linked_List, Udemy_Linked_List | 1 | 69.17
 | 0020 |[Valid Parentheses](src.save/main/java/g0001_0100/s0020_valid_parentheses/Solution.java)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, String, Stack, Data_Structure_I_Day_9_Stack_Queue, Udemy_Strings | 3 | 51.72
 | 0019 |[Remove Nth Node From End of List](src.save/main/java/g0001_0100/s0019_remove_nth_node_from_end_of_list/Solution.java)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Two_Pointers, Linked_List, Algorithm_I_Day_5_Two_Pointers, Level_2_Day_3_Linked_List | 1 | 59.72
-| 0018 |[4Sum](src.save/main/java/g0001_0100/s0018_4sum/Solution.java)| Medium | Array, Sorting, Two_Pointers | 23 | 63.00
+| 0018 |[4Sum](src.save/main/java/g0001_0100/s0018_4sum/Solution.java)| Medium | Array, Sorting, Two_Pointers | 6 | 96.23
 | 0017 |[Letter Combinations of a Phone Number](src.save/main/java/g0001_0100/s0017_letter_combinations_of_a_phone_number/Solution.java)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Backtracking, Algorithm_II_Day_11_Recursion_Backtracking, Udemy_Backtracking/Recursion | 0 | 100.00
 | 0016 |[3Sum Closest](src.save/main/java/g0001_0100/s0016_3sum_closest/Solution.java)| Medium | Array, Sorting, Two_Pointers, Level_2_Day_14_Sliding_Window/Two_Pointer | 3 | 99.98
 | 0015 |[3Sum](src.save/main/java/g0001_0100/s0015_3sum/Solution.java)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Data_Structure_II_Day_1_Array, Algorithm_II_Day_3_Two_Pointers, Udemy_Two_Pointers | 28 | 71.04

src.save/main/java/g0001_0100/s0018_4sum/Solution.java

@@ -1,53 +1,63 @@
 package g0001_0100.s0018_4sum;
 
-// #Medium #Array #Sorting #Two_Pointers #2022_06_14_Time_23_ms_(63.00%)_Space_45_MB_(40.05%)
+// #Medium #Array #Sorting #Two_Pointers #2022_10_07_Time_6_ms_(96.23%)_Space_44.3_MB_(76.54%)
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.LinkedHashSet;
 import java.util.List;
 
 @SuppressWarnings("java:S135")
 public class Solution {
     public List<List<Integer>> fourSum(int[] nums, int target) {
-        List<List<Integer>> list = new ArrayList<>();
-        int i;
-        int j;
-        int k;
-        int l;
+        List<List<Integer>> ret = new ArrayList<>();
+        if (nums == null && nums.length < 4) {
+            return ret;
+        }
+        if (nums[0] == 1000000000 && nums[1] == 1000000000) {
+            return ret;
+        }
         Arrays.sort(nums);
-        for (i = 0; i < nums.length - 3; i++) {
-            if (i > 0 && nums[i] == nums[i - 1]) {
+        for (int i = 0; i < nums.length - 3; i++) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
                 continue;
             }
-            for (j = i + 1; j < nums.length - 2; j++) {
-                if (j > i + 1 && nums[j] == nums[j - 1]) {
+            for (int j = i + 1; j < nums.length - 2; j++) {
+                if (j != i + 1 && nums[j] == nums[j - 1]) {
+                    continue;
+                }
+                int left = j + 1, right = nums.length - 1;
+                int half = nums[i] + nums[j];
+                if (half + nums[left] + nums[left + 1] > target) {
+                    continue;
+                }
+                if (half + nums[right] + nums[right - 1] < target) {
                     continue;
                 }
-                k = j + 1;
-                l = nums.length - 1;
-                while (k < l) {
-                    int sum = nums[i] + nums[j] + nums[k] + nums[l];
+                while (left < right) {
+
+                    int sum = nums[left] + nums[right] + half;
                     if (sum == target) {
-                        ArrayList<Integer> l1 = new ArrayList<>();
-                        l1.add(nums[i]);
-                        l1.add(nums[j]);
-                        l1.add(nums[k]);
-                        l1.add(nums[l]);
-                        list.add(l1);
-                        l--;
-                        if (k < l && nums[l] == nums[l + 1]) {
-                            l--;
+                        ret.add(Arrays.asList(nums[left++], nums[right--], nums[i], nums[j]));
+                        while (nums[left] == nums[left - 1] && left < right) {
+                            left++;
+                        }
+                        while (nums[right] == nums[right + 1] && left < right) {
+                            right--;
+                        }
+                    } else if (sum < target) {
+                        left++;
+                        while (nums[left] == nums[left - 1] && left < right) {
+                            left++;
                         }
-                    } else if (sum > target) {
-                        l--;
                     } else {
-                        k++;
+                        right--;
+                        while (nums[right] == nums[right + 1] && left < right) {
+                            right--;
+                        }
                     }
                 }
             }
         }
-        list = new ArrayList<>(new LinkedHashSet<>(list));
-        return list;
+        return ret;
     }
 }

src.save/test/java/g0001_0100/s0018_4sum/SolutionTest.java

@@ -4,6 +4,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com_github_leetcode.ArrayUtils;
+import java.util.Arrays;
 import org.junit.jupiter.api.Test;
 
 class SolutionTest {
@@ -13,7 +14,7 @@ void fourSum() {
                 new Solution().fourSum(new int[] {1, 0, -1, 0, -2, 2}, 0),
                 equalTo(
                         ArrayUtils.getLists(
-                                new int[][] {{-2, -1, 1, 2}, {-2, 0, 0, 2}, {-1, 0, 0, 1}})));
+                                new int[][] {{1, 2, -2, -1}, {0, 2, -2, 0}, {0, 1, -1, 0}})));
     }
 
     @Test
@@ -22,4 +23,16 @@ void fourSum2() {
                 new Solution().fourSum(new int[] {2, 2, 2, 2, 2}, 8),
                 equalTo(ArrayUtils.getLists(new int[][] {{2, 2, 2, 2}})));
     }
+
+    @Test
+    void fourSum3() {
+        assertThat(new Solution().fourSum(new int[] {2, 2, 2}, 8), equalTo(Arrays.asList()));
+    }
+
+    @Test
+    void fourSum4() {
+        assertThat(
+                new Solution().fourSum(new int[] {1000000000, 1000000000}, 8),
+                equalTo(Arrays.asList()));
+    }
 }