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

Answer 1

I'm not going to answer your question completely, since I think it is homework and also think that this is easily done. But I do think that I know why you are having difficulty with an answer, so I will help you out a little bit.

Firstly, you should look into recursion. That means calling a function from within itself.

Second, you should use a helper function, which is called by the function you want to write. This function should take as arguments: - an array of numbers - the length of the array - the value you want find members that sum up to - the number of members of the array that you want to sum up

This function will be called by your other function and passed a 4 for the last argument. It will then call itself adjusting the arguments as it tries to find results by partial trial and error.

edit 2

Upon further thought I realized that this not O(n^2), as I claimed earlier (I mentally glossed over the the middle steps). It is limited by n^4, but may have a lower limit than that due to ample opportunity to short cut in many cases. I do not believe that this short cutting improves it to the point of n^2, though.

Answer 2

Like a few other posters, it can be done with a hash in O(n^2)

#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
#include <math.h>
#include <map>

using namespace std;

struct Entry
{
   int a;
   int b;
};

int main () {

   typedef vector<int> VI;

   VI l(5);
   l[0] = 1;
   l[1] = 2;
   l[2] = -1;
   l[3] = -2;
   l[4] = 5;
   l[5] = 6;

   sort(l.begin(), l.end());

   int sumTo = 0;

   typedef multimap<int, Entry> Table;

   typedef pair<int,Entry> PairEntry;

   Table myTbl;

   // N
   for (int i = 0; i < l.size(); ++i)
   {
      // N
      for (int j = i+1; j < l.size(); ++j)
      {
         // Const
         int val = l[i] + l[j];

         // A is always less than B
         Entry ent = {i, j};

         myTbl.insert(PairEntry(val,ent));
      }
   }

   pair<Table::iterator, Table::iterator> range;

   // Start at beginning of array
   for (Table::iterator ita = myTbl.begin();
        ita != myTbl.end();
        ++ita)
   {
      int lookFor = sumTo - ita->first;
      // Find the complement
      range = myTbl.equal_range(lookFor);

      // Const bound
      for (Table::iterator itb = range.first;
           itb != range.second;
           ++itb)
      {
         if (ita->second.a == itb->second.a || ita->second.b == itb->second.b)
         {
            // No match
         }
         else
         {
            // Match
            cout << l[ita->second.a] << " " << l[itb->second.a] << " "
                 << l[ita->second.b] << " " << l[itb->second.b] << endl;

            return 0;
         }
      }
   }

   return 0;
}

Answer 3

Abusing the fact that no memory constrain is specified. And using the usual divide and conquer approach.

Number of all permutations for 4 number subsets is C(n,4) and is O(n^4). Number of all permutations for 2 numbers is C(n,2) and is O(n^2). O(n^2) seems to be OK for the task.

1. Input is: an array A with n elements, X.
2. Generate all permutations for 2 number subsets (that's O(n^2)) and put their sums into array B with n^2 elements (also remembering the subsets). Let's denote as S[B[i]] the subset (consisting of the two numbers) whose sum is B[i].
3. Sort the B, O(n^2*log(n^2)).

4. Walk through the array B (O(n^2)) i = [0,n^2) and quick search O(log(n^2)) = O(log(n)) in it for the value (X - B[i]). There might be several of them (but not more than n^2).

   4.1. Walk through all the elements with value of (X - B[i]), using index k.

   4.2. Skip the elements B[k] where S[B[k]] intersects with S[B[i]]. Intersection of two sets with two numbers can be calculated in O(1).

   4.3 If k is the index a element where B[i] + B[k] == X and S[B[k]] doesn't intersect with S[B[i]], then the sum of the sets S[B[k]] and S[B[i]] are the four sought numbers.

Performance is: O( n^2 + n^2*log(n^2) + n^2*log(n^2) ) = O( n^2 * log(n^2) ) = O( n^2 * log(n) )

On step four, when we iterate over the multiple matching elements of B using nested loop. Yet, total number of iterations of the two nested loops is limited by the |B| which is O(n^2). The quick search is not the usual variation but the one which finds the matching element with the lowest index. (Alternatively one can use the usual bsearch and since we might have landed in the middle, use two adjacent loops, checking elements in both directions.)

Answer 4

This problem can be reduced to finding all combinations of length 4. For each combination thus obtained, sum the elements and check if it is equal to X.

Answer 5

I have written an O(N^^2) running time function which does not use hashtables but handles negative numbers and duplicate numbers apparently OK. I handle negative numbers in an integer array by adding an large postive number(e.g. 100) to all the integers in the array. Then, I adjust the target by target += (4 * 100). Then when I find a result, I subtract out the 100 from the integers in the result. Here is my code and test cases: Please let me know if this o(N^^2) time complexity.

struct maryclaranicholascameron{
    int sum;
    int component1;
    int component2;
};


void Another2PrintSum(int arr[], int arraysize, int target){
    int i(arraysize -1);
    int j(arraysize -2);
    int temp(target);
    int temp2(0);
    int m(0);
    int n(0);
    int sum(0);
    int original_target(target);

    for (int ctr = 0; ctr < arraysize; ctr++){

        sum += arr[ctr];
    }

         for (int ctrn = 0; ctrn < arraysize; ctrn++){
        arr[ctrn] += 100;
    }


    maryclaranicholascameron* temparray = new maryclaranicholascameron[sum + (arraysize *100)];
    memset(temparray, 0, sizeof(maryclaranicholascameron) * (sum + 400));



    for (m = 0; m < arraysize; m++){
        for (n = m + 1; n < arraysize; n++){
                temparray[arr[m] + arr[n]].sum = arr[m]+ arr[n];
                temparray[arr[m] + arr[n]].component1 = m;
                temparray[arr[m] + arr[n]].component2 = n;
        }
    }

    target += (4 * 100);
    original_target = target;

    bool found(false);
    while (i >= 0 && i < arraysize && found == false){
        target -= (arr[i]);
        while(j >= 0 && j < arraysize && found == false){
            temp2 = target;
            target -= (arr[j]);
            if (i != j && temparray[target].sum == target && 
                temparray[target].sum != 0 &&
                temparray[target].component1 != i &&
                temparray[target].component2 != i &&
                temparray[target].component1 != j &&
                temparray[target].component2 != j){
                printf("found the 4 integers i = %d j = %d m = %d n = %d component1 = %d component = %d i %d j %d\n",
                    arr[i] - 100,
                    arr[j] - 100,
                    arr[temparray[target].component1] - 100,
                    arr[temparray[target].component2] - 100,
                    temparray[target].component1,
                    temparray[target].component2,
                    i,
                    j);
                    found = true;
                    break;
            }
            j -= 1;
            target = temp2;
        }
        i -= 1;
        j = i;
        target = original_target;
    }
    if (found == false){
        printf("cannot found the 4 integers\n");
    }
    delete [] temparray;
}

// test cases

int maryclaranicholas[] = {-14,-14,-14,-14,-12 ,-12, -12 ,-12 ,-11, -9,-8,-7,40};
 Another2PrintSum(maryclaranicholas, 13,-2};

int testarray[] = {1,3,4,5,7,10};
Another2PrintSum(testarray, 6, 20);