Count all possible unique sum of series K, K+1, K+2, K+3, K+4, …, K+N

Given a number N and for any number K for a series formed as K, K + 1, K + 2, K + 3, K + 4, ……., K + N. The task is to find the number of unique sums that can be obtained by adding two or more integers from the series of N + 1 integers.

Examples:

Input: N = 3 
Output: 10 
Explanation: 
The possible unique combinations are: 
(K) + (K + 1) = 2*K + 1 
(K) + (K + 2) = 2*K + 2 
(K) + (K + 3) = 2*K + 3 
(K + 1) + (K + 3) = 2*K + 4 
(K + 2) + (K + 3) = 2*K + 5 
(K) + (K + 1) + (K + 2) = 3*K + 3 
(K) + (K + 1) + (K + 3) = 3*K + 4 
(K) + (K + 2) + (K + 3) = 3*K + 5 
(K + 1) + (K + 2) + (K + 3) = 3*K + 6 
(K) + (K + 1) + (K + 2) + (K + 3) = 4*K + 6 
So in total, there are 10 unique ways. 

Input: N = 4 
Output: 20 
Explanation: 
The possible unique combinations are 20 in number. 
 

Approach: The following observations are to be made:



  • Since K is number the only significance it has is that two subsets with different sizes cannot have the same sum.
  • A unique sum can be obtained from the minimum possible sum of the subset to the maximum possible sum of subset having size as X where (2 ≤ X ≤ (N + 1)).

For Example:N = 4
The Series is = {K, K + 1, K + 2, K + 3, K + 4}
For K = 2, minimum_sum = (K, K + 1) = 2*K + 1
and maximum_sum = (K + 3, K + 4) = 2*K + 7
The maximum distinct sums possible with K = 2 are (maximum_sum – minimum_sum + 1) = (7 – 1 + 1) = 7.

Follow the steps below to solve the problem: 

  1. Initialize two arrays array fsum[] and rsum[] each of size N + 1 to 0.
  2. For each element of both the arrays fsum[] and rsum[], update fsum[i] with ar[i] + fsum[i – 1] and rsum[i] with ar[i] + fsum[i + 1].
  3. Initialize a variable ans to 1 that stores the count of different possible sums of the given series.
  4. For each possible subset size X, where (2 ≤ X ≤ (N + 1)), add the value 1 + rsum[n + 1 – k] + fsum[k] to ans.
  5. The value of ans is the required answer hence return it.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to count the unique sum
int count_unique_sum(int n)
{
  
    int i, ar[n + 1], fsum[n + 1];
    int rsum[n + 1], ans = 1;
  
    // Initialize array fsum[] with 0
    memset(fsum, 0, sizeof fsum);
  
    // Initialize array rsum[] with 0
    memset(rsum, 0, sizeof rsum);
  
    for (i = 0; i <= n; i++) {
        ar[i] = i;
    }
  
    // Set fsum[0] as ar[0]
    fsum[0] = ar[0];
  
    // Set rsum[0] as ar[n]
    rsum[n] = ar[n];
  
    // For each i update fsum[i] with
    // ar[i] + fsum[i - 1]
    for (i = 1; i <= n; i++) {
        fsum[i] = ar[i] + fsum[i - 1];
    }
  
    // For each i from n-1, update
    // rsum[i] with ar[i] + fsum[i + 1]
    for (i = n - 1; i >= 0; i--) {
        rsum[i] = ar[i] + rsum[i + 1];
    }
  
    // K represent size of subset as
    // explained above
    for (int k = 2; k <= n; k++) {
  
        // Using above relation
        ans += 1 + rsum[n + 1 - k]
               - fsum[k - 1];
    }
  
    // Return the result
    return ans;
}
  
// Driver Code
int main()
{
    // Given a number N
    int N = 4;
  
    // Function Call
    cout << count_unique_sum(N);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
class GFG{
    
// Function to count the unique sum
static int count_unique_sum(int n)
{
    int i;
    int ar[] = new int[n + 1];
    int fsum[] = new int[n + 1];
    int rsum[] = new int[n + 1];
    int ans = 1;
    
    // Initialize array fsum[] with 0
    Arrays.fill(fsum, 0);
   
    // Initialize array rsum[] with 0
    Arrays.fill(rsum, 0);
   
    for (i = 0; i <= n; i++)
    {
        ar[i] = i;
    }
   
    // Set fsum[0] as ar[0]
    fsum[0] = ar[0];
   
    // Set rsum[0] as ar[n]
    rsum[n] = ar[n];
   
    // For each i update fsum[i] with
    // ar[i] + fsum[i - 1]
    for (i = 1; i <= n; i++) 
    {
        fsum[i] = ar[i] + fsum[i - 1];
    }
   
    // For each i from n-1, update
    // rsum[i] with ar[i] + fsum[i + 1]
    for (i = n - 1; i >= 0; i--) 
    {
        rsum[i] = ar[i] + rsum[i + 1];
    }
   
    // K represent size of subset as
    // explained above
    for (int k = 2; k <= n; k++)
    {
   
        // Using above relation
        ans += 1 + rsum[n + 1 - k] - 
                     fsum[k - 1];
    }
   
    // Return the result
    return ans;
}
   
// Driver Code
public static void main(String[] args)
{
    // Given a number N
    int N = 4;
   
    // Function Call
    System.out.print(count_unique_sum(N));
}
}
  
// This code is contributed by rock__cool

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to count the unique sum
def count_unique_sum(n):
  
    ar = [0] * (n + 1)
    fsum = [0] * (n + 1)
    rsum = [0] * (n + 1)
    ans = 1
  
    for i in range(0, n + 1):
        ar[i] = i
      
    # Set fsum[0] as ar[0]
    fsum[0] = ar[0]
  
    # Set rsum[0] as ar[n]
    rsum[n] = ar[n]
  
    # For each i update fsum[i] with
    # ar[i] + fsum[i - 1]
    for i in range(1, n + 1):
        fsum[i] = ar[i] + fsum[i - 1]
  
    # For each i from n-1, update
    # rsum[i] with ar[i] + fsum[i + 1]
    for i in range(n - 1, -1, -1):
        rsum[i] = ar[i] + rsum[i + 1]
      
    # K represent size of subset as
    # explained above
    for k in range(2, n + 1):
  
        # Using above relation
        ans += (1 + rsum[n + 1 - k] - 
                    fsum[k - 1])
      
    # Return the result
    return ans
  
# Driver Code
  
# Given a number N
N = 4
  
# Function call
print(count_unique_sum(N))
  
# This code is contributed by sanjoy_62

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
class GFG{
    
// Function to count the unique sum
static int count_unique_sum(int n)
{
    int i;
    int []ar = new int[n + 1];
    int []fsum = new int[n + 1];
    int []rsum = new int[n + 1];
    int ans = 1;
   
    for (i = 0; i <= n; i++)
    {
        ar[i] = i;
    }
   
    // Set fsum[0] as ar[0]
    fsum[0] = ar[0];
   
    // Set rsum[0] as ar[n]
    rsum[n] = ar[n];
   
    // For each i update fsum[i] with
    // ar[i] + fsum[i - 1]
    for (i = 1; i <= n; i++) 
    {
        fsum[i] = ar[i] + fsum[i - 1];
    }
   
    // For each i from n-1, update
    // rsum[i] with ar[i] + fsum[i + 1]
    for (i = n - 1; i >= 0; i--) 
    {
        rsum[i] = ar[i] + rsum[i + 1];
    }
   
    // K represent size of subset as
    // explained above
    for (int k = 2; k <= n; k++)
    {
   
        // Using above relation
        ans += 1 + rsum[n + 1 - k] - 
                   fsum[k - 1];
    }
   
    // Return the result
    return ans;
}
   
// Driver Code
public static void Main(String[] args)
{
    // Given a number N
    int N = 4;
   
    // Function Call
    Console.Write(count_unique_sum(N));
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Output

20

Time Complexity: O(N) 
Auxiliary Space: O(N)
 

competitive-programming-img




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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.