Count of possible permutations of a number represented as a sum of 2’s, 4’s and 6’s only
Given an integer N, the task is to find out the number of permutations in which N can be represented as a sum of 2s, 4s, and 6s only.
Note: The different permutations of the same combination will also be counted.
Examples:
Input: N = 8
Output: 7
Explanation: The possible combinations are:
2 2 2 2
4 4
4 2 2
2 2 4
2 4 2
2 6
6 2
Input: N = 6
Output: 4
Approach: In order to solve this problem, we are using a Dynamic Programming approach:
- As the possible numbers that can be added to reach N are 2, 4, and 6, they can be considered as base cases. By making use of the base cases further cases can be computed.
- Let us consider a dp[] array of size N + 1 which computes and stores at every index i the possible ways to form a value i using only 2, 4, 6.
-
dp[2] = 1
dp[4] = 2 { 4 can be represented as 2+2, 4}
dp[6] = 4 { 6 can be represented as 2+2+2, 2+4, 4+2, 6}
dp[i] = dp[i-2]+dp[i-4] + dp[i – 6] for all even values of i in the range [8, N]
- Hence, dp[N] contains the required answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int count( int n)
{
if (n == 2)
return 1;
else if (n == 4)
return 2;
else if (n == 6)
return 4;
int table[n + 1], i;
for (i = 0; i < n + 1; i++)
table[i] = 0;
table[0] = 0;
table[2] = 1;
table[4] = 2;
table[6] = 4;
for (i = 8; i <= n; i = i + 2) {
table[i] = table[i - 2]
+ table[i - 4]
+ table[i - 6];
}
return table[n];
}
int main( void )
{
int n = 8;
cout << count(n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int count( int n)
{
if (n == 2 )
return 1 ;
else if (n == 4 )
return 2 ;
else if (n == 6 )
return 4 ;
int table[] = new int [n + 1 ];
int i;
for (i = 0 ; i < n + 1 ; i++)
table[i] = 0 ;
table[ 0 ] = 0 ;
table[ 2 ] = 1 ;
table[ 4 ] = 2 ;
table[ 6 ] = 4 ;
for (i = 8 ; i <= n; i = i + 2 )
{
table[i] = table[i - 2 ] +
table[i - 4 ] +
table[i - 6 ];
}
return table[n];
}
public static void main(String args[])
{
int n = 8 ;
System.out.print(count(n));
}
}
|
Python3
def count(n) :
if (n = = 2 ) :
return 1 ;
elif (n = = 4 ) :
return 2 ;
elif (n = = 6 ) :
return 4 ;
table = [ 0 ] * (n + 1 );
for i in range (n + 1 ) :
table[i] = 0 ;
table[ 0 ] = 0 ;
table[ 2 ] = 1 ;
table[ 4 ] = 2 ;
table[ 6 ] = 4 ;
for i in range ( 8 , n + 1 , 2 ) :
table[i] = table[i - 2 ] + \
table[i - 4 ] + \
table[i - 6 ];
return table[n];
if __name__ = = "__main__" :
n = 8 ;
print (count(n));
|
C#
using System;
class GFG{
static int count( int n)
{
if (n == 2)
return 1;
else if (n == 4)
return 2;
else if (n == 6)
return 4;
int []table = new int [n + 1];
int i;
for (i = 0; i < n + 1; i++)
table[i] = 0;
table[0] = 0;
table[2] = 1;
table[4] = 2;
table[6] = 4;
for (i = 8; i <= n; i = i + 2)
{
table[i] = table[i - 2] +
table[i - 4] +
table[i - 6];
}
return table[n];
}
public static void Main()
{
int n = 8;
Console.Write(count(n));
}
}
|
Javascript
<script>
function count(n)
{
if (n == 2)
return 1;
else if (n == 4)
return 2;
else if (n == 6)
return 4;
let table = Array.from({length: n+1}, (_, i) => 0);
let i;
for (i = 0; i < n + 1; i++)
table[i] = 0;
table[0] = 0;
table[2] = 1;
table[4] = 2;
table[6] = 4;
for (i = 8; i <= n; i = i + 2)
{
table[i] = table[i - 2] +
table[i - 4] +
table[i - 6];
}
return table[n];
}
let n = 8;
document.write(count(n));
</script>
|
Time Complexity: O(N)
Auxiliary Space Complexity: O(N)
Efficient approach : Space optimization O(1)
In previous approach we the current value dp[i] is only depend upon the previous 3 values i.e. dp[i-2], dp[i-4] and dp[i-6]. So to optimize the space we can keep track of previous and current values by the help of variables prev2, prev4, prev6 and curr which will reduce the space complexity from O(N) to O(1).
Implementation Steps:
- Create variables prev2, prev4 and prev6 to keep track o previous values of DP.
- Initialize base case and initialize variables.
- Create a variable sum to store current value.
- Iterate over subproblem using loop and update sum.
- After every iteration update prev2 ,prev4 and prev6 for further iterations.
- At last return sum.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int count( int n)
{
if (n == 2) return 1;
if (n == 4) return 2;
if (n == 6) return 4;
int sum = 0, i, prev2 = 1, prev4 = 2, prev6 = 4;
for (i = 8; i <= n; i += 2) {
sum = prev2 + prev4 + prev6;
prev2 = prev4;
prev4 = prev6;
prev6 = sum;
}
return sum;
}
int main( void )
{
int n = 8;
cout << count(n);
return 0;
}
|
Java
import java.io.*;
class Main {
static int count( int n)
{
if (n == 2 ) return 1 ;
if (n == 4 ) return 2 ;
if (n == 6 ) return 4 ;
int sum = 0 , i, prev2 = 1 , prev4 = 2 , prev6 = 4 ;
for (i = 8 ; i <= n; i += 2 ) {
sum = prev2 + prev4 + prev6;
prev2 = prev4;
prev4 = prev6;
prev6 = sum;
}
return sum;
}
public static void main(String[] args)
{
int n = 8 ;
System.out.println(count(n));
}
}
|
Python3
def count(n):
if n = = 2 :
return 1
if n = = 4 :
return 2
if n = = 6 :
return 4
sum = 0
prev2 = 1
prev4 = 2
prev6 = 4
for i in range ( 8 , n + 1 , 2 ):
sum = prev2 + prev4 + prev6
prev2 = prev4
prev4 = prev6
prev6 = sum
return sum
if __name__ = = '__main__' :
n = 8
print (count(n))
|
C#
using System;
class Program
{
static int Count( int n)
{
if (n == 2) return 1;
if (n == 4) return 2;
if (n == 6) return 4;
int sum = 0, i, prev2 = 1, prev4 = 2, prev6 = 4;
for (i = 8; i <= n; i += 2)
{
sum = prev2 + prev4 + prev6;
prev2 = prev4;
prev4 = prev6;
prev6 = sum;
}
return sum;
}
static void Main()
{
int n = 8;
int ways = Count(n);
Console.WriteLine( "Number of ways to reach {0}: {1}" , n, ways);
}
}
|
Javascript
function count(n) {
if (n === 2) return 1;
if (n === 4) return 2;
if (n === 6) return 4;
let sum = 0;
let prev2 = 1;
let prev4 = 2;
let prev6 = 4;
for (let i = 8; i <= n; i += 2) {
sum = prev2 + prev4 + prev6;
prev2 = prev4;
prev4 = prev6;
prev6 = sum;
}
return sum;
}
const n = 8;
console.log(count(n));
|
Time Complexity: O(N)
Auxiliary Space Complexity: O(1)
Last Updated :
03 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...