Given a positive integer N. The task is to find the number of ways of representing N as a sum of 1s and 2s.
Examples:
Input : N = 3 Output : 3 3 can be represented as (1+1+1), (2+1), (1+2). Input : N = 5 Output : 8
For N = 1, answer is 1.
For N = 2. (1 + 1), (2), answer is 2.
For N = 3. (1 + 1 + 1), (2 + 1), (1 + 2), answer is 3.
For N = 4. (1 + 1 + 1 + 1), (2 + 1 + 1), (1 + 2 + 1), (1 + 1 + 2), (2 + 2) answer is 5.
And so on.
It can be observed that it form Fibonacci Series. So, the number of ways of representing N as a sum of 1s and 2s is (N + 1)th Fibonacci number.
How?
We can easily see that the recursive function is exactly the same as Fibonacci Numbers. To obtain the sum of N, we can add 1 to N - 1. Also, we can add 2 to N - 2. And only 1 and 2 are allowed to make the sum N. So, to obtain sum N using 1s and 2s, total ways are: number of ways to obtain (N - 1) + number of ways to obtain (N - 2).
We can find N'th Fibonacci Number in O(Log n) time. Please refer to method 5 of this post.
Below is the implementation of this approach:
// C++ program to find number of ways to representing
// a number as a sum of 1's and 2's
#include <bits/stdc++.h>
using namespace std;
// Function to multiply matrix.
void multiply(int F[2][2], int M[2][2])
{
int x = F[0][0]*M[0][0] + F[0][1]*M[1][0];
int y = F[0][0]*M[0][1] + F[0][1]*M[1][1];
int z = F[1][0]*M[0][0] + F[1][1]*M[1][0];
int w = F[1][0]*M[0][1] + F[1][1]*M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
// Power function in log n
void power(int F[2][2], int n)
{
if( n == 0 || n == 1)
return;
int M[2][2] = {{1,1},{1,0}};
power(F, n/2);
multiply(F, F);
if (n%2 != 0)
multiply(F, M);
}
/* function that returns (n+1)th Fibonacci number
Or number of ways to represent n as sum of 1's
2's */
int countWays(int n)
{
int F[2][2] = {{1,1},{1,0}};
if (n == 0)
return 0;
power(F, n);
return F[0][0];
}
// Driver program
int main()
{
int n = 5;
cout << countWays(n) << endl;
return 0;
}
// Java program to find number of
// ways to representing a number
// as a sum of 1's and 2's
class GFG
{
// Function to multiply matrix.
static void multiply(int F[][], int M[][])
{
int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
// Power function in log n
static void power(int F[][], int n)
{
if (n == 0 || n == 1)
{
return;
}
int M[][] = {{1, 1}, {1, 0}};
power(F, n / 2);
multiply(F, F);
if (n % 2 != 0)
{
multiply(F, M);
}
}
/* function that returns (n+1)th Fibonacci number
Or number of ways to represent n as sum of 1's
2's */
static int countWays(int n)
{
int F[][] = {{1, 1}, {1, 0}};
if (n == 0)
{
return 0;
}
power(F, n);
return F[0][0];
}
// Driver program
public static void main(String[] args)
{
int n = 5;
System.out.println(countWays(n));
}
}
// This code contributed by Rajput-Ji
# Python3 program to find number of ways to
# representing a number as a sum of 1's and 2's
# Function to multiply matrix.
def multiply(F, M):
x = F[0][0] * M[0][0] + F[0][1] * M[1][0]
y = F[0][0] * M[0][1] + F[0][1] * M[1][1]
z = F[1][0] * M[0][0] + F[1][1] * M[1][0]
w = F[1][0] * M[0][1] + F[1][1] * M[1][1]
F[0][0] = x
F[0][1] = y
F[1][0] = z
F[1][1] = w
# Power function in log n
def power(F, n):
if( n == 0 or n == 1):
return
M = [[1, 1],[1, 0]]
power(F, n // 2)
multiply(F, F)
if (n % 2 != 0):
multiply(F, M)
#/* function that returns (n+1)th Fibonacci number
# Or number of ways to represent n as sum of 1's
# 2's */
def countWays(n):
F = [[1, 1], [1, 0]]
if (n == 0):
return 0
power(F, n)
return F[0][0]
# Driver Code
n = 5
print(countWays(n))
# This code is contributed by mohit kumar
// C# program to find number of
// ways to representing a number
// as a sum of 1's and 2's
class GFG
{
// Function to multiply matrix.
static void multiply(int [,]F, int [,]M)
{
int x = F[0,0] * M[0,0] + F[0,1] * M[1,0];
int y = F[0,0] * M[0,1] + F[0,1] * M[1,1];
int z = F[1,0] * M[0,0] + F[1,1] * M[1,0];
int w = F[1,0] * M[0,1] + F[1,1] * M[1,1];
F[0,0] = x;
F[0,1] = y;
F[1,0] = z;
F[1,1] = w;
}
// Power function in log n
static void power(int [,]F, int n)
{
if (n == 0 || n == 1)
{
return;
}
int [,]M = {{1, 1}, {1, 0}};
power(F, n / 2);
multiply(F, F);
if (n % 2 != 0)
{
multiply(F, M);
}
}
/* function that returns (n+1)th Fibonacci number
Or number of ways to represent n as sum of 1's
2's */
static int countWays(int n)
{
int [,]F = {{1, 1}, {1, 0}};
if (n == 0)
{
return 0;
}
power(F, n);
return F[0,0];
}
// Driver program
public static void Main()
{
int n = 5;
System.Console.WriteLine(countWays(n));
}
}
// This code contributed by mits
<script>
// Javascript program to find number of
// ways to representing a number
// as a sum of 1's and 2's
// Function to multiply matrix.
function multiply(F , M)
{
var x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
var y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
var z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
var w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
// Power function in log n
function power(F , n)
{
if (n == 0 || n == 1)
{
return;
}
var M = [[1, 1], [1, 0]];
power(F, parseInt(n / 2));
multiply(F, F);
if (n % 2 != 0)
{
multiply(F, M);
}
}
/* function that returns (n+1)th Fibonacci number
Or number of ways to represent n as sum of 1's
2's */
function countWays(n)
{
var F = [[1, 1], [1, 0]];
if (n == 0)
{
return 0;
}
power(F, n);
return F[0][0];
}
// Driver program
var n = 5;
document.write(countWays(n));
// This code is contributed by 29AjayKumar
</script>
Output:
8
Time Complexity: O(logn).
Auxiliary Space: O(1).
