Count all possible unique sum of series K, K+1, K+2, K+3, K+4, …, K+N
Last Updated :
23 Nov, 2022
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:
- Initialize two arrays array fsum[] and rsum[] each of size N + 1 to 0.
- 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].
- Initialize a variable ans to 1 that stores the count of different possible sums of the given series.
- For each possible subset size X, where (2 ? X ? (N + 1)), add the value 1 + rsum[n + 1 – k] + fsum[k] to ans.
- The value of ans is the required answer hence return it.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int count_unique_sum( int n)
{
int i, ar[n + 1], fsum[n + 1];
int rsum[n + 1], ans = 1;
memset (fsum, 0, sizeof fsum);
memset (rsum, 0, sizeof rsum);
for (i = 0; i <= n; i++) {
ar[i] = i;
}
fsum[0] = ar[0];
rsum[n] = ar[n];
for (i = 1; i <= n; i++) {
fsum[i] = ar[i] + fsum[i - 1];
}
for (i = n - 1; i >= 0; i--) {
rsum[i] = ar[i] + rsum[i + 1];
}
for ( int k = 2; k <= n; k++) {
ans += 1 + rsum[n + 1 - k]
- fsum[k - 1];
}
return ans;
}
int main()
{
int N = 4;
cout << count_unique_sum(N);
return 0;
}
|
Java
import java.util.*;
class GFG{
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 ;
Arrays.fill(fsum, 0 );
Arrays.fill(rsum, 0 );
for (i = 0 ; i <= n; i++)
{
ar[i] = i;
}
fsum[ 0 ] = ar[ 0 ];
rsum[n] = ar[n];
for (i = 1 ; i <= n; i++)
{
fsum[i] = ar[i] + fsum[i - 1 ];
}
for (i = n - 1 ; i >= 0 ; i--)
{
rsum[i] = ar[i] + rsum[i + 1 ];
}
for ( int k = 2 ; k <= n; k++)
{
ans += 1 + rsum[n + 1 - k] -
fsum[k - 1 ];
}
return ans;
}
public static void main(String[] args)
{
int N = 4 ;
System.out.print(count_unique_sum(N));
}
}
|
Python3
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
fsum[ 0 ] = ar[ 0 ]
rsum[n] = ar[n]
for i in range ( 1 , n + 1 ):
fsum[i] = ar[i] + fsum[i - 1 ]
for i in range (n - 1 , - 1 , - 1 ):
rsum[i] = ar[i] + rsum[i + 1 ]
for k in range ( 2 , n + 1 ):
ans + = ( 1 + rsum[n + 1 - k] -
fsum[k - 1 ])
return ans
N = 4
print (count_unique_sum(N))
|
C#
using System;
class GFG{
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;
}
fsum[0] = ar[0];
rsum[n] = ar[n];
for (i = 1; i <= n; i++)
{
fsum[i] = ar[i] + fsum[i - 1];
}
for (i = n - 1; i >= 0; i--)
{
rsum[i] = ar[i] + rsum[i + 1];
}
for ( int k = 2; k <= n; k++)
{
ans += 1 + rsum[n + 1 - k] -
fsum[k - 1];
}
return ans;
}
public static void Main(String[] args)
{
int N = 4;
Console.Write(count_unique_sum(N));
}
}
|
Javascript
<script>
function count_unique_sum(n)
{
let i;
let ans = 1;
let ar = new Array(n + 1);
let fsum = new Array(n + 1);
let rsum = new Array(n + 1);
fsum.fill(0);
rsum.fill(0);
for (i = 0; i <= n; i++) {
ar[i] = i;
}
fsum[0] = ar[0];
rsum[n] = ar[n];
for (i = 1; i <= n; i++) {
fsum[i] = ar[i] + fsum[i - 1];
}
for (i = n - 1; i >= 0; i--) {
rsum[i] = ar[i] + rsum[i + 1];
}
for (let k = 2; k <= n; k++) {
ans += 1 + rsum[n + 1 - k]
- fsum[k - 1];
}
return ans;
}
let N = 4;
document.write(count_unique_sum(N));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N), since N extra space has been taken.
Share your thoughts in the comments
Please Login to comment...