[RUBY] umschreiben, es sei denn

Ursprung

Es gibt einen ↓ Code im Code anderer, die gerade zuschauen.

tgt

unless hash.has_key?("1") || hash.has_key?("2") || hash.has_key?("3") || arr1.size == 0 || arr2.size == 0
  ....
end

Eigentlich ist es mit Ablehnung vermischt. Es ist mitten in einer riesigen Menge an Code, um einen Test auszuführen. Es gibt viele andere "es sei denn" -Anweisungen mit mehreren Bedingungen ... Ich kann mir das Verhalten mit meinem verrückten Gehirn-Miso nicht vorstellen. Es tut mir Leid.

Selbst wenn Sie Gugu ausprobieren, wird die Erklärung von de Morgan bestenfalls unter zwei Bedingungen erklärt.

Es gibt keine Hilfe dafür. Erstellen Sie daher ein Vorlagenskript zur Bestätigung.

Konzept

Erstens unter zwei Bedingungen. Rufen Sie den Wert 0, 1 anstelle des bedingten Ausdrucks auf.

2.pl

my @d = ( [0,0],[1,0],[0,1],[1,1] ) ;
for my $r ( @d ){
    print join "", @{$r} unless $r->[0] || $r->[1] ;
}

$ perl -l 2.pl
00

unless A || BDie Bedingung ist, dass der erste bedingte Ausdruck falsch ist(0)Der zweite bedingte Ausdruck ist ebenfalls falsch(0)Ich weiß das. Mit anderen Wortenif ! A and ! B

Hauptthema

Was ist also mit tgt?

Da es höchstens 5 Stück gibt, wird die Schnur geschoben

python

$ ruby -e 'p [0,1].product([0,1],[0,1],[0,1],[0,1])'
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 1], [0, 0, 1, 0, 0], [0, 0, 1, 0, 1], [0, 1, 0, 0, 0], [0, 1, 0, 0, 1],
 [0, 1, 1, 0, 0], [0, 1, 1, 0, 1], [1, 0, 0, 0, 0], [1, 0, 0, 0, 1], [1, 0, 1, 0, 0], [1, 0, 1, 0, 1], 
[1, 1, 0, 0, 0], [1, 1, 0, 0, 1], [1, 1, 1, 0, 0], [1, 1, 1, 0, 1]]

Betten Sie dies in den Quellcode ein

5.pl

#!/usr/bin/env perl
my @d = (
    [0, 0, 0, 0, 0], [0, 0, 0, 0, 1],
    [0, 0, 0, 1, 0], [0, 0, 0, 1, 1],
    [0, 0, 1, 0, 0], [0, 0, 1, 0, 1],
    [0, 0, 1, 1, 0], [0, 0, 1, 1, 1],
    [0, 1, 0, 0, 0], [0, 1, 0, 0, 1],
    [0, 1, 0, 1, 0], [0, 1, 0, 1, 1],
    [0, 1, 1, 0, 0], [0, 1, 1, 0, 1],
    [0, 1, 1, 1, 0], [0, 1, 1, 1, 1],
    [1, 0, 0, 0, 0], [1, 0, 0, 0, 1],
    [1, 0, 0, 1, 0], [1, 0, 0, 1, 1],
    [1, 0, 1, 0, 0], [1, 0, 1, 0, 1],
    [1, 0, 1, 1, 0], [1, 0, 1, 1, 1],
    [1, 1, 0, 0, 0], [1, 1, 0, 0, 1],
    [1, 1, 0, 1, 0], [1, 1, 0, 1, 1],
    [1, 1, 1, 0, 0], [1, 1, 1, 0, 1],
    [1, 1, 1, 1, 0], [1, 1, 1, 1, 1]
) ;

for my $r ( @d ){
    print join "", @{$r} unless $r->[0] || $r->[1] || $r->[2] || $r->[3] || $r->[4] ;
}

Lauf.

python

$ perl -l 5.pl
00000

Verbesserung

Zusätzlich wird die "@ d" -Generation durch "Perl" beschrieben, so dass die Nummer geändert werden kann [^ 1].

[^ 1]: Ich wünschte, "Perl" hätte auch "Produkt". "CPAN"? Abgelehnt wegen des störenden Geruchs.

perl:5.2.pl

#!/usr/bin/env perl
sub comb{
	my $in = shift ;
	#Kombination von Binärzahlen von 0-Nach der Konvertierung von Dezimalzahlen bis zu 1 in Binärzahlen, die mit 0x gefüllt sind,
	#Teilen Sie jeweils ein Zeichen. Als Array-Referenz verwenden. Und der Rückgabewert ist Array of Arrays
	map{ [ unpack '(A)*', sprintf "%0${in}b", $_ ] } 0 .. 2 ** $in - 1 ;
}

my @d = comb $ARGV[0] ;
for my $r ( @d ){
    # $ARGV[0] -Auch einmal||Es ist mühsam zu schreiben
    # ||Die mit verkettete Zeichenfolge ist eval und wird als Argument für "Es sei denn" verwendet.
    #Wechseln Sie tatsächlich zu dem Code, der dem Überprüfungsziel entspricht
    print join "", @{$r} unless eval join '||', map{ $r->[$_] } 0 .. $ARGV[0] - 1 ;
}

$ perl -l 5.2.pl 12
000000000000

später,||Zu&&Oder!Oder antworten Sie sofort gemäß der bedingten Anweisung, die Sie testen möchten.

Oh, das ist weniger stressig und Sie können "es sei denn" in "wenn" ändern.

Serpentin

Wenn Sie keine Binärzahlen verwenden.

python

sub comb {
    my $in = shift ;
    # ([0,0,0..])Erstellen Sie ein Array
    my @d = ( [(0)x$in] ) ;
    #Hash für Cache
    my %seen ;
    # @Ich lecke d,@Weil d in die Schleife gedrückt wird und an Zahl zunimmt
    #Separate Bedingungen für das Verlassen
    for my $r ( @d ){
        # $r = [ x,x,x,x,x ... ]Ändern Sie die Elemente von auf 1 in der Reihenfolge,
        #Wenn es eine unbekannte Kombination ist@Hinzufügen zu d
        push @d, grep{ ! $seen{ join "", @{$_} } ++ }
                 map { my @k = @{$r} ;  $k[$_] = 1 ; [@k] }
                 0 .. $in - 1  ;
        # [Alle 1]Ist die letzte Kombination
        last if +(join '', @{$d[-1]}) eq '1' x $in ;
    }
    return @d ;
}

Dies ist ein Tabu-Code [^ 2]. In diesem Fall ist es schwierig, es zweistellig zu machen.

[^ 2]: Ich habe das zuerst geschrieben und dann kam mir die Idee, dass ich es binär schreiben sollte. Es ist lange her, also werde ich es verlassen.