find four elements in array whose sum equal to a given number X [closed]

Answer 1

A working Java solution of the algo. provided by Nikita Rybak above..

// find four numbers in an array such that they equals to X
 class Pair{
     int i;
     int j;

     Pair(int x,int y){
         i=x;
         j=y;
     }
 }

 public class FindNumbersEqualsSum {
    public static void main(String[] args) {

         int num[]={1,2,3,4,12,43,32,53,8,-10,4};

         get4Numbers(num, 17);

         get4Numbers(num, 55);
    }

 public static void get4Numbers(int a[],int sum){

    int len=a.length;

    Map<Integer, Pair> sums = new HashMap<Integer, Pair>(); 
    for (int i = 0; i < len; ++i) {
        // 'sums' hastable holds all possible sums a[k] + a[l]
        // where k and l are both less than i

        for (int j = i + 1; j < len; ++j) {
            int current = a[i] + a[j];
            int rest = sum - current;
            // Now we need to find if there're different numbers k and l
            // such that a[k] + a[l] == rest and k < i and l < i
            // but we have 'sums' hashtable prepared for that
            if (sums.containsKey(rest)) {
                // found it
                Pair p = sums.get(rest);
                System.out.println(a[i]+" + "+a[j]+" + "+a[p.i] +" + "+a[p.j]+" = "+sum);

            }
        }

        // now let's put in 'sums' hashtable all possible sums
        // a[i] + a[k] where k < i
        for (int k = 0; k < i; ++k) {
            sums.put(a[i] + a[k],new Pair(i, k));
        }
    }
 }
}

 Result:

  4 + 8 + 3 + 2 = 17
  8 + 4 + 4 + 1 = 17
  43 + 8 + 3 + 1 = 55
  32 + 8 + 12 + 3 = 55
  8 + -10 + 53 + 4 = 55
  -10 + 4 + 8 + 53 = 55

Answer 2

1) Create an array of all possible pair sums [O(N^2)]

2) Sort this array in ascending order [O(N^2 * Log N)]

3) Now this problem reduces to finding 2 numbers in a sorted array that sum to a given number X, in linear time. Use 2 pointers: a LOW pointer starting from the lowest value, and a HIGH pointer starting from the highest value. If the sum is too low, advance LOW. If the sum is too high, advance HIGH (backwards). Eventually they will find that pair or cross each other (this can be easily proven). This process takes linear time in the size of the array, i.e. O(N ^ 2)

This gives a total time of O(N^2 * log N) as required.

NOTE : This method can be generalized for solving the case of M numbers in O(M * N^(M/2) * log N) time.

-- EDIT --

Actually my response is very similar to Dummy00001's response, except the final lookup, where I use a faster method (though the overall complexity is the same...)

Answer 3

This problem can be taken as a variation of pascals identity,

here is the complete code :

please excuse as the code is in java :

public class Combination {
static int count=0;

public static void main(String[] args) {
    int a[] =  {10, 20, 30, 40, 1, 2,4,11,60,15,5,6};
    int setValue = 4;
    getCombination(a, setValue);

}

private static void getCombination(int[] a, int setValue) {
    // TODO Auto-generated method stub

    int size = a.length;
    int data[] = new int[setValue];
    createCombination(a, data, setValue, 0, 0, size);
    System.out.println(" total combinations : "+count);
}

private static void createCombination(int[] a, int[] data, int setValue,
        int i, int index, int size) {

    // TODO Auto-generated method stub
    if (index == setValue) {

        if(data[0]+data[1]+data[3]+data[2]==91)
        {   count ++;
        for (int j = 0; j < setValue; j++)
            System.out.print(data[j] + " ");
        System.out.println();
        }return;
    }
    // System.out.println(". "+i);
    if (i >= size)
        return;
    // to take care of repetation
    if (i < size - 2) {
        while (a[i] == a[i + 1])
            i++;
    }
    data[index] = a[i];
    // System.out.println(data[index]+" "+index+"  .....");
    createCombination(a, data, setValue, i + 1, index + 1, size);

    createCombination(a, data, setValue, i + 1, index, size);

}

}

Sample input :

int a[] =  {10, 20, 30, 40, 1, 2,4,11,60,15,5,6};

Output : :

10 20 1 60 
10 30 40 11 
10 60 15 6 
20 30 40 1 
20 60 5 6 
30 40 15 6 
11 60 15 5 
 total combinations : 7

Answer 4

You can do it in O(n^2). Works fine with duplicated and negative numbers.

edit as Andre noted in comment, time is with use of hash, which has 'worst case' (although it's less likely than winning in a lottery). But you can also replace hashtable with balanced tree (TreeMap in java) and get guaranteed stable O(n^2 * log(n)) solution.

Hashtable sums will store all possible sums of two different elements. For each sum S it returns pair of indexes i and j such that a[i] + a[j] == S and i != j. But initially it's empty, we'll populate it on the way.

for (int i = 0; i < n; ++i) {
    // 'sums' hastable holds all possible sums a[k] + a[l]
    // where k and l are both less than i

    for (int j = i + 1; j < n; ++j) {
        int current = a[i] + a[j];
        int rest = X - current;
        // Now we need to find if there're different numbers k and l
        // such that a[k] + a[l] == rest and k < i and l < i
        // but we have 'sums' hashtable prepared for that
        if (sums[rest] != null) {
            // found it
        }
    }

    // now let's put in 'sums' hashtable all possible sums
    // a[i] + a[k] where k < i
    for (int k = 0; k < i; ++k) {
        sums[a[i] + a[k]] = pair(i, k);
    }
}

Let's say, X = a[1] + a[3] + a[7] + a[10]. This sum will be found when i = 7, j = 10 and rest = a[1] + a[3] (indexes 1 and 3 will be found from hash)

Answer 5

find four elements in array whose sum equal to a given number X
for me following algorithm works:

Dim Amt(1 To 10) As Long
Dim i

For i = 1 To 10
    Amt(i) = Val(List1.List(i))
Next i

Dim Tot As Integer
Dim lenth As Integer
lenth = List1.ListCount

'sum of 4 numbers
For i = 1 To lenth
    For j = 1 To lenth
        For k = 1 To lenth
            For l = 1 To lenth
                If i <> j And i <> k And i <> l And j <> k And j <> l And k <> l Then
                    Debug.Print CBAmt(i) & " , " & CBAmt(j) & " , " & CBAmt(k) & " , " & CBAmt(l)
                    If CBAmt(i) + CBAmt(j) + CBAmt(k) + CBAmt(l) = Val(Text1) Then
                        MsgBox "Found"
                        found = True
                        Exit For
                    End If
                End If
            Next
            If found = True Then Exit For
        Next
        If found = True Then Exit For
    Next
    If found = True Then Exit For
Next

Answer 6

Sounds like homework to me. But here's what I'd do.

First sort the numbers (there's your n*log(n)).

Now, create pointers to the list, initialize it with the first 4 numbers. Once you have that, you check the sum of your 4 current numbers with the total. It should be less than or equal to your search sum (if it's not, you can quit early). Now all you need to do is traverse rest of your list alternately replacing your pointers with the current value in the list. This only need to happen once (or really at worst 4 times) so there's your other n, which makes n^2*log(n)

You'll need to keep track of some logic to know if you're over/under your sum and what to do next, but I leave that as your homework assignment.