Uno agradable simple

Entrada

Dada una matriz booleana (o una alternativa aceptable), puede asumir que la matriz nunca tendrá más de 32 elementos de largo.

[false, false, true, false, false]

Salida

Invierte cada elemento de la matriz y lo genera.

[true, true, false, true, true]

Reglas

• Puedes escribir un programa completo o solo una función
• Se aplican lagunas estándar
• ¡El código más corto en bytes, por idioma, gana!

Casos de prueba

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

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

05AB1E , 1 byte

Código:

_

Explicación:

_     # Logical not

Pruébalo en línea!

Gelatina , 1 byte

¬

Pruébalo en línea!

¬es lógico NO (1 si es falso-y, de lo contrario 0). C("Complemento", 1 − z ) también funciona.

Javascript ES6, 15 bytes

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

No se necesita mucha explicación, supongo

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

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

<pre id=a>

Matlab, 4 1 byte

Esto debería explicarse por sí mismo.

~

Matlab tiene el operador de negación de un byte ~, si desea una función que pueda usar @not.

Haskell, 7 bytes

map not

Ejemplo:

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

MATL , 1 byte

~

Pruébalo en línea!

~es el lógico no y tantas funciones, también se puede aplicar a matrices / matrices.

C, 46 Bytes versión recursiva

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

C, 47 bytes versión iterativa

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

Ejecute con esta función principal

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

y entrada como esta

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

R, 1 byte

!

Ejemplo:

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

También funciona con entrada numérica:

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

Tampoco estamos restringidos a matrices unidimensionales. Hagamos una matriz y rellene al azar con 0s y 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

Podemos invertir esto con la misma facilidad:

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

Podemos continuar haciendo esto para números arbitrarios de dimensiones. Aquí hay un ejemplo en una matriz de cuatro dimensiones:

> 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

No funciona para los personajes, me temo.

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

Perl 6 , 4 bytes

Versión "francesa" / Unicode:

!«*

Versión "Texas" / ASCII:

!<<*

La entrada es un valor único que puede tratarse como una lista.

Esto es aa Cualquiera que sea lambda ( *) con el operador lógico no prefijo ( !) combinado usando el prefijo hiper operador ( «) .

Efectivamente, esto es lo mismo que:

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

Laberinto , 9 bytes

,$:)%#$.,

Pruébalo en línea! Asume una entrada separada por nueva línea con una nueva línea final. Gracias a @MartinEnder por su ayuda con el golf.

Este programa es un poco extraño para un programa Labyrinth: no hace uso de la naturaleza 2D del lenguaje, y en realidad rebota de un lado a otro. En el primer viaje de ida, tenemos:

[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 siguiente aparición de $XOR entonces el 0 existente en la pila con c, a diferencia de un 0 implícito en la parte inferior de la pila como en la primera ejecución. Ambas situaciones dejan la pila como [c], y el programa se repite a partir de entonces.

Alternativa de 9 bytes:

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

Mathematica, 7 bytes

Not/@#&

o sin letras:

!#&/@#&

En cuanto al azúcar sintáctico: &marca el extremo derecho de una función sin nombre y tiene muy poca precedencia. #se refiere al primer argumento del más cercano y delimitador &. !es el operador para Not. Entonces, !#&es solo una función sin nombre que niega su argumento, en otras palabras, es idéntico al incorporado Not. /@es el operador para Map. Entonces el código también sería equivalente al algo más legible Map[Not, #]&.

Python, 27 25 24 bytes

Gracias a Lynn por jugar golf en dos bytes, y xnor y Mego por jugar golf en otro.

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

C #, 19 bytes

como una función anónima, toma un bool [] y devuelve un IEnumerable

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

o en 36 bytes con

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

Fórmula IBM / Lotus Notes, 2 bytes

!a

Uso:

Cree un formulario de Notas con dos campos llamados a y b.

a (entrada) = editable, número, valor múltiple, separados por comas

b (salida) = calculado, número, multivalor, separado por comas

Pegue la fórmula anterior en b y proporcione un valor predeterminado de 0.

Cree un nuevo documento con el formulario, ingrese una lista binaria en ay presione F9 para actualizar la salida.

Ejemplos:

Funciona porque, dada una lista como entrada, la fórmula de Notes aplicará cualquier acción especificada a cada elemento de la lista.

J, 2 bytes

-.

Este es el verbo de negación.

Caso de prueba

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

Swift 3 (7 bytes)

.map(!)

p.ej

[true, false].map(!)

Explicación

Parece bastante obvio. Llamadas mapen la matriz [true, false]. El único "problema" es que, en Swift, los operadores son solo funciones y se pueden pasar como argumentos. Esto significa que map(!)está pasando la función "no" !a map.

Lenguaje de programación Shakespeare , 240 bytes

.
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]

Toma de entrada como una cadena de \0y \1caracteres de control. Salidas como una cadena de 0o 1. Si la entrada debe ser la misma que la salida, reemplace Open thy heartcon Speak thy mindpor ningún cambio en ByteCount. Si \0y \1no se pueden utilizar, hacer lo anterior, sino también sustituir Open your mindcon Listen to thy heartuna pena de 5 bytes.

Sin golf:

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]

Esto se traduce aproximadamente al siguiente pseudocódigo C:

int romeo;

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

Scene2:;

Estoy usando este intérprete . Ejecución de muestra:

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

JAISBaL , 1 byte

!

Como todas las otras respuestas de 1 byte, este es el operador de negación, que puede operar sobre una matriz si es necesario. Esto deja la salida en la pila, que se imprime al final del programa.

Para dos bytes, la matriz se puede imprimir explícitamente:

!§

La entrada está en el formato de matriz increíblemente extraño de JAISBaL (que inventé, pero no me gusta ...).

Casos de prueba (Salida del intérprete de 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 bytes

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

Creo que esto incluso puede funcionar en v1, por lo tanto, dejé el número de versión fuera del título. Recorre la entrada $argsy niega cada elemento por turno. Esa matriz resultante se deja en la tubería.

Sin embargo, lo bueno es que PowerShell es tan flexible en sus requisitos de conversión que puede hacer una entrada completamente mixta y obtener una salida booleana adecuada. Por ejemplo, aquí están los valores booleanos literales $false/ $true, los números 0 1y 123456789como enteros, una cadena vacía, una cadena no vacía, una matriz vacía y una matriz no vacía:

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

Incluye +2 para -lp

Dé a cada valor booleano como 0 o 1 en su propia línea

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 bytes

:{-$_}a

Pruébalo en línea!

Explicación

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

Cheddar, 10 bytes

@.map((!))

Espero haber contado bien mientras escribo desde el teléfono

Java, 58 bytes

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

brainfuck (58 bytes)

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

Pruébalo aquí

Sin golf

-[>+<-----]>---     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

Toma una entrada de 1s o 0s no divididos (11001).

Logicode , 9 8 bytes

out!binp

Simple, de verdad.

Toma la entrada como una cadena binaria, ya que Logicode no tiene soporte para listas (por [true, false]lo que sería10 ).

los out emite el resultado de la línea.

El !comando calcula el NOT de cada bit en la cadena, por lo que algo así !111sería 000.

La binpentrada es binaria.

1 byte guardado gracias a @daHugLenny

CJam , 4 bytes

{:!}

La entrada es una lista de 0sy 1s.

Pruébalo en línea!

Japt, 3 bytes

¡!X

Japt no tiene entrada booleana, por lo que la entrada es una matriz de 0s y 1s. ¡Pruébelo en línea!

Cómo funciona

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

Retina , 3 bytes

%`0

Pruébalo en línea!

Para cada línea ( %), cuente el número de 0s.

Python 2, 24 bytes (no competitivos)

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

La lógica es similar a la de Steven, pero traté de usar la idea de este comentario, pero diferente, porque todavía toma 0/ 1arrays, no 0/ -1. No hay afeitado de bytes para usar 0/ -1, así que seamos cuerdos. Tenga en cuenta que esto no es competitivo, hasta que Steven o Lynn me permitan usar la idea. Si es así, podría eliminar la marca no competitiva. Tenga en cuenta que este código no se puede robar descaradamente, todavía está aquí. Solo Steven puede usarlo para su respuesta.

Rubí, 14 bytes.

Función anónima:

->a{a.map &:!}

Pruébalo:

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