Skip to content
Related Articles

Related Articles

Improve Article

Print all combinations of points that can compose a given number

  • Difficulty Level : Medium
  • Last Updated : 28 May, 2021

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: 

  1. At first position we can have three numbers 1 or 2 or 3.
  2. First put 1 at first position and recursively call for n-1.
  3. Then put 2 at first position and recursively call for n-2.
  4. Then put 3 at first position and recursively call for n-3.
  5. 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++ program to Print all
// combinations of points that
// can compose a given number
#define MAX_POINT 3
#define ARR_SIZE 100
#include <bits/stdc++.h>
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. 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++)
        cout<<arr[i]<<" ";
    cout<<endl;
}
 
/* Driver code */
int main()
{
    int n = 5;
     
    cout<<"Different compositions formed by 1, 2 and 3 of "<<n<<" are\n";
    printCompositions(n, 0);
    return 0;
}
 
// This code is contributed by rathbhupendra

C




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

Javascript




<script>
 
// Javascript program to print all
// combinations of points that
// can compose a given number
 
// Function prlets all combinations of numbers
// 1, 2, ...MAX_POlet 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(arr, n, i)
{
    let MAX_POINT = 3;
    if (n == 0)
    {
        printArray(arr, i);
    }
    else if(n > 0)
    {
        for(let k = 1; k <= MAX_POINT; k++)
        {
            arr[i] = k;
            printCompositions(arr, n - k, i + 1);
        }
    }
}
 
// Utility function to print array arr[]
function printArray(arr, m)
{
    for(let i = 0; i < m; i++)
        document.write(arr[i] + " ");
         
    document.write("<br/>");
}
 
// Driver code
let n = 5;
let size = 100;
let arr = new Array(size).fill(0);
 
document.write("Different compositions formed " +
               "by 1, 2 and 3 of "+ n + " are" + "<br/>");
printCompositions(arr, n, 0);
 
// This code is contributed by avijitmondal1998
 
</script>

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.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :