Print all distinct combinations of sum x and n natural number

Here given code implementation process.

// C Program
// Print all distinct combinations of sum x and n natural number
#include <stdio.h>

// Display result
void printSequence(int result[], int k)
{
    for (int i = 0; i < k; ++i)
    {
        printf(" %d", result[i]);
    }
    printf("\n ");
}
void findCombination(int result[], int index, int sum, int x, int n)
{
    if (sum == x)
    {
        // Display calculated result
        printSequence(result, index);
        return;
    }
    if (sum > x || index >= x)
    {
        // Base case when stop process
        return;
    }
    for (int i = n; i >= 1; --i)
    {
        // Collect result value
        result[index] = i;
        findCombination(result, index + 1, sum + i, x, i);
    }
}
// Handles the request of find combination of given n and x
void combination(int x,int n)
{
    if (n <= 0 || x <= 0)
    {
        return;
    }
    printf("\n Given n : %d  x : %d \n ", n,x);
    // Collect result
    int result[x];
    // Test
    findCombination(result, 0, 0, x, n);
}
int main()
{   
  	// Test A
    // n = 3 means use [1,2,3]
    int n = 3;
    // Sum x = 10
    int x = 10;
    combination(x,n);
  	
  	// Test B
  	// n = 4 means use [1,2,3,4]
    n = 4;
    // Sum x = 12
    x = 12;
    combination(x,n);
  
  
    return 0;
}

Output

 Given n : 3  x : 10
  3 3 3 1
  3 3 2 2
  3 3 2 1 1
  3 3 1 1 1 1
  3 2 2 2 1
  3 2 2 1 1 1
  3 2 1 1 1 1 1
  3 1 1 1 1 1 1 1
  2 2 2 2 2
  2 2 2 2 1 1
  2 2 2 1 1 1 1
  2 2 1 1 1 1 1 1
  2 1 1 1 1 1 1 1 1
  1 1 1 1 1 1 1 1 1 1

 Given n : 4  x : 12
  4 4 4
  4 4 3 1
  4 4 2 2
  4 4 2 1 1
  4 4 1 1 1 1
  4 3 3 2
  4 3 3 1 1
  4 3 2 2 1
  4 3 2 1 1 1
  4 3 1 1 1 1 1
  4 2 2 2 2
  4 2 2 2 1 1
  4 2 2 1 1 1 1
  4 2 1 1 1 1 1 1
  4 1 1 1 1 1 1 1 1
  3 3 3 3
  3 3 3 2 1
  3 3 3 1 1 1
  3 3 2 2 2
  3 3 2 2 1 1
  3 3 2 1 1 1 1
  3 3 1 1 1 1 1 1
  3 2 2 2 2 1
  3 2 2 2 1 1 1
  3 2 2 1 1 1 1 1
  3 2 1 1 1 1 1 1 1
  3 1 1 1 1 1 1 1 1 1
  2 2 2 2 2 2
  2 2 2 2 2 1 1
  2 2 2 2 1 1 1 1
  2 2 2 1 1 1 1 1 1
  2 2 1 1 1 1 1 1 1 1
  2 1 1 1 1 1 1 1 1 1 1
  1 1 1 1 1 1 1 1 1 1 1 1

// Java Program for
// Print all distinct combinations of sum x and n natural number
public class SumCombination
{
	// Display result
	public void printSequence(int[] result, int k)
	{
		for (int i = 0; i < k; ++i)
		{
			System.out.print("  " + result[i]);
		}
		System.out.print("\n");
	}
	public void findCombination(int[] result, 
                                int index, 
                                int sum, 
                                int x, 
                                int n)
	{
		if (sum == x)
		{
			// Display calculated result
			printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		for (int i = n; i >= 1; --i)
		{
			// Collect result value
			result[index] = i;
			findCombination(result, index + 1, sum + i, x, i);
		}
	}
	// Handles the request of find combination of given n and x
	public void combination(int x, int n)
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		System.out.println("\n Given n : " + n + " x : " + x);
		// Collect result
		int[] result = new int[x];
		// Test
		findCombination(result, 0, 0, x, n);
	}
	public static void main(String[] args)
	{
		SumCombination task = new SumCombination();
		// Test A
		// n = 3 means use [1,2,3]
		int n = 3;
		// Sum x = 10
		int x = 10;
		task.combination(x, n);
		// Test B
		// n = 4 means use [1,2,3,4]
		n = 4;
		// Sum x = 12
		x = 12;
		task.combination(x, n);
	}
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Include header file
#include <iostream>

using namespace std;
// C++ Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination
{
	public:
		// Display result
		void printSequence(int result[], int k)
		{
			for (int i = 0; i < k; ++i)
			{
				cout << "  " << result[i];
			}
			cout << "\n";
		}
	void findCombination(int result[], int index, int sum, int x, int n)
	{
		if (sum == x)
		{
			// Display calculated result
			this->printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		for (int i = n; i >= 1; --i)
		{
			// Collect result value
			result[index] = i;
			this->findCombination(result, index + 1, sum + i, x, i);
		}
	}
	// Handles the request of find combination of given n and x
	void combination(int x, int n)
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		cout << "\n Given n : " << n << " x : " << x << endl;
		// Collect result
		int result[x];
		// Test
		this->findCombination(result, 0, 0, x, n);
	}
};
int main()
{
	SumCombination *task = new SumCombination();
	// Test A
	// n = 3 means use [1,2,3]
	int n = 3;
	// Sum x = 10
	int x = 10;
	task->combination(x, n);
	// Test B
	// n = 4 means use [1,2,3,4]
	n = 4;
	// Sum x = 12
	x = 12;
	task->combination(x, n);
	return 0;
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

package main
import "fmt"
// Go Program for
// Print all distinct combinations of sum x and n natural number
type SumCombination struct {}
func getSumCombination() * SumCombination {
	var me *SumCombination = &SumCombination {}
	return me
}
// Display result
func(this SumCombination) printSequence(result[] int, k int) {
	for i := 0 ; i < k ; i++ {
		fmt.Print("  ", result[i])
	}
	fmt.Print("\n")
}
func(this SumCombination) findCombination(result[] int, 
                           index int, sum int, x int, n int) {
	if sum == x {
		// Display calculated result
		this.printSequence(result, index)
		return
	}
	if sum > x || index >= x {
		// Base case when stop process
		return
	}
	for i := n ; i >= 1 ; i-- {
		// Collect result value
		result[index] = i
		this.findCombination(result, index + 1, sum + i, x, i)
	}
}
// Handles the request of find combination of given n and x
func(this SumCombination) combination(x, n int) {
	if n <= 0 || x <= 0 {
		return
	}
	fmt.Println("\n Given n : ", n, " x : ", x)
	// Collect result
	var result = make([] int, x)
	// Test
	this.findCombination(result, 0, 0, x, n)
}
func main() {
	var task * SumCombination = getSumCombination()
	// Test A
	// n = 3 means use [1,2,3]
	var n int = 3
	// Sum x = 10
	var x int = 10
	task.combination(x, n)
	// Test B
	// n = 4 means use [1,2,3,4]
	n = 4
	// Sum x = 12
	x = 12
	task.combination(x, n)
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Include namespace system
using System;
// Csharp Program for
// Print all distinct combinations of sum x and n natural number
public class SumCombination
{
	// Display result
	public void printSequence(int[] result, int k)
	{
		for (int i = 0; i < k; ++i)
		{
			Console.Write("  " + result[i]);
		}
		Console.Write("\n");
	}
	public void findCombination(int[] result, 
                                int index, 
                                int sum, 
                                int x, 
                                int n)
	{
		if (sum == x)
		{
			// Display calculated result
			this.printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		for (int i = n; i >= 1; --i)
		{
			// Collect result value
			result[index] = i;
			this.findCombination(result, index + 1, sum + i, x, i);
		}
	}
	// Handles the request of find combination of given n and x
	public void combination(int x, int n)
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		Console.WriteLine("\n Given n : " + n + " x : " + x);
		// Collect result
		int[] result = new int[x];
		// Test
		this.findCombination(result, 0, 0, x, n);
	}
	public static void Main(String[] args)
	{
		SumCombination task = new SumCombination();
		// Test A
		// n = 3 means use [1,2,3]
		int n = 3;
		// Sum x = 10
		int x = 10;
		task.combination(x, n);
		// Test B
		// n = 4 means use [1,2,3,4]
		n = 4;
		// Sum x = 12
		x = 12;
		task.combination(x, n);
	}
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

<?php
// Php Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination
{
	// Display result
	public	function printSequence($result, $k)
	{
		for ($i = 0; $i < $k; ++$i)
		{
			echo("  ".$result[$i]);
		}
		echo("\n");
	}
	public	function findCombination($result, $index, $sum, $x, $n)
	{
		if ($sum == $x)
		{
			// Display calculated result
			$this->printSequence($result, $index);
			return;
		}
		if ($sum > $x || $index >= $x)
		{
			// Base case when stop process
			return;
		}
		for ($i = $n; $i >= 1; --$i)
		{
			// Collect result value
			$result[$index] = $i;
			$this->findCombination($result, $index + 1, $sum + $i, $x, $i);
		}
	}
	// Handles the request of find combination of given n and x
	public	function combination($x, $n)
	{
		if ($n <= 0 || $x <= 0)
		{
			return;
		}
		echo("\n Given n : ".$n.
			" x : ".$x.
			"\n");
		// Collect result
		$result = array_fill(0, $x, 0);
		// Test
		$this->findCombination($result, 0, 0, $x, $n);
	}
}

function main()
{
	$task = new SumCombination();
	// Test A
	// n = 3 means use [1,2,3]
	$n = 3;
	// Sum x = 10
	$x = 10;
	$task->combination($x, $n);
	// Test B
	// n = 4 means use [1,2,3,4]
	$n = 4;
	// Sum x = 12
	$x = 12;
	$task->combination($x, $n);
}
main();

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Node JS Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination
{
	// Display result
	printSequence(result, k)
	{
		for (var i = 0; i < k; ++i)
		{
			process.stdout.write("  " + result[i]);
		}
		process.stdout.write("\n");
	}
	findCombination(result, index, sum, x, n)
	{
		if (sum == x)
		{
			// Display calculated result
			this.printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		for (var i = n; i >= 1; --i)
		{
			// Collect result value
			result[index] = i;
			this.findCombination(result, index + 1, sum + i, x, i);
		}
	}
	// Handles the request of find combination of given n and x
	combination(x, n)
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		console.log("\n Given n : " + n + " x : " + x);
		// Collect result
		var result = Array(x).fill(0);
		// Test
		this.findCombination(result, 0, 0, x, n);
	}
}

function main()
{
	var task = new SumCombination();
	// Test A
	// n = 3 means use [1,2,3]
	var n = 3;
	// Sum x = 10
	var x = 10;
	task.combination(x, n);
	// Test B
	// n = 4 means use [1,2,3,4]
	n = 4;
	// Sum x = 12
	x = 12;
	task.combination(x, n);
}
main();

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

#  Python 3 Program for
#  Print all distinct combinations of sum x and n natural number
class SumCombination :
	#  Display result
	def printSequence(self, result, k) :
		i = 0
		while (i < k) :
			print(" ", result[i], end = "")
			i += 1
		
		print(end = "\n")
	
	def findCombination(self, result, index, sum, x, n) :
		if (sum == x) :
			#  Display calculated result
			self.printSequence(result, index)
			return
		
		if (sum > x or index >= x) :
			#  Base case when stop process
			return
		
		i = n
		while (i >= 1) :
			#  Collect result value
			result[index] = i
			self.findCombination(result, index + 1, sum + i, x, i)
			i -= 1
		
	
	#  Handles the request of find combination of given n and x
	def combination(self, x, n) :
		if (n <= 0 or x <= 0) :
			return
		
		print("\n Given n : ", n ," x : ", x)
		#  Collect result
		result = [0] * (x)
		#  Test
		self.findCombination(result, 0, 0, x, n)
	

def main() :
	task = SumCombination()
	#  Test A
	#  n = 3 means use [1,2,3]
	n = 3
	#  Sum x = 10
	x = 10
	task.combination(x, n)
	#  Test B
	#  n = 4 means use [1,2,3,4]
	n = 4
	#  Sum x = 12
	x = 12
	task.combination(x, n)

if __name__ == "__main__": main()

Output

 Given n :  3  x :  10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n :  4  x :  12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

#  Ruby Program for
#  Print all distinct combinations of sum x and n natural number
class SumCombination 
	#  Display result
	def printSequence(result, k) 
		i = 0
		while (i < k) 
			print("  ", result[i])
			i += 1
		end

		print("\n")
	end

	def findCombination(result, index, sum, x, n) 
		if (sum == x) 
			#  Display calculated result
			self.printSequence(result, index)
			return
		end

		if (sum > x || index >= x) 
			#  Base case when stop process
			return
		end

		i = n
		while (i >= 1) 
			#  Collect result value
			result[index] = i
			self.findCombination(result, index + 1, sum + i, x, i)
			i -= 1
		end

	end

	#  Handles the request of find combination of given n and x
	def combination(x, n) 
		if (n <= 0 || x <= 0) 
			return
		end

		print("\n Given n : ", n ," x : ", x, "\n")
		#  Collect result
		result = Array.new(x) {0}
		#  Test
		self.findCombination(result, 0, 0, x, n)
	end

end

def main() 
	task = SumCombination.new()
	#  Test A
	#  n = 3 means use [1,2,3]
	n = 3
	#  Sum x = 10
	x = 10
	task.combination(x, n)
	#  Test B
	#  n = 4 means use [1,2,3,4]
	n = 4
	#  Sum x = 12
	x = 12
	task.combination(x, n)
end

main()

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Scala Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination()
{
	// Display result
	def printSequence(result: Array[Int], k: Int): Unit = {
		var i: Int = 0;
		while (i < k)
		{
			print("  " + result(i));
			i += 1;
		}
		print("\n");
	}
	def findCombination(result: Array[Int], 
      index: Int, sum: Int, x: Int, n: Int): Unit = {
		if (sum == x)
		{
			// Display calculated result
			printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		var i: Int = n;
		while (i >= 1)
		{
			// Collect result value
			result(index) = i;
			findCombination(result, index + 1, sum + i, x, i);
			i -= 1;
		}
	}
	// Handles the request of find combination of given n and x
	def combination(x: Int, n: Int): Unit = {
		if (n <= 0 || x <= 0)
		{
			return;
		}
		println("\n Given n : " + n + " x : " + x);
		// Collect result
		var result: Array[Int] = Array.fill[Int](x)(0);
		// Test
		findCombination(result, 0, 0, x, n);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: SumCombination = new SumCombination();
		// Test A
		// n = 3 means use [1,2,3]
		var n: Int = 3;
		// Sum x = 10
		var x: Int = 10;
		task.combination(x, n);
		// Test B
		// n = 4 means use [1,2,3,4]
		n = 4;
		// Sum x = 12
		x = 12;
		task.combination(x, n);
	}
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Swift 4 Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination
{
	// Display result
	func printSequence(_ result: [Int], _ k: Int)
	{
		var i: Int = 0;
		while (i < k)
		{
			print(" ", result[i], terminator: "");
			i += 1;
		}
		print(terminator: "\n");
	}
	func findCombination(_ result: inout[Int], 
      _ index: Int, _ sum: Int, _ x: Int, _ n: Int)
	{
		if (sum == x)
		{
			// Display calculated result
			self.printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		var i: Int = n;
		while (i >= 1)
		{
			// Collect result value
			result[index] = i;
			self.findCombination(&result, index + 1, sum + i, x, i);
			i -= 1;
		}
	}
	// Handles the request of find combination of given n and x
	func combination(_ x: Int, _ n: Int)
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		print("\n Given n : ", n ," x : ", x);
		// Collect result
		var result: [Int] = Array(repeating: 0, count: x);
		// Test
		self.findCombination(&result, 0, 0, x, n);
	}
}
func main()
{
	let task: SumCombination = SumCombination();
	// Test A
	// n = 3 means use [1,2,3]
	var n: Int = 3;
	// Sum x = 10
	var x: Int = 10;
	task.combination(x, n);
	// Test B
	// n = 4 means use [1,2,3,4]
	n = 4;
	// Sum x = 12
	x = 12;
	task.combination(x, n);
}
main();

Output

 Given n :  3  x :  10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n :  4  x :  12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

// Kotlin Program for
// Print all distinct combinations of sum x and n natural number
class SumCombination
{
	// Display result
	fun printSequence(result: Array < Int > , k: Int): Unit
	{
		var i: Int = 0;
		while (i < k)
		{
			print("  " + result[i]);
			i += 1;
		}
		print("\n");
	}
	fun findCombination(result: Array < Int > , 
                        index: Int, sum: Int, 
                        x: Int, n: Int): Unit
	{
		if (sum == x)
		{
			// Display calculated result
			this.printSequence(result, index);
			return;
		}
		if (sum > x || index >= x)
		{
			// Base case when stop process
			return;
		}
		var i: Int = n;
		while (i >= 1)
		{
			// Collect result value
			result[index] = i;
			this.findCombination(result, index + 1, sum + i, x, i);
			i -= 1;
		}
	}
	// Handles the request of find combination of given n and x
	fun combination(x: Int, n: Int): Unit
	{
		if (n <= 0 || x <= 0)
		{
			return;
		}
		println("\n Given n : " + n + " x : " + x);
		// Collect result
		val result: Array < Int > = Array(x)
		{
			0
		};
		// Test
		this.findCombination(result, 0, 0, x, n);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: SumCombination = SumCombination();
	// Test A
	// n = 3 means use [1,2,3]
	var n: Int = 3;
	// Sum x = 10
	var x: Int = 10;
	task.combination(x, n);
	// Test B
	// n = 4 means use [1,2,3,4]
	n = 4;
	// Sum x = 12
	x = 12;
	task.combination(x, n);
}

Output

 Given n : 3 x : 10
  3  3  3  1
  3  3  2  2
  3  3  2  1  1
  3  3  1  1  1  1
  3  2  2  2  1
  3  2  2  1  1  1
  3  2  1  1  1  1  1
  3  1  1  1  1  1  1  1
  2  2  2  2  2
  2  2  2  2  1  1
  2  2  2  1  1  1  1
  2  2  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1

 Given n : 4 x : 12
  4  4  4
  4  4  3  1
  4  4  2  2
  4  4  2  1  1
  4  4  1  1  1  1
  4  3  3  2
  4  3  3  1  1
  4  3  2  2  1
  4  3  2  1  1  1
  4  3  1  1  1  1  1
  4  2  2  2  2
  4  2  2  2  1  1
  4  2  2  1  1  1  1
  4  2  1  1  1  1  1  1
  4  1  1  1  1  1  1  1  1
  3  3  3  3
  3  3  3  2  1
  3  3  3  1  1  1
  3  3  2  2  2
  3  3  2  2  1  1
  3  3  2  1  1  1  1
  3  3  1  1  1  1  1  1
  3  2  2  2  2  1
  3  2  2  2  1  1  1
  3  2  2  1  1  1  1  1
  3  2  1  1  1  1  1  1  1
  3  1  1  1  1  1  1  1  1  1
  2  2  2  2  2  2
  2  2  2  2  2  1  1
  2  2  2  2  1  1  1  1
  2  2  2  1  1  1  1  1  1
  2  2  1  1  1  1  1  1  1  1
  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1

« Previous Next »

Backtracking

Print all permutations of a string

Print all combinations of balanced parentheses

Print all solutions in N-Queen Problem

Distinct permutations of the string

Warnsdorff’s algorithm for knight’s tour problem

Rat in a Maze

Find all solutions in a maze

Print all Hamiltonian path present in a graph

Print all intervals of given number

Find longest path in maze

Find longest increasing path in a matrix

Subset sum using backtracking

Find max number using k swap

Locate the center path of given maze by using footprint

Permutation with spaces

Tug of War

K partition with equal sum

Longest common subsequence

Print all longest common subsequence

Find all subsets using backtracking

Surrounded Regions

Generate n bit gray code

Find permutation of numbers divisible by k

Find maximum size subset with given sum

Split a number into smaller numbers

Find all subsequences with given sum and length

Find all perfect square root of n digit

Find all possible path with one magical key in maze

Print all permutations with repetition of characters

Print all initials sequences of given length

Print k size combinations in given array

Split a numeric string into fibonacci sequence

Print all N digit strictly increasing numbers

Print all possible strings of length N in a set

Knight Tour Problem

Generate all the binary strings of N bits

Print all binary strings without consecutive 1s

Generate all binary strings from given pattern

Print all palindrome permutations of a string

Possible ways to break a string using brackets

Print all interleavings of two strings

Longest possible route in a matrix with hurdles

Find all distinct combinations of k sum in array

Find paths from corner cell to middle cell in maze

Fill two instances of all numbers from 1 to n in a specific interval

Split a string into maximum number of unique substrings

Generate minimum number of coins that make a given value

Letter case permutation by using backtracking

Find all subsequences of string which divisible by k

Find possible group which contains one and two consecutive elements

Display Friends Pairing Group

Display all possible permutations of a number divisible by K

Power set in lexicographic order

Print all possible combinations of given size

Print all subsets with given sum

Print all possible combinations of given sum from 1 to n

Print distinct combinations of given sum without repeating number

Print all subsequences of given size

Print all sequences from 1 to n in given length k

Increasing subsequence of n natural number in k size

Print all non-increasing sequence of sum equal to a given number k

Print all combinations of N length sequences whose product is M

Distinct combinations of N length sequences whose product is M

Sequences of length K having each term divisible by its preceding term

Find all subsequences whose product is less than k in array

Find all subsequences of N length whose sum is even

Print all combinations of n natural number whose pair element difference is one

Find all even length binary sequences with same sum of first and second half bits

Print all subsequences of x whose sum is combination of even numbers

Generate palindromic binary strings of given length N

Generate all palindromic subsequence of n natural number

Generate all palindromic subsequence of length N and K Odd natural number

Generate all palindromic subsequence of length N and K Even natural number

Generate all palindromic subsequence of n natural number Whose adjacent elements are different type

Find Subset sum which divisible by k

Generate fixed bitonic sequence of n natural number

Generate all bitonic sequence of given range and size

Find all four elements that sum to a given value

Print all combinations factors of given number

Print combinations of characters of a numeric string which is less than x

Print all combinations of other digits on a '$' place of given sequence

All combinations of strings that can be used to dial a number

Travelling salesman problem using backtracking

Generate combinations of integer product whose adjacent numbers are not similar

Generate all unique partitions of a number

Generate all k digit number whose sum is to x

Generate all distinct combinations of N numbers whose sum is X

Generate combination of two equal length string which is belong to index

Generate all the products of a number in which each element is divisible by the previous element

Print all the sequences of length m that begin with n and the consecutive difference is less than k

Print the combinations of given vertices which connect of M edges they not contain cycle and its path cost is positive by node

Generate all passwords from given character set

Generate permutations with only adjacent swaps allowed

Generate all prime partition of a number

Split a number into prime numbers

Split a large Even number into small Even number

Split a large Odd number into small Odd number

Print all N digit jumping numbers

Print all n-digit numbers with sum of even and odd position digits whose absolute difference are one

Generate all possible permutations of words in a String

Generate all binary strings with 1 and 0 of size N

Print all distinct combinations of sum x and n natural number

Generate all n digit numbers whose consecutive even and odd digit

Generate all n digit numbers whose consecutive odd and even digit

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name