GeeksforGeeks App
Open App
Browser
Continue

# Print all combinations of points that can compose a given number

You can win three kinds of basketball points, 1 point, 2 points, and 3 points. Given a total score of n, print out all the combinations to compose n.

Examples:

```For n = 1, the program should print following:
1

For n = 2, the program should print following:
1 1
2

For n = 3, the program should print following:
1 1 1
1 2
2 1
3

For n = 4, the program should print following:
1 1 1 1
1 1 2
1 2 1
1 3
2 1 1
2 2
3 1

and so on ...```

Algorithm:

1. In the first position, we can have three numbers 1 or 2 or 3.
2. First, put 1 at the first position and recursively call for n-1.
3. Then put 2 at the first position and recursively call for n-2.
4. Then put 3 at the first position and recursively call for n-3.
5. If n becomes 0 then we have formed a combination that composes n, so print the current combination.

Below is a generalized implementation. In the below implementation, we can change MAX_POINT if there are higher points (more than 3) in the basketball game.

## C++

 `// C++ program to Print all``// combinations of points that``// can compose a given number``#define MAX_POINT 3``#define ARR_SIZE 100``#include ``using` `namespace` `std;` `/* Utility function to print array arr[] */``void` `printArray(``int` `arr[], ``int` `arr_size);` `/* The function prints all combinations of numbers 1, 2, ...MAX_POINT``that sum up to n.``i is used in recursion keep track of index in arr[] where next``element is to be added. Initial value of i must be passed as 0 */``void` `printCompositions(``int` `n, ``int` `i)``{` `    ``/* array must be static as we want to keep track``    ``of values stored in arr[] using current calls of``    ``printCompositions() in function call stack*/``    ``static` `int` `arr[ARR_SIZE];``    ` `    ``if` `(n == 0)``    ``{``        ``printArray(arr, i);``    ``}``    ``else` `if``(n > 0)``    ``{``        ``int` `k;``        ``for` `(k = 1; k <= MAX_POINT; k++)``        ``{``            ``arr[i]= k;``            ``printCompositions(n-k, i+1);``        ``}``    ``}``}` `/* UTILITY FUNCTIONS */``/* Utility function to print array arr[] */``void` `printArray(``int` `arr[], ``int` `arr_size)``{``    ``int` `i;``    ``for` `(i = 0; i < arr_size; i++)``        ``cout<

## C

 `// C program to Print all``// combinations of points that``// can compose a given number``#define MAX_POINT 3``#define ARR_SIZE 100``#include` `/* Utility function to print array arr[] */``void` `printArray(``int` `arr[], ``int` `arr_size);` `/* The function prints all combinations of numbers 1, 2, ...MAX_POINT``that sum up to n.``i is used in recursion keep track of index in arr[] where next``element is to be added. Initial value of i must be passed as 0 */``void` `printCompositions(``int` `n, ``int` `i)``{` `    ``/* array must be static as we want to keep track``    ``of values stored in arr[] using current calls of``    ``printCompositions() in function call stack*/``    ``static` `int` `arr[ARR_SIZE];``    ` `    ``if` `(n == 0)``    ``{``        ``printArray(arr, i);``    ``}``    ``else` `if``(n > 0)``    ``{``        ``int` `k;``        ``for` `(k = 1; k <= MAX_POINT; k++)``        ``{``        ``arr[i]= k;``        ``printCompositions(n-k, i+1);``        ``}``    ``}``}` `/* UTILITY FUNCTIONS */``/* Utility function to print array arr[] */``void` `printArray(``int` `arr[], ``int` `arr_size)``{``    ``int` `i;``    ``for` `(i = 0; i < arr_size; i++)``        ``printf``(``"%d "``, arr[i]);``    ``printf``(``"\n"``);``}` `/* Driver function to test above functions */``int` `main()``{``    ``int` `n = 5;``    ` `    ``printf``(``"Different compositions formed by 1, 2 and 3 of %d are\n"``, n);``    ``printCompositions(n, 0);``    ` `    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java program to Print all``// combinations of points that``// can compose a given number``import` `java.io.*;` `class` `GFG``{``    ``// Function prints all combinations of numbers 1, 2, ...MAX_POINT``    ``// that sum up to n.``    ``// i is used in recursion keep track of index in arr[] where next``    ``// element is to be added. Initial value of i must be passed as 0``    ``static` `void` `printCompositions(``int` `arr[], ``int` `n, ``int` `i)``    ``{``        ``int` `MAX_POINT = ``3``;``        ``if` `(n == ``0``)``        ``{``            ``printArray(arr, i);``        ``}``        ``else` `if``(n > ``0``)``        ``{``            ``for` `(``int` `k = ``1``; k <= MAX_POINT; k++)``            ``{``                ``arr[i]= k;``                ``printCompositions(arr, n-k, i+``1``);``            ``}``        ``}``    ``}``    ` `    ``// Utility function to print array arr[]``    ``static` `void` `printArray(``int` `arr[], ``int` `m)``    ``{``        ``for` `(``int` `i = ``0``; i < m; i++)``            ``System.out.print(arr[i] + ``" "``);``        ``System.out.println();``    ``}``    ` `    ` `    ``// Driver program``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `n = ``5``;``        ``int` `size = ``100``;``        ``int``[] arr = ``new` `int``[size];``        ``System.out.println(``"Different compositions formed by 1, 2 and 3 of "``+ n + ``" are"``);``        ``printCompositions(arr, n, ``0``);``    ``}``}` `// Contributed by Pramod Kumar`

## Python3

 `# Python3 program to Print all combinations``# of points that can compose a given number``MAX_POINT ``=` `3``;``ARR_SIZE ``=` `100``;` `arr ``=` `[``0``] ``*` `ARR_SIZE;` `# The function prints all combinations``# of numbers 1, 2, ...MAX_POINT that sum``# up to n. i is used in recursion keep``# track of index in arr[] where next``# element is to be added. Initial value``# of i must be passed as 0``def` `printCompositions(n, i):``    ` `    ``# array must be static as we``    ``# want to keep track of values``    ``# stored in arr[] using current``    ``# calls of printCompositions() in``    ``# function call stack*/``    ``if` `(n ``=``=` `0``):``        ``printArray(arr, i);``    ``elif``(n > ``0``):``        ``for` `k ``in` `range``(``1``,MAX_POINT ``+` `1``):``            ``arr[i] ``=` `k;``            ``printCompositions(n ``-` `k, i ``+` `1``);` `# UTILITY FUNCTIONS */``# Utility function to print array arr[] */``def` `printArray(arr, arr_size):``    ``for` `i ``in` `range``(arr_size):``        ``print``(arr[i], end ``=` `" "``);``    ``print``();` `# Driver Code``n ``=` `5``;``print``(``"Different compositions formed "` `+``         ``"by 1, 2 and 3 of"``, n, ``" are"``);``printCompositions(n, ``0``);` `# This code is contributed by mits`

## C#

 `// C# program to Print all``// combinations of points that``// can compose a given number``using` `System;` `class` `GFG {``    ` `    ``// Function prints all combinations of numbers``    ``// 1, 2, ...MAX_POINT that sum up to n. i is``    ``// used in recursion keep track of index in``    ``// arr[] where next element is to be added.``    ``// Initial value of i must be passed as 0``    ``static` `void` `printCompositions(``int``[] arr, ``int` `n, ``int` `i)``    ``{``        ``int` `MAX_POINT = 3;``        ``if` `(n == 0) {``            ``printArray(arr, i);``        ``}``        ``else` `if` `(n > 0) {``            ``for` `(``int` `k = 1; k <= MAX_POINT; k++) {``                ``arr[i] = k;``                ``printCompositions(arr, n - k, i + 1);``            ``}``        ``}``    ``}` `    ``// Utility function to print array arr[]``    ``static` `void` `printArray(``int``[] arr, ``int` `m)``    ``{``        ``for` `(``int` `i = 0; i < m; i++)``            ``Console.Write(arr[i] + ``" "``);``        ``Console.WriteLine();``    ``}` `    ``// Driver program``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 5;``        ``int` `size = 100;``        ``int``[] arr = ``new` `int``[size];``        ` `        ``Console.WriteLine(``"Different compositions formed"``                    ``+ ``" by 1, 2 and 3 of "` `+ n + ``" are"``);``        ``printCompositions(arr, n, 0);``    ``}``}` `// Contributed by Sam007`

## PHP

 ` 0)``    ``{``        ``for` `(``\$k` `= 1; ``\$k` `<= ``\$MAX_POINT``; ``\$k``++)``        ``{``            ``\$arr``[``\$i``] = ``\$k``;``            ``printCompositions(``\$n` `- ``\$k``, ``\$i` `+ 1);``        ``}``    ``}``}` `/* UTILITY FUNCTIONS */``/* Utility function to print array arr[] */``function` `printArray(``\$arr``, ``\$arr_size``)``{``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$arr_size``; ``\$i``++)``        ``echo` `\$arr``[``\$i``].``" "``;``    ``echo` `"\n"``;``}` `// Driver Code``\$n` `= 5;` `echo` `"Different compositions formed"` `.``     ``" by 1, 2 and 3 of "``.``\$n``.``" are\n"``;``printCompositions(``\$n``, 0);` `// This code is contributed by mits``?>`

## Javascript

 ``

Output:

```Different compositions formed by 1, 2 and 3 of 5 are
1 1 1 1 1
1 1 1 2
1 1 2 1
1 1 3
1 2 1 1
1 2 2
1 3 1
2 1 1 1
2 1 2
2 2 1
2 3
3 1 1
3 2 ```

Time Complexity:O(3n)

Auxiliary Space:O(n)

Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up