Open In App

Ways to represent a number as a sum of 1’s and 2’s

Improve
Improve
Like Article
Like
Save
Share
Report

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++




// 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




// 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




# 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#




// 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


Javascript




<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).

 



Last Updated : 08 Mar, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads