[JAVA] Kann ich alle Kombinationen mit einer App mit 20 Kontrollkästchen ausprobieren?

In den Einstellungen der App gibt es ein Kontrollkästchen oder eine Umschalttaste, die nur den EIN / AUS-Wert enthält. Angenommen, es gibt 20.

Es sieht so aus (obwohl es im Beispiel nur drei gibt).

Kontrollkästchen

Binäre Umschalttaste wie EIN / AUS

Betrachten Sie die Kombination.

Wenn es sich um ein allgemeines Kontrollkästchen handelt Jedes Kontrollkästchen ist Da es nur zwei Zustände hat, "markiert" und "nicht markiert", Wenn n Kontrollkästchen vorhanden sind, beträgt die Gesamtzahl der Kombinationen Es ist 2 nach der n-ten Potenz ($ 2 ^ n $).

Wenn es 20 gibt, ist es 2 nach der 20. Potenz ($ 2 ^ {20} $), also Es gibt mehr als eine Million Kombinationen mit 1.048.576 Kombinationen.

Ohne viel Mut scheint es unmöglich, alle Kombinationen manuell auszuprobieren. Derzeit scheint Amazon mehr als 500.000 Mitarbeiter zu haben Ich denke, es wäre schön, wenn alle zusammenarbeiten könnten, In Anbetracht der Schwierigkeiten bei der Verwaltung wird es fast unmöglich sein. (Soziale Tests sind eine gute Möglichkeit, Sie so zu führen, dass alles abgedeckt ist. Es ist möglicherweise nicht unmöglich, wenn Sie eine beträchtliche Anzahl von Benutzern sichern können. )

Betrachten Sie die Kombination aus einer anderen Perspektive.

Einfach weil es n "" markiert "und" nicht markiert "gibt Sie können es sich als 2 nach der n-ten Potenz vorstellen, Sie können es anders sehen.

Wenn es n Kontrollkästchen gibt,

0 von n werden geprüft
1 von n wird geprüft
2 von n werden geprüft
...
n-1 von n werden geprüft
n von n werden geprüft

Es fühlt sich an wie. Wenn Sie alle addieren, sollten Sie die gleiche Anzahl von Kombinationen erhalten.

(Anzahl der Kombinationen, bei denen 0 von n geprüft werden) +
(Anzahl der Kombinationen, bei denen 1 von n aktiviert ist) +
(Anzahl der Kombinationen, bei denen 2 von n geprüft werden) +
... +
(n von n-Anzahl der Kombinationen, bei denen eine aktiviert ist) +
(Anzahl der Kombinationen, bei denen n von n geprüft werden)

Berechnen wir.

Die Kombination von n bis k Auswahlen kann durch die folgenden Symbole dargestellt werden.

\dbinom{n}{k}

Im Sinne einer Kombination Je nach Person ist Folgendes möglicherweise vertrauter.

{}_n C_k

Daher muss aus n, 0, 1, 2, 3, ..., n für jede Kombination addiert werden. Ich fühle mich so.

\dbinom{n}{0} + \dbinom{n}{1} + \dbinom{n}{2} + \cdots + \dbinom{n}{n - 1} + \dbinom{n}{n} = \sum_{k=0}^{n}\dbinom{n}{k}

Je nach Betrachter kommt es Ihnen möglicherweise sofort bekannt vor. Es sieht aus wie ein Muster, das im Binärsatz enthalten ist.

(x + y)^{n} = \sum_{k=0}^{n}\dbinom{n}{k}x^{k}y^{n-k}

Das Ersetzen von $ x = 1, y = 1 $ ist genau das, was Sie wollen.

(1 + 1)^{n} = \sum_{k=0}^{n}\dbinom{n}{k}1^{k}1^{n-k}\\
2^{n} = \sum_{k=0}^{n}\dbinom{n}{k}

Am Ende stellt sich heraus, dass es dasselbe ist wie 2 nach der n-ten Potenz ($ 2 ^ n $).

Versuchen Sie, alle Kombinationen aufzuschreiben.

Wenn es zwei Zustände gibt, "aktiviert" und "deaktiviert", Wenn Sie sich jedes Bit der Binärzahl als Flag vorstellen und dafür sorgen, dass es 0 oder 1 ist, wird es nicht überprüft usw. Es scheint leicht zu schreiben.

Es ist nicht praktisch, sehr große Kombinationen manuell auszuprobieren. Es kann möglich sein, die Kombination abzudecken, indem sie in einen automatisierten Komponententest oder dergleichen einbezogen wird. (Es wird angenommen, dass es sich um eine sinnvolle Kombination handelt. Wenn es sich um ein Kontrollkästchen handelt, das sich nicht gegenseitig beeinflusst, muss geprüft werden, ob Tests erforderlich sind. )

Es gibt 20 Kontrollkästchen bis A, B, C, ..., R, S, T, Wenn Sie beispielsweise alle Kombinationen der aktivierten Zustände auflisten, sieht dies wie folgt aus. Es ist ziemlich harter Code, also nicht cool, Konzentrieren Sie sich beim Schreiben eines Artikels auf Klarheit Ich wage es, einen harten Code und eine dumme Implementierung zu machen.

Es sieht so aus, wenn es in C # geschrieben ist.

var buttons = "ABCDEFGHIJKLMNOPQRST".ToCharArray();

var combination = new StringBuilder(20);

//Drehen Sie einfach den ganzzahligen Wert mit für, um zu sehen, ob jedes Bit gesetzt ist
for(int flags = 0; flags < 1048576; flags++)
{
    for(int bit = 0; bit < 20; bit++)
    {
        //Wenn jedes Bit gesetzt ist, gilt es als geprüft
        if( (flags & (0x01 << bit)) != 0)
        {
            combination.Append(buttons[bit]);
        }
    }

    Console.WriteLine(combination.ToString());
    combination.Clear();
}

Ich denke nicht, dass es notwendig ist, in Java zu schreiben, aber Sie können fast das gleiche in Java tun.

char[] buttons = "ABCDEFGHIJKLMNOPQRST".toCharArray();

StringBuilder combination = new StringBuilder(20);

//Drehen Sie einfach den ganzzahligen Wert mit für, um zu sehen, ob jedes Bit gesetzt ist
for(int flags = 0; flags < 1048576; flags++)
{
    for(int bit = 0; bit < 20; bit++)
    {
        //Wenn jedes Bit gesetzt ist, gilt es als geprüft
        if( (flags & (0x01 << bit)) != 0)
        {
            combination.append(buttons[bit]);
        }
    }

    System.out.println(combination.toString());
    combination.setLength(0);
}

(Bonus) Anzahl der Kombinationen zur Auswahl von n bis k

Wenn Sie k aus n auswählen und in der richtigen Reihenfolge anordnen, $n \times (n - 1) \times (n - 2) \times \cdots \times (n - k + 1)$ Es sollte so aussehen.

Wenn Sie beispielsweise 5 bis 3 auswählen und diese in der richtigen Reihenfolge anordnen, Zunächst gibt es 5 Möglichkeiten zur Auswahl, die verbleibenden 4 Möglichkeiten zur Auswahl und dann die verbleibenden 3 Möglichkeiten zur Auswahl. $ 5 \ times 4 \ times 3 = 60 $ Es scheint eine Möglichkeit zu geben, sie auszuwählen und anzuordnen.

Sie müssen sie nicht auswählen und bestellen, sondern nur die Gesamtzahl der Auswahlmöglichkeiten Von dem oben Gesagten reicht es aus, den Teil unter Berücksichtigung der Anordnung auszuschließen, also Es scheint gut, durch $ k! $ (Die Potenz von k) zu teilen.

In Bezug auf die Anzahl der Kombinationen, um k aus n auszuwählen, $\frac{n \times (n - 1) \times (n - 2) \times \cdots \times (n - k + 1)}{k!}$ Es scheint so als.

Bei dieser Rate erscheint "$ \ cdots $" und es ist nicht cool, also Ich werde versuchen, es nur durch Bodenbeläge auszudrücken.

Kam oben heraus, Schauen Sie sich $ n \ times (n - 1) \ times (n - 2) \ times \ cdots \ times (n - k + 1) $ und $ n! $ Genauer an, um den Unterschied zu erkennen. n \times (n - 1) \times (n - 2) \times \cdots \times (n - k + 1) \times (n - k) \times (n - k - 1) \times (n - k - 2) \times \cdots \times 2 \times 1 Ist $ n! $.

das ist, $n \times (n - 1) \times (n - 2) \times \cdots \times (n - k + 1) \times (n - k)!$ Es scheint so als.

Das bedeutet $ n \ times (n - 1) \ times (n - 2) \ times \ cdots \ times (n - k + 1) $ is $\frac{n!}{(n - k)!}$ Es scheint, dass es ausgedrückt werden kann als.

damit, Wenn die Anzahl der Kombinationen zur Auswahl von k aus n nur durch den Boden ausgedrückt wird, $\frac{n!}{k!(n - k)!}$ Es wird sein.

Deshalb,

\dbinom{n}{k} = \frac{n!}{k!(n - k)!}\\
{}_n C_k = \frac{n!}{k!(n - k)!}

Es fühlt sich an wie.