Um bom simples

Entrada

Dada uma matriz booleana (ou uma alternativa aceitável), você pode assumir que a matriz nunca terá mais de 32 elementos.

[false, false, true, false, false]

Resultado

Inverta todos os elementos da matriz e faça a saída.

[true, true, false, true, true]

Regras

• Você pode escrever um programa completo ou apenas uma função
• Aplicam-se brechas padrão
• O menor código em bytes, por idioma, ganha!

Casos de teste

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

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

05AB1E , 1 byte

Código:

_

Explicação:

_     # Logical not

Experimente online!

Geléia , 1 byte

¬

Experimente online!

¬é lógico NOT (1 se falso-y, caso contrário 0). C("Complemento", 1-z ) também funciona.

Javascript ES6, 15 bytes

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

Acho que não há muita explicação

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

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

<pre id=a>

Matlab, 4 1 byte

Isso deve ser auto-explicativo.

~

O Matlab possui o operador de negação de um byte ~, se você quiser uma função, poderá usar @not.

Haskell, 7 bytes

map not

Exemplo:

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

MATL , 1 byte

~

Experimente online!

~é a lógica not e tantas funções, também pode ser aplicada a matrizes / matrizes.

C, 46 bytes versão recursiva

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

C, versão iterativa de 47 bytes

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

Executar usando esta função principal

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

e entrada como esta

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

R, 1 byte

!

Exemplo:

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

Também funciona com entrada numérica:

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

Também não estamos restritos a matrizes unidimensionais. Vamos criar uma matriz e preenchê-la aleatoriamente com 0s e 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 inverter isso com a mesma facilidade:

> !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 fazendo isso para números arbitrários de dimensões. Aqui está um exemplo em uma matriz quadridimensional:

> 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

Receio que não funcione para personagens.

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

Perl 6 , 4 bytes

Versão "francesa" / Unicode:

!«*

Versão "Texas" / ASCII:

!<<*

Entrada é um valor único que pode ser tratado como uma lista.

Isso é aa Qualquer que seja lambda ( *) com o operador lógico não prefixo ( !) combinado usando o operador hiper prefixo ( «) .

Efetivamente, é o mesmo 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)

Labirinto , 9 bytes

,$:)%#$.,

Experimente online! Assume a entrada separada por nova linha com uma nova linha à direita. Obrigado a @MartinEnder pela ajuda com o golfe.

Este programa é um pouco estranho para um programa de labirinto - ele não faz uso da natureza 2D da linguagem e, na verdade, salta para frente e para trás. Na primeira viagem, temos:

[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

A próxima ocorrência de $ então XORs o 0 existente na pilha com c, em oposição a um 0 implícito na parte inferior da pilha, como na primeira execução. Ambas as situações deixam a pilha como [c]e o programa se repete posteriormente.

9 bytes alternativos:

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

Mathematica, 7 bytes

Not/@#&

ou sem letras:

!#&/@#&

Quanto ao açúcar sintático: &marca a extremidade direita de uma função sem nome e tem precedência muito baixa. #refere-se ao primeiro argumento do mais próximo e do anexo &. !é o operador para Not. Assim, !#&é apenas uma função sem nome que nega seu argumento, ou seja, é idêntica à incorporada Not. /@é o operador para Map. Portanto, o código também seria equivalente ao mais legível Map[Not, #]&.

Python, 27 25 24 bytes

Agradecimentos a Lynn por jogar fora dois bytes e xnor e Mego por jogar fora outro.

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

C #, 19 bytes

como uma função anônima, pega um bool [] e retorna um IEnumerable

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

ou em 36 bytes com

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

Fórmula IBM / Lotus Notes, 2 bytes

!a

Uso:

Crie um formulário do Notes com dois campos chamados a e b.

a (entrada) = editável, número, valores múltiplos, separados por vírgula

b (saída) = calculado, número, múltiplos valores, separado por vírgula

Cole a fórmula acima em be dê um valor padrão de 0.

Crie um novo documento com o formulário, insira uma lista binária em a e pressione F9 para atualizar a saída.

Exemplos:

Funciona porque, dada uma lista como entrada, a fórmula do Notes aplicará qualquer ação especificada a todos os elementos da lista.

J, 2 bytes

-.

Este é o verbo de negação.

Caso de teste

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

Rápido 3 (7 bytes)

.map(!)

por exemplo

[true, false].map(!)

Explicação

Parece bastante óbvio. Chama mapa matriz [true, false]. O único problema é que, no Swift, os operadores são apenas funções e podem ser passados ​​como argumentos. Isso significa map(!)passar a função "not" !para map.

Linguagem de programação de 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]

Recebe entrada como uma sequência de caracteres \0e de \1controle. Saídas como uma sequência de 0ou 1. Se a entrada deve ser o mesmo que a saída, substitua Open thy heartcom Speak thy mindpor nenhuma mudança na bytecount. Se \0e \1não puder ser usado, faça o acima, mas também substitua Open your mindporListen to thy heart uma pena de 5 bytes.

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]

Isso se traduz aproximadamente no seguinte pseudocódigo C:

int romeo;

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

Scene2:;

Estou usando esse intérprete . Exemplo de execução:

$ 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 as outras respostas de 1 byte, este é o operador de negação, que pode operar em uma matriz, se necessário. Isso deixa a saída na pilha, que é impressa no final do programa.

Para dois bytes, a matriz pode ser impressa explicitamente:

!§

A entrada está no formato de matriz incrivelmente estranho do JAISBaL (que eu inventei, mas não gosto ...).

Casos de teste (saída do interpretador 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]|%{!$_}

Eu acho que isso pode até funcionar na v1, por isso deixei o número da versão fora do título. Loops através da entrada$args e nega cada item por vez. Essa matriz resultante é deixada no pipeline.

O mais interessante, no entanto, é porque o PowerShell é tão flexível quanto aos requisitos de conversão, você pode fazer uma entrada completamente mista e obter uma saída booleana apropriada. Por exemplo, aqui estão os valores booleanos literais $false/ $true, os números 0 1e 123456789como números inteiros, uma sequência vazia, uma sequência não vazia, uma matriz vazia e uma matriz não vazia -

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

Inclui +2 para -lp

Atribua a cada valor booleano como 0 ou 1 em sua própria linha

invert.pl
1
1
0
^D

invert.pl:

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

Braquilog , 7 bytes

:{-$_}a

Experimente online!

Explicação

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

Queijo Cheddar, 10 bytes

@.map((!))

Espero ter contado direito enquanto escrevo por telefone

Java, 58 bytes

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

brainfuck (58 bytes)

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

Experimente aqui

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

Toma uma entrada de 1s ou 0s não divididos (11001).

Código de lógica , 9 8 bytes

out!binp

Simples, realmente.

Recebe a entrada como uma sequência binária, pois o Logicode não tem suporte para listas (o que [true, false]seria10 ).

A outsaída do resultado da linha.

O !comando calcula o NOT de cada bit da string, então algo como !111seria 000.

A binpentrada é binária.

1 byte salvo graças a @daHugLenny

CJam , 4 bytes

{:!}

A entrada é uma lista de 0s e 1s.

Experimente online!

Japonês, 3 bytes

¡!X

O Japt não possui entrada booleana; portanto, a entrada é uma matriz de 0s e 1s. Teste online!

Como funciona

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

Retina , 3 bytes

%`0

Experimente online!

Para cada linha ( %), conte o número de 0s.

Python 2, 24 bytes (não concorrente)

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

A lógica é semelhante à de Steven, mas tentei usar a ideia desse comentário, mas diferente, porque ainda leva 0/ 1matrizes, não 0/ -1. Não há barbear de bytes para usar 0/ -1, então vamos ser sensatos. Observe que isso não é competitivo, até que Steven ou Lynn me permitam usar a ideia. Se assim for, eu poderia remover a marca não concorrentes. Observe que esse código não pode ser roubado descaradamente, ele ainda está aqui. Apenas Steven pode usá-lo como resposta.

Ruby, 14 bytes

Função anônima:

->a{a.map &:!}

Teste-o:

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