Una bella semplice

Ingresso

Dato un array booleano (o un'alternativa accettabile), puoi supporre che l'array non sarà mai più lungo di 32 elementi.

[false, false, true, false, false]

Produzione

Invertire ogni elemento dell'array e inviarlo in output.

[true, true, false, true, true]

Regole

• Puoi scrivere un programma completo o solo una funzione
• Si applicano scappatoie standard
• Il codice più corto in byte, per lingua, vince!

Casi test

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

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

05AB1E , 1 byte

Codice:

_

Spiegazione:

_     # Logical not

Provalo online!

Gelatina , 1 byte

¬

Provalo online!

¬è logico NOT (1 se false-y, altrimenti 0). C("Complemento", 1 − z ) funziona anche.

Javascript ES6, 15 byte

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

Non ho bisogno di molte spiegazioni

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

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

<pre id=a>

Matlab, 4 1 byte

Questo dovrebbe essere autoesplicativo.

~

Matlab ha l'operatore di negazione a un byte ~, se vuoi una funzione puoi usare @not.

Haskell, 7 byte

map not

Esempio:

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

MATL , 1 byte

~

Provalo online!

~è il non logico e, come tante funzioni, può essere applicato anche ad array / matrici.

C, versione ricorsiva a 46 byte

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

C, 47 byte versione iterativa

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

Esegui utilizzando questa funzione principale

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

e input in questo modo

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

R, 1 byte

!

Esempio:

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

Funziona anche con input numerici:

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

Non siamo nemmeno limitati alle matrici unidimensionali. Facciamo una matrice e la popoliamo casualmente con 0 e 1:

> 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

Possiamo invertire questo altrettanto facilmente:

> !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

Possiamo continuare a farlo per un numero arbitrario di dimensioni. Ecco un esempio su un array quadridimensionale:

> 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

Non funziona per i personaggi, temo.

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

Perl 6 , 4 byte

Versione "francese" / Unicode:

!«*

Versione "Texas" / ASCII:

!<<*

L'input è un singolo valore che può essere trattato come un elenco.

Questo è un qualunque Lambda ( *) con l' operatore non prefisso logico ( !) combinato usando l' operatore hyper prefisso ( «) .

In effetti questo è lo stesso di:

-> $_ { $_.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 )

Uso:

# 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)

Labirinto , 9 byte

,$:)%#$.,

Provalo online! Presuppone l'input separato da una nuova riga con una nuova riga finale. Grazie a @MartinEnder per l'aiuto con il golf.

Questo programma è un po 'strano per un programma Labyrinth: non utilizza la natura 2D del linguaggio e in realtà rimbalza avanti e indietro. Nel primo viaggio di andata, abbiamo:

[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

La ricorrenza successiva di $allora XOR indica lo 0 esistente nello stack c, al contrario di uno 0 implicito nella parte inferiore dello stack come nella prima esecuzione. Entrambe le situazioni lasciano lo stack come [c]e il programma si ripete successivamente.

9 byte alternativi:

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

Mathematica, 7 byte

Not/@#&

o senza lettere:

!#&/@#&

Per quanto riguarda lo zucchero sintattico: &segna l'estremità destra di una funzione senza nome e ha una precedenza molto bassa. #si riferisce al primo argomento del più vicino e che racchiude &. !è l'operatore per Not. Quindi !#&è solo una funzione senza nome che nega il suo argomento, in altre parole è identico al built-in Not. /@è l'operatore per Map. Quindi il codice sarebbe anche equivalente a un po 'più leggibile Map[Not, #]&.

Python, 27 25 24 byte

Grazie a Lynn per il golf di due byte e xnor e Mego per il golf di un altro.

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

C #, 19 byte

come una funzione anonima, prende un bool [] e restituisce un IEnumerable

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

o in 36 byte con

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

Formula IBM / Lotus Notes, 2 byte

!a

Uso:

Creare un modulo Note con due campi denominati a e b.

a (input) = modificabile, numero, valore multiplo, separati da virgola

b (output) = calcolato, numero, multivalore, separato da virgola

Incolla la formula sopra in b e assegna un valore predefinito di 0.

Crea un nuovo documento con il modulo, inserisci un elenco binario in a e premi F9 per aggiornare l'output.

Esempi:

Funziona perché dato un elenco come input, la formula Notes applicherà qualsiasi azione specificata a tutti gli elementi dell'elenco.

J, 2 byte

-.

Questo è il verbo della negazione.

Caso di prova

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

Swift 3 (7 byte)

.map(!)

per esempio

[true, false].map(!)

Spiegazione

Sembra abbastanza ovvio. Chiamate mapsull'array [true, false]. L'unico "gotcha" è che, in Swift, gli operatori sono solo funzioni e possono essere passati come argomenti. Questo significa che map(!)passa la funzione "non" !in map.

Shakespeare Programming Language , 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]

Accetta input come una stringa \0e \1controlla i caratteri. Emette come una stringa di 0o 1. Se l'ingresso deve essere uguale a quello in uscita, sostituirlo Open thy heartcon Speak thy mindper nessuna modifica in bytecount. Se \0e \1non può essere utilizzato, fare quanto sopra, ma sostituire anche Open your mindcon Listen to thy heartuna penalità di 5 byte.

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]

Ciò si traduce approssimativamente nel seguente pseudocodice C:

int romeo;

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

Scene2:;

Sto usando questo interprete . Esecuzione di esempio:

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

JAISBaL , 1 byte

!

Come tutte le altre risposte a 1 byte, questo è l'operatore di negazione, che può operare su un array se necessario. Questo lascia l'output nello stack, che viene stampato alla fine del programma.

Per due byte, l'array può essere stampato esplicitamente:

!§

L'input è nel formato di array incredibilmente strano di JAISBaL (che ho inventato, ma non mi piace ...).

Casi di test (output dell'interprete Java, 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]|%{!$_}

Penso che potrebbe funzionare anche in v1, quindi ho lasciato il numero di versione fuori dal titolo. Passa attraverso l'ingresso$args e annulla ogni elemento a turno. L'array risultante viene lasciato sulla pipeline.

La cosa bella, tuttavia, è perché PowerShell è così lento sui suoi requisiti di casting, puoi fare un input completamente misto e ottenere un output booleano appropriato. Ad esempio, ecco i valori booleani letterali $false/ $true, i numeri 0 1e 123456789come numeri interi, una stringa vuota, una stringa non vuota, una matrice vuota e una matrice non vuota -

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 byte

Include +2 per -lp

Assegna ogni valore booleano come 0 o 1 sulla propria riga

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 byte

:{-$_}a

Provalo online!

Spiegazione

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

Cheddar, 10 byte

@.map((!))

Spero di aver contato bene mentre scrivo dal telefono

Java, 58 byte

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

brainfuck (58 byte)

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

Provalo qui

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

Accetta un input di 1 o 0 indivisi (11001).

Logicode , 9 8 byte

out!binp

Semplice, davvero.

Accetta l'input come stringa binaria, poiché Logicode non supporta gli elenchi (così [true, false]sarebbe 10).

L' outemissione dei risultati della linea.

Il !comando calcola il NOT di ogni bit nella stringa, quindi qualcosa del genere !111sarebbe 000.

È l' binpinput binario.

1 byte salvato grazie a @daHugLenny

CJam , 4 byte

{:!}

Ingresso è una lista di 0s e 1s.

Provalo online!

Japt, 3 byte

¡!X

Japt non ha input booleani, quindi input è un array di 0s e 1s. Provalo online!

Come funziona

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

Retina , 3 byte

%`0

Provalo online!

Per ogni riga ( %), contare il numero di 0s.

Python 2, 24 byte (non concorrenti)

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

La logica è simile a quella di Steven, ma ho provato a usare l'idea di questo commento, ma diversa, perché richiede ancora 0/ 1array, non 0/ -1. Non c'è rasatura di byte per l'uso di 0/ -1, quindi cerchiamo di essere sani. Nota che questo non è in competizione, fino a quando Steven o Lynn non mi permetteranno di usare l'idea. In tal caso, potrei rimuovere il marchio non concorrenziale. Nota che questo codice non può essere rubato senza vergogna, è ancora qui. Solo Steven può usarlo per la sua risposta.

Rubino, 14 byte

Funzione anonima:

->a{a.map &:!}

Provalo:

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