Sum of products of all combination taken (1 to n) at a time

Given N, we have to find the sum of products of all combination taken 1 to N at a time. In simple words, we have to find the sum of products of all combination taken 1 at time, then 2 at a time, then 3 at a time till N at a time.

If you think closely about the problem, a large value of N could result in producing a large number of combinations.

Examples:

Input :  N = 3
Output : f(1) = 6
         f(2) = 11
         f(3) = 6

Explanation: f(x) is sum of products of all 
             combination taken x at a time
             1 + 2 + 3 = 6
             f(2) = (1*2) + (1*3) + (2*3) = 11
             f(3) = (1*2*3) 

Input :  N = 4
Output : f(1) = 10
         f(2) = 35
         f(3) = 50
         f(4) = 24

Explanation: f(1) = 1 + 2 + 3 + 4 = 10
             f(2) = (1*2) + (1*3) + (1*4) + 
                    (2*3) + (2*4) + (3*4) 
                  = 35
             f(3) = (1*2*3) + (1*2*4) +(1*3*4) + 
                    (2*3*4) 
                 = 50
             f(4) = (1*2*3*4) = 24        



A Brute force approach would be to produce all the combinations and then find their products and sum.

Recursion would do the trick to produce the combinations taken x at a time.
Example : N = 4 taken 3 at a time

C++

// Program to find SOP of all combination taken
// (1 to N) at a time using brute force
#include <iostream>
using namespace std;

// to store sum of every combination
int sum = 0;

void Combination(int a[], int combi[], int n, 
                int r, int depth, int index) {

  // if we have reached sufficient depth
  if (index == r) {
    
    // find the product of combination
    int product = 1;
    for (int i = 0; i < r; i++)
      product = product * combi[i];

    // add the product into sum
    sum += product;
    return;
  }

  // recursion to produce different combination
  for (int i = depth; i < n; i++) {
    combi[index] = a[i];
    Combination(a, combi, n, r, i + 1, index + 1);
  }
}

// function to print sum of products of
// all combination taken 1-N at a time
void allCombination(int a[], int n) {
  for (int i = 1; i <= n; i++) {

    // creating temporary array for storing
    // combination
    int *combi = new int[i];

    // call combination with r = i
    // for combination taken i at a time
    Combination(a, combi, n, i, 0, 0);

    // displaying sum
    cout << "f(" << i << ") --> " << sum << "\n";
    sum = 0;

    // free from heap area
    free(combi);
  }
}

// Driver's code
int main() {
  int n = 5;
  int *a = new int[n];

  // storing numbers from 1-N in array
  for (int i = 0; i < n; i++)
    a[i] = i + 1;

  // calling allCombination
  allCombination(a, n);

  return 0;
}

Java

// Program to find SOP of 
// all combination taken
// (1 to N) at a time using
// brute force
import java.io.*;

class GFG
{
    // to store sum of
    // every combination
    static int sum = 0;
    
    static void Combination(int []a, int []combi, 
                            int n, int r, 
                            int depth, int index) 
    {
    
    // if we have reached
    // sufficient depth
    if (index == r) 
    {
        
        // find the product
        // of combination
        int product = 1;
        for (int i = 0; i < r; i++)
        product = product * combi[i];
    
        // add the product into sum
        sum += product;
        return;
    }
    
    // recursion to produce 
    // different combination
    for (int i = depth; i < n; i++) 
    {
        combi[index] = a[i];
        Combination(a, combi, n, r, 
                    i + 1, index + 1);
    }
    }
    
    // function to print sum of 
    // products of all combination
    // taken 1-N at a time
    static void allCombination(int []a, 
                               int n)
    {
        for (int i = 1; i <= n; i++) 
        {
        
            // creating temporary array 
            // for storing combination
            int []combi = new int[i];
        
            // call combination with 
            // r = i for combination 
            // taken i at a time
            Combination(a, combi, n,
                        i, 0, 0);
        
            // displaying sum
            System.out.print("f(" + i + ") --> " + 
                                      sum + "\n");
            sum = 0;
        }
    }
    
    // Driver code
    public static void main(String args[]) 
    {
        int n = 5;
        int []a = new int[n];
        
        // storing numbers 
        // from 1-N in array
        for (int i = 0; i < n; i++)
            a[i] = i + 1;
        
        // calling allCombination
        allCombination(a, n);
    }
} 

// This code is contributed by 
// Manish Shaw(manishshaw1)

C#

// Program to find SOP of 
// all combination taken
// (1 to N) at a time using
// brute force
using System;

class GFG
{
    // to store sum of
    // every combination
    static int sum = 0;
    
    static void Combination(int []a, int []combi, 
                            int n, int r, 
                            int depth, int index) 
    {
    
    // if we have reached
    // sufficient depth
    if (index == r) 
    {
        
        // find the product
        // of combination
        int product = 1;
        for (int i = 0; i < r; i++)
        product = product * combi[i];
    
        // add the product into sum
        sum += product;
        return;
    }
    
    // recursion to produce 
    // different combination
    for (int i = depth; i < n; i++) 
    {
        combi[index] = a[i];
        Combination(a, combi, n, r, 
                    i + 1, index + 1);
    }
    }
    
    // function to print sum of 
    // products of all combination
    // taken 1-N at a time
    static void allCombination(int []a, 
                               int n)
    {
    for (int i = 1; i <= n; i++) 
    {
    
        // creating temporary array 
        // for storing combination
        int []combi = new int[i];
    
        // call combination with 
        // r = i for combination 
        // taken i at a time
        Combination(a, combi, n,
                    i, 0, 0);
    
        // displaying sum
        Console.Write("f(" + i + ") --> " + 
                               sum + "\n");
        sum = 0;
    }
    }
    
    // Driver code
    static void Main() 
    {
        int n = 5;
        int []a = new int[n];
        
        // storing numbers 
        // from 1-N in array
        for (int i = 0; i < n; i++)
            a[i] = i + 1;
        
        // calling allCombination
        allCombination(a, n);
    }
}

// This code is contributed by 
// Manish Shaw(manishshaw1)



Output:

f(1) --> 15
f(2) --> 85
f(3) --> 225
f(4) --> 274
f(5) --> 120

The Time complexity of above code is exponential when the value of N is large.

An Efficient Method is to use the concept of dynamic programming. We don’t have to find sum of products every time. We can make use of previous results.
Let’s take an example: N = 4

C++

// CPP Program to find sum of all combination takne
// (1 to N) at a time using dynamic programming
#include <iostream>
using namespace std;

// find the postfix sum array
void postfix(int a[], int n) {
  for (int i = n - 1; i > 0; i--)
    a[i - 1] = a[i - 1] + a[i];
}

// modify the array such that we don't have to
// compute the products which are obtained before
void modify(int a[], int n) {
  for (int i = 1; i < n; i++)
    a[i - 1] = i * a[i];
}

// finding sum of all combination taken 1 to N at a time
void allCombination(int a[], int n) {

  int sum = 0;

  // sum taken 1 at time is simply sum of 1 - N
  for (int i = 1; i <= n; i++)
    sum += i;
  cout << "f(1) --> " << sum << "\n";

  // for sum of products for all combination
  for (int i = 1; i < n; i++) {

    // finding postfix array
    postfix(a, n - i + 1);
    
    // sum of products taken i+1 at a time
    sum = 0;
    for (int j = 1; j <= n - i; j++) {
      sum += (j * a[j]);
    }
    cout << "f(" << i + 1 << ") --> " << sum << "\n";

    // modify the array for overlapping problem
    modify(a, n);
  }
}

// Driver's Code
int main() {
  int n = 5;
  int *a = new int[n];

  // storing numbers from 1 to N
  for (int i = 0; i < n; i++)
    a[i] = i + 1;

  // calling allCombination
  allCombination(a, n);

  return 0;
}

Output:

f(1) --> 15
f(2) --> 85
f(3) --> 225
f(4) --> 274
f(5) --> 120

The Time Complexity of above method is O(n^2) which far more better than the brute force method.
You can also find the execution time of both the method for large value of N and can see the difference for yourself.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


Improved By : manishshaw1




Recommended Posts:



4 Average Difficulty : 4/5.0
Based on 9 vote(s)






User Actions