Ein schönes einfaches

Eingang

Bei einem booleschen Array (oder einer akzeptablen Alternative) können Sie davon ausgehen, dass das Array niemals länger als 32 Elemente ist.

[false, false, true, false, false]

Ausgabe

Invertieren Sie jedes Element des Arrays und geben Sie es aus.

[true, true, false, true, true]

Regeln

• Sie können ein vollständiges Programm oder nur eine Funktion schreiben
• Es gelten Standardlücken
• Kürzester Code in Bytes pro Sprache gewinnt!

Testfälle

Input:
[true, false]
Output:
[false, true]

Input: //Example of acceptable alternative
[0,1,1]
Output:
[1,0,0]

05AB1E , 1 Byte

Code:

_

Erläuterung:

_     # Logical not

Probieren Sie es online!

Gelee , 1 Byte

¬

Probieren Sie es online!

¬ist logisch NOT (1 wenn false-y, sonst 0). C("Komplement", 1 - z ) funktioniert auch.

Javascript ES6, 15 Bytes

a=>a.map(b=>!b)

Ich denke, es ist nicht viel Erklärung nötig

f=
a=>a.map(b=>!b)

a.innerHTML = `[true, false, 1, 0] => ${ f([true, false, 1, 0]) }`

<pre id=a>

Matlab, 4 1 Byte

Dies sollte selbsterklärend sein.

~

Matlab hat den Ein-Byte-Negationsoperator ~, wenn Sie eine Funktion benötigen, die Sie verwenden können @not.

Haskell, 7 Bytes

map not

Beispiel:

Prelude> (map not) [False, True, True]
[True,False,False]

MATL , 1 Byte

~

Probieren Sie es online!

~Ist das logisch nicht und so viele Funktionen, kann es auch auf Arrays / Matrizen angewendet werden.

C, 46 Bytes rekursive Version

f(char*s){*s?putchar(*s&72?*s:*s^1),f(++s):0;}

C, 47 Bytes iterative Version

f(char*s){for(;*s;putchar(*s&72?*s:*s^1),s++);}

Mit dieser Hauptfunktion ausführen

main(c,v)char**v;
{
    f(v[1]);
}

und Eingabe wie folgt

a.exe [1,0,1,1,0]
[0,1,0,0,1]

R, 1 Byte

!

Beispiel:

> !c(TRUE, FALSE)
[1] FALSE  TRUE

Es funktioniert auch mit numerischer Eingabe:

> !c(1, 0)
[1] FALSE  TRUE

Wir sind auch nicht auf eindimensionale Arrays beschränkt. Machen wir eine Matrix und füllen sie zufällig mit 0s und 1s:

> mat = matrix(rbinom(16, 1, .5), ncol=4)
> mat
     [,1] [,2] [,3] [,4]
[1,]    0    1    1    1
[2,]    0    1    0    0
[3,]    0    0    0    0
[4,]    1    1    1    0

Wir können dies genauso einfach umkehren:

> !mat
      [,1]  [,2]  [,3]  [,4]
[1,]  TRUE FALSE FALSE FALSE
[2,]  TRUE FALSE  TRUE  TRUE
[3,]  TRUE  TRUE  TRUE  TRUE
[4,] FALSE FALSE FALSE  TRUE

Wir können dies für eine beliebige Anzahl von Dimensionen fortsetzen. Hier ist ein Beispiel für ein vierdimensionales Array:

> bigarray = array(rbinom(32, 1, 0.5), dim=c(2,2,2,2))
> bigarray
, , 1, 1

     [,1] [,2]
[1,]    0    0
[2,]    0    0

, , 2, 1

     [,1] [,2]
[1,]    1    0
[2,]    0    0

, , 1, 2

     [,1] [,2]
[1,]    0    1
[2,]    0    1

, , 2, 2

     [,1] [,2]
[1,]    1    0
[2,]    1    1

> !bigarray
, , 1, 1

     [,1] [,2]
[1,] TRUE TRUE
[2,] TRUE TRUE

, , 2, 1

      [,1] [,2]
[1,] FALSE TRUE
[2,]  TRUE TRUE

, , 1, 2

     [,1]  [,2]
[1,] TRUE FALSE
[2,] TRUE FALSE

, , 2, 2

      [,1]  [,2]
[1,] FALSE  TRUE
[2,] FALSE FALSE

Funktioniert leider nicht für Charaktere.

> !"Hello world"
Error in !"Hello world" : Invalid argument type.

Perl 6 , 4 Bytes

"French" / Unicode-Version:

!«*

"Texas" / ASCII-Version:

!<<*

Die Eingabe ist ein einzelner Wert, der als Liste behandelt werden kann.

Dies ist ein beliebiges Lambda ( *) mit dem logischen Nicht-Präfix-Operator ( !), der mit dem Präfix-Hyper-Operator ( «) kombiniert wird .

Tatsächlich ist dies dasselbe wie:

-> $_ { $_.values.hyper.map: &prefix:<!> }
# ( currently the Rakudo implementation doesn't actually do the ｢.hyper｣ call,
#   but prefix ｢«｣ is specifically designated for doing things in parallel )

Verwendung:

# pretend it's a method
say (True,False,True,True).&( !«* );
# (False True False False)

say ( !«* )( (False,False,True,False,False) );
# (True True False True True)


# give it a lexical name
my &list-invert = !«*;

#              v¯¯ a space is necessary here
say list-invert (True,False);
# (False True)

say (False,True).&list-invert;
# (True False)

Labyrinth , 9 Bytes

,$:)%#$.,

Probieren Sie es online!Nimmt eine durch Zeilenvorschub getrennte Eingabe mit einem nachgestellten Zeilenvorschub an. Vielen Dank an @MartinEnder für die Hilfe beim Golfen.

Dieses Programm ist etwas seltsam für ein Labyrinth-Programm - es nutzt nicht die 2D-Natur der Sprache und springt tatsächlich vor und zurück. Auf der ersten Hinfahrt haben wir:

[Moving rightward]
,            Read char c of input
 $           XOR c with implicit 0 at bottom of stack
  :)%        Calculate c % (c+1), erroring out if c == -1 from EOF, otherwise returns c
     #$      XOR with (length of stack == 1)
       .     Output (c^1) as char
        ,    Read newline

[Moving leftward]
       .     Output newline
      $      XOR two implicit 0s, stack [0]
    %#       Mod with (length of stack == 1), giving stack [0]
 $:)         Increment, duplicate then XOR, stack still [0]
,            Read char c of input

Beim nächsten Auftreten von $XOR wird dann die vorhandene 0 auf dem Stapel mit c, im Gegensatz zu einer impliziten 0 am unteren Ende des Stapels wie im ersten Durchlauf. Beide Situationen verlassen den Stapel als [c], und das Programm wiederholt sich danach.

Alternative 9 Bytes:

,:):/$.:,
,::)/)$.,
,:):%)$.,

Mathematica, 7 Bytes

Not/@#&

oder ohne Buchstaben:

!#&/@#&

Was den syntaktischen Zucker betrifft: &Markiert das rechte Ende einer unbenannten Funktion und hat eine sehr niedrige Priorität. #verweist auf das erste Argument des nächsten und umschließenden &. !ist der Betreiber für Not. Es !#&ist also nur eine unbenannte Funktion, die ihr Argument negiert, mit anderen Worten, sie ist identisch mit der eingebauten Not. /@ist der Betreiber für Map. Der Code wäre also auch gleichbedeutend mit dem etwas besser lesbaren Map[Not, #]&.

Python, 27 25 24 Bytes

Vielen Dank an Lynn für das Abschlagen von zwei Bytes und an xnor und Mego für das Abschlagen von weiteren Bytes.

lambda a:[b^1for b in a]

C #, 19 Bytes

Nimmt als anonyme Funktion ein Bool [] und gibt eine IEnumerable zurück

b=>b.Select(x=>!x);

oder in 36 Bytes mit

dynamic f(bool[]b)=>b.Select(x=>!x);

IBM / Lotus Notes-Formel, 2 Byte

!a

Verwendung:

Erstellen Sie ein Notes-Formular mit zwei Feldern mit den Namen a und b.

a (Eingabe) = editierbar, Zahl, mehrwertig, kommagetrennt

b (Ausgabe) = berechnet, Zahl, mehrwertig, kommasepariert

Fügen Sie die obige Formel in b ein und geben Sie einen Standardwert von 0 ein.

Erstellen Sie ein neues Dokument mit dem Formular, geben Sie eine Binärliste in a ein und drücken Sie F9, um die Ausgabe zu aktualisieren.

Beispiele:

Funktioniert, da bei einer Liste als Eingabe die Notes-Formel auf jedes Element in der Liste die angegebene Aktion anwendet.

J, 2 Bytes

-.

Dies ist das Negationsverb.

Testfall

   -. 0 1 0 0 1
1 0 1 1 0

Swift 3 (7 Bytes)

.map(!)

z.B

[true, false].map(!)

Erläuterung

Scheint ziemlich offensichtlich. Ruft mapdas Array auf [true, false]. Das einzige "Problem" ist, dass Operatoren in Swift nur Funktionen sind und als Argumente weitergegeben werden können. Dieses Mittel map(!)ist das Bestehen der „nicht“ Funktion !in map.

Shakespeare-Programmiersprache , 240 Byte

.
Ajax,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Puck]
Puck:
Open your mind.Is hog as big as you?If so, let us return to scene II.You be sum of difference of zero and you and cat.Open thy heart!Let us return to scene I.
Scene II:.
[Exeunt]

Übernimmt die Eingabe als Zeichenfolge \0und als \1Steuerzeichen. Ausgabe als String von 0oder 1. Wenn die Eingabe mit der Ausgabe identisch sein muss, ersetzen Sie sie Open thy heartdurch, Speak thy mindum die Bytecount-Anzahl nicht zu ändern. Wenn \0und \1kann nicht verwendet werden, tun Sie das oben, aber ersetzen Sie auch Open your mindmitListen to thy heart für eine 5-Byte - Strafe.

Ungolfed:

The Invertion of Veronan Arrays.

Romeo, who stores the element.
Juliet, who lectures him.

Act I: In which an array is inverted.

Scene I: A silent entrance.

[Enter Romeo and Juliet]

Scene II: In which Juliet pours out her heart to Romeo.

Juliet:
  Open your mind. Is nothing better than thee? If so, let us proceed to scene III. 
  Thou art as good as the sum of the difference between nothing and thee and my 
  cat. Open your heart! Let us return to scene II.

Scene III: Finale.

[Exeunt]

Dies entspricht ungefähr dem folgenden C-Pseudocode:

int romeo;

Scene1:
romeo = getchar();
if (0 > romeo) goto Scene2;
romeo = 0 - romeo + 1;
printf("%d", romeo);
goto Scene1;

Scene2:;

Ich benutze diesen Interpreter . Probelauf:

$ python splc.py invert.spl > invert.c
$ gcc invert.c -o invert.exe
$ echo -ne "\x00\x01\x00" | ./invert
101

JAISBaL , 1 Byte

!

Wie alle anderen 1-Byte-Antworten ist dies der Negationsoperator, der bei Bedarf über ein Array operieren kann. Dadurch verbleibt die Ausgabe auf dem Stapel, der am Ende des Programms gedruckt wird.

Für zwei Bytes kann das Array explizit gedruckt werden:

!§

Die Eingabe erfolgt im unglaublich seltsamen Array-Format von JAISBaL (das ich erfunden habe, aber es gefällt mir nicht ...).

Testfälle (Ausgabe vom Java-Interpreter, 3.0.5):

Enter a value > [true][false]


--------------------
Stack: [[false, true]]
Locals: {}
----------------------------------------
Enter a value > [false][false][true][false][false]


--------------------
Stack: [[true, true, false, true, true]]
Locals: {}

PowerShell, 15 Byte

$args[0]|%{!$_}

Ich denke, dass dies sogar in v1 funktioniert, daher habe ich die Versionsnummer vom Titel entfernt. Durchläuft die Eingabe $argsund negiert nacheinander jeden Gegenstand. Das resultierende Array verbleibt in der Pipeline.

Das Schöne daran ist jedoch, dass PowerShell die Casting-Anforderungen so locker hat, dass Sie eine vollständig gemischte Eingabe vornehmen und eine geeignete boolesche Ausgabe erhalten können. Hier sind zum Beispiel die wörtlichen Booleschen Werte $false/ $true, die Zahlen 0 1und 123456789als Ganzzahlen eine leere Zeichenfolge, eine nicht leere Zeichenfolge, ein leeres Array und ein nicht leeres Array -

PS C:\Tools\Scripts\golfing> .\invert-a-boolean-array.ps1 @($false,$true,0,1,123456789,'','foo',@(),@(1,1))
True
False
True
False
False
True
False
True
False

Perl, 7 Bytes

Beinhaltet +2 für -lp

Geben Sie jedem Booleschen Wert in einer eigenen Zeile den Wert 0 oder 1

invert.pl
1
1
0
^D

invert.pl:

#!/us/bin/perl -lp
$_^=1

Brachylog , 7 Bytes

:{-$_}a

Probieren Sie es online!

Erläuterung

:{   }a   Apply this predicate to each element of the Input
  -         Decrement
   $_       Negate

Cheddar, 10 Bytes

@.map((!))

Ich hoffe, ich habe richtig gezählt, als ich vom Telefon aus schreibe

Java, 58 Bytes

void f(boolean[]a){for(boolean i:a)System.out.print(!i);}

Brainfuck (58 Bytes)

-[>+<-----]>--->,[<[->->+<<]>[--<]>[>]<[-<+<+>>]<+.[-]<>,]

Probieren Sie es hier aus

Ungolfed

-[>+<-----]>---     Number 48 (stands for 0)
>,                  Read in first point
[               
    <[->->+<<]      Subtract 1 from 48 flag, subtract 1 from read data, add 1 for new flag
    >           
    [--<]           If sitting on 1 (true) subtract 2 and move left)
        >[>]<       Move to 48 flag
        [-<+<+>>]   Add 48 to data point
        <+.[-]<     Add 1 move print, zero cell, move to new 48 cell
        >,          Read in next point
]                   Loop if input remaining

Nimmt eine Eingabe von ungeteilten Einsen oder Nullen (11001) an.

Logikcode , 9 8 Bytes

out!binp

Wirklich einfach.

Nimmt Eingaben als binäre Zeichenfolge an, da Logicode keine Unterstützung für Listen bietet ( [true, false]wäre es auch 10).

Das outgibt das Ergebnis der Zeile aus.

Der !Befehl berechnet das NICHT von jedem Bit in der Zeichenfolge, also !111wäre so etwas wie 000.

Das binpist ein Binäreingang.

Dank @daHugLenny 1 Byte gespart

CJam , 4 Bytes

{:!}

Die Eingabe ist eine Liste von 0s und 1s.

Probieren Sie es online!

Japt, 3 Bytes

¡!X

Japt hat keine boolesche Eingabe, daher besteht die Eingabe aus einem Array von 0s und 1s. Online testen!

Wie es funktioniert

¡    // Map each item X in the input to
 !X  //  the boolean NOT of X.
     // Implicit output

Netzhaut , 3 Bytes

%`0

Probieren Sie es online!

%Zählen Sie für jede Zeile ( ) die Anzahl von 0s.

Python 2, 24 Bytes (nicht konkurrierend)

lambda a:[i-1for i in a]

Die Logik ähnelt der von Steven, aber ich habe versucht, die Idee dieses Kommentars zu verwenden, aber anders, weil es immer noch 0/ 1arrays, nicht 0/ braucht -1. Für die Verwendung von 0/ gibt es keine Byte-Rasur -1. Seien wir also vernünftig. Beachten Sie, dass dies kein Wettbewerb ist, bis Steven oder Lynn mir erlauben, die Idee zu verwenden. In diesem Fall entferne ich möglicherweise das Wettbewerbsverbot. Beachten Sie, dass dieser Code nicht schamlos gestohlen werden kann, sondern immer noch hier ist. Nur Steven kann es für seine Antwort verwenden.

Ruby, 14 Bytes

Anonyme Funktion:

->a{a.map &:!}

Probier es aus:

->a{a.map &:!}.call([true, true, false, true, false, true, true])
# => [false, false, true, false, true, false, false]