Java: Generator kombinacji true's i false za pomocą liczby N;

Question

Związałem, aby uprościć zadanie tak bardzo, jak to możliwe, więc mogłem zastosować je do mojego algorytmu.

A oto wyzwanie dla matematyków i programistów:

muszę utworzyć metodę gdzie mogę przekazać parametr int N:

public void optionality_generator(int n){ 
    //some kind of loops, or recursions...to make it workable 
    System.out.println("current combination: ..."); 
} 

Wyjście powinno pokazać wszystkie możliwe kombinacje prawdziwych tych i fałszywych tych.

Oto przykłady gdzie N = 1; N = 2; N = 3; N = 4; N = 5 gdzie x = fałsz i 0 = prawda; Pamiętaj, że puste linie przerwania są po to, abyś mógł łatwiej rozpoznać wzorce. Mamy nadzieję, że zawarte wszystkie możliwe kombinacje):

Combination of 1: 
0 
x 

Combination of 2: 
00 
x0 
0x 
xx 

Combination of 3: 
000 
X00 
0X0 
00X 
XX0 
0XX 
XXX 

Combination of 4: 
0000 

X000 
0X00 
00X0 
000X 

XX00 
X0X0 
X00X 

0XX0 
0X0X 

00XX 

XXX0 
XX0X 
X0XX 
0XXX 

XXXX 

Combination of 5: 
00000 
X0000 
0X000 
00X00 
000X0 
0000X 

XX000 
X0X00 
X00X0 
X000X 

X0X00 
X00X0 
X000X 

0XX00 
0X0X0 
0X00X 

00XX0 
00X0X 

000XX 

XXX00 
XX0X0 
XX00X 

X0XX0 
X0X0X 
X00XX 

0XXX0 
0XX0X 

00XXX 

XXXX0 
XXX0X 
XX0XX 
X0XXX 
0XXXX 

XXXXX 

Również Jeśli widzisz wyjścia, oto wzór Poznałem, że wszystkie kombinacje są odwrócone o połowę (np pierwsza kombinacja jest 00000 ostatnia będzie XXXXX, drugi X0000, jeden przed ostatnim będzie 0XXXX itd ..). Być może ten wzór pomoże uczynić cały algorytm bardziej wydajnym, nie jestem tego pewien. Z góry dziękuję!

Answer 1

Tutaj jest naprawdę podstawowy sposób używając tylko API Javy:

final int n = 3; 
for (int i = 0; i < Math.pow(2, n); i++) { 
    String bin = Integer.toBinaryString(i); 
    while (bin.length() < n) 
     bin = "0" + bin; 
    System.out.println(bin); 
} 

Wynik:

000 
001 
010 
011 
100 
101 
110 
111 

Oczywiście, można ustawić n aby cokolwiek chcesz. I, z tym wynikiem, możesz wybrać znak z n th z ciągu jako true/false.

Jeśli musisz tylko sprawdzić, czy bit jest prawdziwy, nie musisz konwertować go na ciąg znaków. Ma to jedynie zilustrować wartości wyjściowe.

Answer 2

To tylko wskazówka, ale pomyśl o bitach, które są ustawione dla liczby z co najwyżej "n" bitami. Zobaczysz, czy zmienisz liczbę od 0 do "n" (w tym przypadku 3); bity to: 000, 001, 010, 011, 100, 101, 110, 111. Można obliczyć maksymalną liczbę pasującą do bitów 'n' za pomocą formuły ((n * n) -1).

Answer 3

Oto prosty wersja realizowane z wykorzystaniem rekurencji

public void optionality_generator(int n){ 
    ArrayList<String> strings = generatorHelper(n); 
    for(String s : strings){ 
     System.out.println(s); 
    } 
} 

private ArrayList<String> generatorHelper(int n){ 
    if(n == 1){ 
     ArrayList<String> returnVal = new ArrayList<String>(); 
     returnVal.add("0"); 
     returnVal.add("X"); 
     return returnVal; 
    } 
    ArrayList<String> trueStrings = generatorHelper(n-1); 
    for(String s : trueStrings){ 
     s += "0"; 
    } 
    ArrayList<String> falseStrings = generatorHelper(n-1); 
    for(String s : falseStrings){ 
     s += "X"; 
    } 
    trueStrings.addAll(falseStrings); 
    return trueStrings; 
} 

Answer 4

To powinno załatwić sprawę

int cols = 3; 
int rows = (int) Math.pow(2, cols); 
for (int row = 0; row < rows; row++) 
    System.out.println(String.format("%" + cols + "s", 
      Integer.toBinaryString(row)).replace(' ', '0').replace('1', 'X')); 

się:

000 
00X 
0X0 
0XX 
X00 
X0X 
XX0 
XXX 

Answer 5

Oto test-driven wersja:

import static org.junit.Assert.assertEquals; 

import java.util.ArrayList; 
import java.util.List; 

import org.junit.Test; 

public class OptionalityTest { 

    @Test 
    public void testOptionality0() throws Exception { 
     assertEquals("[]", optionality(0).toString()); 
    } 

    @Test 
    public void testOptionality1() throws Exception { 
     assertEquals("[0, x]", optionality(1).toString()); 
    } 

    @Test 
    public void testOptionality2() throws Exception { 
     assertEquals("[00, x0, 0x, xx]", optionality(2).toString()); 
    } 

    @Test 
    public void testOptionality3() throws Exception { 
     assertEquals("[000, x00, 0x0, xx0, 00x, x0x, 0xx, xxx]", optionality(3).toString()); 
    } 

    private List<String> optionality(int i) { 
     final ArrayList<String> list = new ArrayList<String>(); 
     if (i == 1) { 
      list.add("0"); 
      list.add("x"); 
     } 
     if (i > 1) { 
      List<String> sublist = optionality(i - 1); 
      for (String s : sublist) { 
       list.add("0" + s); 
       list.add("x" + s); 
      } 
     } 
     return list; 
    } 

} 

Answer 6

Oto modyfikacja powyższego kodu Erics, który używa C# i pozwala wprowadzić dowolną liczbę nazw zmiennych logicznych. Wypisze wszystkie możliwe kombinacje w kodzie C# gotowe do wstawienia do instrukcji if. Po prostu edytuj pierwszą linię kodu z nazwami var, a następnie uruchom w LINQpad, aby uzyskać wynik tekstowy.

Przykładowe wyjście ...

!VariableNameA && !VariableNameB && !VariableNameC 
!VariableNameA && !VariableNameB && VariableNameC 
!VariableNameA && VariableNameB && !VariableNameC 
!VariableNameA && VariableNameB && VariableNameC 
VariableNameA && !VariableNameB && !VariableNameC 
VariableNameA && !VariableNameB && VariableNameC 
VariableNameA && VariableNameB && !VariableNameC 
VariableNameA && VariableNameB && VariableNameC 

//To setup edit var names below 
 
    string[] varNames = { "VariableNameA", "VariableNameB", "VariableNameC" }; 
 

 
    int n = varNames.Count();   
 
    for (int i = 0; i < Math.Pow(2, n); i++) { 
 
     String bin = Convert.ToString(i, 2); 
 
     while (bin.Length < n) { 
 
      bin = "0" + bin; 
 
     }   
 
     string and = " && "; 
 
     string f = "!"; 
 
     string t = " "; 
 
     var currentNot = bin[0] == '0' ? f : t; 
 
     //string visual = bin[0].ToString(); 
 
     string visual = currentNot + varNames[0]; 
 
     for (var j = 1; j < n; j++) { 
 
     currentNot = bin[j] == '0' ? f : t; 
 
     //visual = visual + and + bin[j].ToString(); 
 
     visual = visual + and + currentNot + varNames[j]; 
 
     } \t \t 
 
     Console.WriteLine(visual); \t 
 
    }