4 Sum - All Distinct Quadruplets with given Sum in an Array

using System;
using System.Collections.Generic;

class GfG {
    
    static List<List<int>> fourSum(int[] arr, int target) {
        List<List<int>> res = new List<List<int>>();
        int n = arr.Length;

        // Generating all possible quadruplets
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    for (int l = k + 1; l < n; l++) {
                        if (arr[i] + arr[j] + arr[k] + arr[l] == target) {
                            List<int> curr = new List<int> 
                            			{ arr[i], arr[j], arr[k], arr[l] };

                            // Sort the current quadruplet
                            curr.Sort();

                            // Check for uniqueness
                            bool isUnique = true;
                            foreach (var quad in res) {
                                if (quad[0] == curr[0] && quad[1] == curr[1] && 
                                    quad[2] == curr[2] && quad[3] == curr[3]) {
                                    isUnique = false;
                                    break;
                                }
                            }

                            // Add to the result if unique
                            if (isUnique) {
                                res.Add(curr);
                            }
                        }
                    }
                }
            }
        }
        return res;
    }

    static void Main() {
        int[] arr = { 10, 2, 3, 4, 5, 7, 8 };
        int target = 23;
        List<List<int>> ans = fourSum(arr, target);
        foreach (List<int> v in ans) {
            Console.WriteLine(string.Join(" ", v));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class GfG {
    static List<List<int>> fourSum(int[] arr, int target) {
        // Initialize a set to store unique sorted
        // quadruplets using custom comparer
        var resSet = new HashSet<List<int>>(new ListComparer());
        int n = arr.Length;

        // Iterate to fix the first two 
        // elements of the quadruplet
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {

                // Use a set to track seen elements 
                // for the third loop
                var s = new HashSet<int>();

                // Loop to fix the third element
                // and check for the fourth
                for (int k = j + 1; k < n; k++) {
                    int sum = arr[i] + arr[j] + arr[k];
                    int last = target - sum;

                    // If the fourth required element
                    // has already been seen
                    if (s.Contains(last)) {
                        var curr = new List<int> { arr[i], arr[j], arr[k], last };

                        // Sort to ensure a consistent
                        // order for uniqueness
                        curr.Sort();

                        // Add the sorted quadruplet to the set
                        resSet.Add(curr);
                    }

                    // Add current element to the hash 
                    // set for future checks
                    s.Add(arr[k]);
                }
            }
        }

        // Convert the set to a list and return
        return new List<List<int>>(resSet);
    }

    // Custom comparer class to check list 
    // equality and generate hash codes
    class ListComparer : IEqualityComparer<List<int>> {
        public bool Equals(List<int> x, List<int> y) {
            if (x.Count != y.Count)
                return false;
            return x.SequenceEqual(y);
        }

        public int GetHashCode(List<int> obj) {
            int hash = 17;

            // Compute hash code based on list content
            foreach (int item in obj) {
                hash = hash * 31 + item.GetHashCode();
            }
            return hash;
        }
    }

    public static void Main() {
        int[] arr = { 10, 2, 3, 4, 5, 7, 8 };
        int target = 23;
        var ans = fourSum(arr, target);
        foreach (var v in ans) {
            Console.WriteLine(string.Join(" ", v));
        }
    }
}

using System;
using System.Collections.Generic;

class GfG {
  
    // Function to find quadruplets 
    // that sum to the target
    static List<List<int>> fourSum(int[] arr, int target) {
        List<List<int>> res = new List<List<int>>();
        int n = arr.Length;

        // Sort the array
        Array.Sort(arr);

        // Generate quadruplets
        for (int i = 0; i < n; i++) {
          
            // Skip duplicates for i
            if (i > 0 && arr[i] == arr[i - 1]) continue;

            for (int j = i + 1; j < n; j++) {
              
                // Skip duplicates for j
                if (j > i + 1 && arr[j] == arr[j - 1]) continue;

                int k = j + 1, l = n - 1;

                // Two pointers approach
                while (k < l) {
                    int sum = arr[i] + arr[j] + arr[k] + arr[l];
                    if (sum == target) {
                        res.Add(new List<int> { arr[i], arr[j], arr[k], arr[l] });
                        k++;
                        l--;

                        // Skip duplicates for k and l
                        while (k < l && arr[k] == arr[k - 1]) k++;
                        while (k < l && arr[l] == arr[l + 1]) l--;
                    } else if (sum < target) {
                        k++;
                    } else {
                        l--;
                    }
                }
            }
        }
        return res;
    }

    public static void Main() {
        int[] arr = { 10, 2, 3, 4, 5, 7, 8 };
        int target = 23;
        List<List<int>> ans = fourSum(arr, target);
        foreach (var v in ans) {
            Console.WriteLine(string.Join(" ", v));
        }
    }
}