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

• Difficulty Level : Medium
• Last Updated : 08 Mar, 2022

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

 ``

Output:

`8`

Time Complexity: O(logn).

Auxiliary Space: O(1).
This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.