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 n, print out all the combination 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:

At first position we can have three numbers 1 or 2 or 3.
First put 1 at first position and recursively call for n-1.
Then put 2 at first position and recursively call for n-2.
Then put 3 at first position and recursively call for n-3.
If n becomes 0 then we have formed a combination that compose 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++

// CPP program to Print all  
// combinations of points that  
// can compose a given number 
#define MAX_POINT 3 
#define ARR_SIZE 100 
#include<stdio.h> 
  
/* 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. Initital 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. Initital 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. Initital 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.  
    // Initital 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

<?php 
// PHP program to Print all  
// combinations of points that  
// can compose a given number 
$MAX_POINT = 3; 
$ARR_SIZE = 100; 
  
$arr = array($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. Initital value 
of i must be passed as 0 */
function printCompositions($n, $i) 
{ 
    global $arr, $MAX_POINT, $ARR_SIZE; 
      
    /* 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); 
    } 
    else if($n > 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  
?> 

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

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

My Personal Notes

C/C++

Java

Python3

C#

PHP

Recommended Posts: