Generate all 0 and 1 with 25% and 75% probability

Here given code implementation process.

// C Program
// Generate all 0 and 1 with 25% and 75% probability
#include <stdio.h>

void balancedBinary(char result[], int k, 
  					int zero, int one, int index)
{
	if (zero > k || one > k *3)
	{
		return;
	}
	if (index == k *4)
	{
		printf("%s\n", result);
		return;
	}
	result[index] = '0';
	balancedBinary(result, k, zero + 1, one, index + 1);
	result[index] = '1';
	balancedBinary(result, k, zero, one + 1, index + 1);
}
void findSolution(int n)
{
	if (n <= 0)
	{
		return;
	}
	if (n < 4)
	{
		// When only 1s
		for (int i = 0; i < n; ++i)
		{
			printf("  1");
		}
		return;
	}
	char result[n + 1];
	// set the value of last char is to terminating character
	result[n - 1] = '\0';
	balancedBinary(result, n / 4, 0, 0, 0);
}
int main()
{
	int n = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	findSolution(n);
	return 0;
}

Output

// Java program for
// Generate all 0 and 1 with 25% and 75% probability
public class Combination
{
	public void balancedBinary(String result, 
                                int k, int zero, 
                                int one, int index)
	{
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			System.out.println(result);
			return;
		}
		balancedBinary(result + "0", k, 
                       zero + 1, one, index + 1);
		balancedBinary(result + "1", k, 
                       zero, one + 1, index + 1);
	}
	public void findSolution(int n)
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			// When only 1s
			for (int i = 0; i < n; ++i)
			{
				System.out.print(" 1");
			}
			return;
		}
		balancedBinary("", n / 4, 0, 0, 0);
	}
	public static void main(String[] args)
	{
		Combination task = new Combination();
		int n = 8;
		// Example
		// n = 8
		// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
		// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
		task.findSolution(n);
	}
}

Output

// Include header file
#include <iostream>

using namespace std;
// C++ program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination
{
	public: void balancedBinary(string result, 
                                int k, int zero, 
                                int one, int index)
	{
		if (zero > k || one > k *3)
		{
			return;
		}
		if (index == k *4)
		{
			cout << result << endl;
			return;
		}
		this->balancedBinary(result  +  "0", 
                             k, zero + 1, one, index + 1);
		this->balancedBinary(result  +  "1", 
                             k, zero, one + 1, index + 1);
	}
	void findSolution(int n)
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			// When only 1s
			for (int i = 0; i < n; ++i)
			{
				cout << " 1";
			}
			return;
		}
		this->balancedBinary("", n / 4, 0, 0, 0);
	}
};
int main()
{
	Combination *task = new Combination();
	int n = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task->findSolution(n);
	return 0;
}

Output

// Include namespace system
using System;
// Csharp program for
// Generate all 0 and 1 with 25% and 75% probability
public class Combination
{
	public void balancedBinary(String result, 
                                int k, int zero, int one, int index)
	{
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			Console.WriteLine(result);
			return;
		}
		this.balancedBinary(result + "0", k, 
                            zero + 1, one, index + 1);
		this.balancedBinary(result + "1", k, 
                            zero, one + 1, index + 1);
	}
	public void findSolution(int n)
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			// When only 1s
			for (int i = 0; i < n; ++i)
			{
				Console.Write(" 1");
			}
			return;
		}
		this.balancedBinary("", n / 4, 0, 0, 0);
	}
	public static void Main(String[] args)
	{
		Combination task = new Combination();
		int n = 8;
		// Example
		// n = 8
		// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
		// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
		task.findSolution(n);
	}
}

Output

package main
import "fmt"
// Go program for
// Generate all 0 and 1 with 25% and 75% probability
type Combination struct {}
func getCombination() * Combination {
	var me *Combination = &Combination {}
	return me
}
func(this Combination) balancedBinary(result string, 
                                      k int, zero int, 
                                      one int, index int) {
	if zero > k || one > k * 3 {
		return
	}
	if index == k * 4 {
		fmt.Println(result)
		return
	}
	this.balancedBinary(result + "0", 
		k, zero + 1, one, index + 1)
	this.balancedBinary(result + "1", 
		k, zero, one + 1, index + 1)
}
func(this Combination) findSolution(n int) {
	if n <= 0 {
		return
	}
	if n < 4 {
		// When only 1s
		for i := 0 ; i < n ; i++ {
			fmt.Print(" 1")
		}
		return
	}
	this.balancedBinary("", n / 4, 0, 0, 0)
}
func main() {
	var task * Combination = getCombination()
	var n int = 8
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n)
}

Output

<?php
// Php program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination
{
	public	function balancedBinary($result, $k, 
                                     $zero, $one, 
                                     $index)
	{
		if ($zero > $k || $one > $k * 3)
		{
			return;
		}
		if ($index == $k * 4)
		{
			echo($result.
				"\n");
			return;
		}
		$this->balancedBinary($result.
			"0", $k, $zero + 1, $one, $index + 1);
		$this->balancedBinary($result.
			"1", $k, $zero, $one + 1, $index + 1);
	}
	public	function findSolution($n)
	{
		if ($n <= 0)
		{
			return;
		}
		if ($n < 4)
		{
			// When only 1s
			for ($i = 0; $i < $n; ++$i)
			{
				echo(" 1");
			}
			return;
		}
		$this->balancedBinary("", (int)($n / 4), 0, 0, 0);
	}
}

function main()
{
	$task = new Combination();
	$n = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	$task->findSolution($n);
}
main();

Output

// Node JS program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination
{
	balancedBinary(result, k, zero, one, index)
	{
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			console.log(result);
			return;
		}
		this.balancedBinary(result + "0", k, 
                            zero + 1, one, index + 1);
		this.balancedBinary(result + "1", k, 
                            zero, one + 1, index + 1);
	}
	findSolution(n)
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			// When only 1s
			for (var i = 0; i < n; ++i)
			{
				process.stdout.write(" 1");
			}
			return;
		}
		this.balancedBinary("", parseInt(n / 4), 0, 0, 0);
	}
}

function main()
{
	var task = new Combination();
	var n = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n);
}
main();

Output

#  Python 3 program for
#  Generate all 0 and 1 with 25% and 75% probability
class Combination :
	def balancedBinary(self, result, k, zero, one, index) :
		if (zero > k or one > k * 3) :
			return
		
		if (index == k * 4) :
			print(result)
			return
		
		self.balancedBinary(result + "0", k, 
                            zero + 1, one, index + 1)
		self.balancedBinary(result + "1", k, 
                            zero, one + 1, index + 1)
	
	def findSolution(self, n) :
		if (n <= 0) :
			return
		
		if (n < 4) :
			i = 0
			#  When only 1s
			while (i < n) :
				print(" 1", end = "")
				i += 1
			
			return
		
		self.balancedBinary("", int(n / 4), 0, 0, 0)
	

def main() :
	task = Combination()
	n = 8
	#  Example
	#  n = 8
	#  k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	#  k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n)

if __name__ == "__main__": main()

Output

#  Ruby program for
#  Generate all 0 and 1 with 25% and 75% probability
class Combination 
	def balancedBinary(result, k, zero, one, index) 
		if (zero > k || one > k * 3) 
			return
		end

		if (index == k * 4) 
			print(result, "\n")
			return
		end

		self.balancedBinary(result + "0", k, 
                            zero + 1, one, index + 1)
		self.balancedBinary(result + "1", k, 
                            zero, one + 1, index + 1)
	end

	def findSolution(n) 
		if (n <= 0) 
			return
		end

		if (n < 4) 
			i = 0
			#  When only 1s
			while (i < n) 
				print(" 1")
				i += 1
			end

			return
		end

		self.balancedBinary("", n / 4, 0, 0, 0)
	end

end

def main() 
	task = Combination.new()
	n = 8
	#  Example
	#  n = 8
	#  k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	#  k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n)
end

main()

Output

// Scala program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination()
{
	def balancedBinary(result: String, k: Int, 
                       zero: Int, one: Int, index: Int): Unit = {
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			println(result);
			return;
		}
		balancedBinary(result + "0", k, 
                       zero + 1, one, index + 1);
		balancedBinary(result + "1", k, 
                       zero, one + 1, index + 1);
	}
	def findSolution(n: Int): Unit = {
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			var i: Int = 0;
			// When only 1s
			while (i < n)
			{
				print(" 1");
				i += 1;
			}
			return;
		}
		balancedBinary("", n / 4, 0, 0, 0);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Combination = new Combination();
		var n: Int = 8;
		// Example
		// n = 8
		// k = n / 4   [8/4 = 2 (two 0s)] (25 % 0s)
		// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
		task.findSolution(n);
	}
}

Output

// Swift 4 program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination
{
	func balancedBinary(_ result: String, _ k: Int, 
                         _ zero: Int, _ one: Int, _ index: Int)
	{
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			print(result);
			return;
		}
		self.balancedBinary(result + "0", k, 
                            zero + 1, one, index + 1);
		self.balancedBinary(result + "1", k, 
                            zero, one + 1, index + 1);
	}
	func findSolution(_ n: Int)
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			var i: Int = 0;
			// When only 1s
			while (i < n)
			{
				print(" 1", terminator: "");
				i += 1;
			}
			return;
		}
		self.balancedBinary("", n / 4, 0, 0, 0);
	}
}
func main()
{
	let task: Combination = Combination();
	let n: Int = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n);
}
main();

Output

// Kotlin program for
// Generate all 0 and 1 with 25% and 75% probability
class Combination
{
	fun balancedBinary(result: String, k: Int, zero: Int, 
                        one: Int, index: Int): Unit
	{
		if (zero > k || one > k * 3)
		{
			return;
		}
		if (index == k * 4)
		{
			println(result);
			return;
		}
		this.balancedBinary(result + "0", k, zero + 1, one, index + 1);
		this.balancedBinary(result + "1", k, zero, one + 1, index + 1);
	}
	fun findSolution(n: Int): Unit
	{
		if (n <= 0)
		{
			return;
		}
		if (n < 4)
		{
			var i: Int = 0;
			// When only 1s
			while (i < n)
			{
				print(" 1");
				i += 1;
			}
			return;
		}
		this.balancedBinary("", n / 4, 0, 0, 0);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Combination = Combination();
	val n: Int = 8;
	// Example
	// n = 8
	// k = n / 4    [8/4 = 2 (two 0s)] (25 % 0s)
	// k *3        [2*3 = 6 (six 1s)] (75 % 1s)
	task.findSolution(n);
}

Output

Generate all 0 and 1 with 25% and 75% probability

Output

Output

Output

Output

Output

Output

Output

Output

Output

Output

Output

Output

Comment

New Comment