Java: Generator wahrer s & false, s-Kombinationen, indem Sie die Anzahl N;

Band ich um die Aufgabe zu vereinfachen, so viel wie möglich, damit ich es anwenden konnte, um meinen Algorithmus.

Und hier ist die Herausforderung für Mathematiker und Programmierer:

Brauche ich, um eine Methode zu erstellen, wo ich den pass-parameter int n:

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

Sollte die Ausgabe zeigt alle möglichen Kombinationen von wahr und falsch ist.

Hier Beispiele, in denen N=1; N=2; N=3; N=4; N=5 wobei x=false und 0=true; beachten Sie Bitte, leeren break lines ist einfach für Sie zu erkennen einfacher Muster. Hoffentlich, habe ich alle möglichen Kombinationen):

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

Auch, Wenn Sie sehen, der Ausgang, hier ist das Muster, das ich erkannt, dass alle Kombinationen sind invertiert auf die Hälfte (e.g erste Kombination ist 00000 Letzte XXXXX, zweite X0000, bevor der Letzte 0XXXX etc..). Vielleicht ist dieses Muster wird Ihnen helfen, damit der ganze Algorithmus effizienter, nicht sicher über diese.
Vielen Dank im Voraus!

Das ist, warum jeder lernen sollte, Montage zuerst! Oder zumindest etwas Mathematik und Zweierkomplement.

InformationsquelleAutor vvinjj | 2012-06-06

5

Hier ist eine wirklich einfache Weise nur unter Verwendung von Java-APIs:
```
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);
}
```
Ergebnis:
```
000
001
010
011
100
101
110
111
```
Natürlich, Sie können n zu was auch immer Sie mögen. Und, mit diesem Ergebnis, können Sie wählen Sie die nTEN Zeichen aus dem string als true/false.

Wenn Sie nur brauchen, um zu überprüfen, ob etwas wahr ist, brauchen Sie nicht, um es in einen string konvertieren. Dies ist nur zur Veranschaulichung des Ausgabe-Werte.
- Ihr code schlägt fehl, wenn int n = 5, weil 2^5 = 32 ist größer als n*n, vielleicht benutzen die Mathematik.pow(2,n); anstelle?
- Ich habe aktualisiert mein code... mein Gehirn hatte verwirrt n^2 2^n! Danke!!!
- Jetzt funktioniert es, danke!
InformationsquelleAutor Eric
2

Nur eine Ahnung, aber denke über die bits, die gesetzt sind für eine Zahl mit höchstens " n " - bits. Sie werden sehen, wenn Sie gehen von 0 bis 'n' Anzahl von bits (3 in diesem Fall); die bits sind 000, 001, 010, 011, 100, 101, 110, 111. Sie können herausfinden, die maximale Anzahl, die passen in 'n' bits, indem die ((n*n)-1) Formel.

InformationsquelleAutor Justin

Dies sollte den trick tun

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'));

out:

000
00X
0X0
0XX
X00
X0X
XX0
XXX

java hat einen Math.pow-Funktion....
Funktioniert perfekt, danke!
es ist ein wenig schade, dass String.format nicht unterstützen %0s - format, während C/C++ unterstützen.

InformationsquelleAutor Pshemo

Verwendung von Rekursion ist nicht so einfach, wie mit dem Java-Integer.toBinaryString () - API für die Erzeugung von Binär-strings. Aber der folgende code gibt Ihnen die Flexibilität, die zur Erstellung eines Basis-Darstellung, z.B. Basis 3:
"000"
"001"
"002"
"010"
"011"
"012"

Zur Basis 2 (D. H. binäre) Zeichenketten, rufen Sie es wie folgt:

getBinaryStrings(2, 3);

Basis für 3 Streicher, rufen Sie es wie folgt:

getBinaryStrings(3, 3);

Hier ist der code:

public static List<String> getBinaryStrings(int base, int n){
    ArrayList<String> result = new ArrayList<>();
    getBinaryStringsCore(base, n, "", result);
    return result;
}

private static void getBinaryStringsCore(int base, int n, String tempString, List<String> result){
    if (tempString.length() == n) {
        result.add(tempString);
        return;
    }

    for (int i = 0; i < base; i++) {
        tempString += i;
        getBinaryStringsCore(base, n, tempString, result);
        tempString = tempString.substring(0, tempString.length() - 1);
    }
}

Der code für die base 2 und base 3 strings sind identisch (d.h. getBinaryStrings(2, 3);). Ist das beabsichtigt?
Danke @entpnerd. Ich hatte einen Tippfehler in meiner Beschreibung der Nutzung. Es ist jetzt korrigiert.

InformationsquelleAutor David Long

Hier ist eine einfache version, implementiert unter Verwendung von Rekursion

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;
}

Hinweis für die anderen: vielleicht klappt es, aber das Ausgabeformat ist anders, wo alles in eine einzige Spalte, so ist es unmöglich zu unterscheiden, wo jede Kombination beginnt und wo es endet. Trotzdem, vielen Dank!

InformationsquelleAutor Hans Z

Hier ist eine test-driven version:

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;
    }

}

Interessanter Ansatz, danke!

InformationsquelleAutor Carl Manaster

Hier ist eine Modifikation von Erics code oben, dass c# verwendet wird und ermöglicht die Eingabe einer beliebigen Anzahl von boolean-Variablen-Namen. Es wird die Ausgabe alle möglichen Kombinationen im c# - code, bereit für das einfügen in eine if-Anweisung. Ändern Sie einfach die 1. Zeile der code mit den var-Namen, und führen Sie dann im LINQpad um eine text-Ausgabe.

Ausgabe Beispiel...

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

JS:

    //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];
      }		
      Console.WriteLine(visual);	
    }

InformationsquelleAutor kamgman

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.