Inverter uma matriz booleana

19

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]
Shaun Wild
fonte
Que tal matrizes de 0(falso, todos os 0 bits) e -1(verdadeiro, todos os 1 bits)?
Lynn
5
@ Lynn Embora seja uma decisão dos OPs, eu diria que o seu idioma deve considerar a verdade / a falsidade.
Martin Ender
Relacionado. (Dada a simplicidade da tarefa principal, eu diria que as diferenças de formato são suficientes significativo que estes não são duplicados.)
Martin Ender
6
Mais do que codificar golfe, isso me parece: qual é o operador não no seu idioma favorito? Pontos adicionais se funcionar em listas.
licorna

Respostas:

14

Geléia , 1 byte

¬

Experimente online!

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

Lynn
fonte
12
Acho que o @Dennis vai ter dificuldade em superar você.
flawr
15
@ flawr É apenas uma questão de tempo até que Dennis faça isso em 0 bytes ou menos.
Erik the Outgolfer
2
@EriktheGolfer "0 bytes ou menos " hmm
zdimension 17/09/16
11
@zdimension É o Dennis, ele pode fazê-lo mais curto do que você pensa (leia os memes).
Erik the Outgolfer
13

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>

Bassdrop Cumberwubwubwub
fonte
12

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.

flawr
fonte
22
obter @rgument, neGate, output, terminate, certo?
Martin Ender
2
Haha, certo, estou surpreso que você seja tão fluente no Matlab!
flawr
lol, isso soa como Borat "Isso deve ser auto-explicativo .... NÃO"
user2023861
certamente ~é uma resposta apropriada, pois é um operador que recebe um argumento. Eu acho que ~[1,0,0,1,0]é inteiramente apropriado.
Tasos Papastylianou
11
@TasosPapastylianou Os envios de operadores são definitivamente válidos (em alguns idiomas, como Julia e Mathematica, é até prática comum definir seus próprios operadores, porque é mais curto do que definir sua própria função), mas tenho certeza de que a falha não quer invalidar meu comentário. ;)
Martin Ender
10

Haskell, 7 bytes

map not

Exemplo:

Prelude> (map not) [False, True, True]
[True,False,False]
Lynn
fonte
Você não precisa dos parênteses no exemplo, certo?
flawr
9
Não, mas queria demonstrar no exemplo como minha resposta é uma expressão válida e não um trecho.
Lynn
3
Houve uma edição sugerida agora para criar o código not<$>, mas essa não é uma expressão válida; você não pode escrever f = not<$>e então f [False, True, True]; as fatias do operador precisam de parênteses em torno deles, o que contribuiria para a contagem de bytes.
Lynn
2
e você também não deveria sugerir código via edições de qualquer maneira
undergroundmonorail
10

MATL , 1 byte

~

Experimente online!

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

flawr
fonte
2
Funciona em APL também.
Adám 15/09/16
10

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]
cleblanc
fonte
Mais curto do que eu esperava ver para C!
22616 Chris Jefferson
10

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.
rturnbull
fonte
11
Para salvar em submeter respostas idênticas, isso também funciona em Julia (exceto ele não funciona na entrada numérica lá)
SP3000
8

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)
Brad Gilbert b2gills
fonte
Eu só estava tentando decifrar a mesma coisa. Eu só chegou até {!«@_}:)
Hobbs
!**deve funcionar também
Jo King
7

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:

,:):/$.:,
,::)/)$.,
,:):%)$.,
Sp3000
fonte
2
Esse efeito de frente para trás é muito legal.
DLosc 15/09/16
Eu gosto desta resposta. É feliz. :)
Fund Monica's Lawsuit
6

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, #]&.

Martin Ender
fonte
11
Como !#&/@#&eu devo ler isso? :)
Lynn
11
@Lynn Isso ajuda? :)
Martin Ender
4
Estou surpreso que Notnão é listável
A Simmons
@ASimmons Sim, eu também.
Martin Ender
6

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]
Steven H.
fonte
11
Matrizes de 0/ 1são permitidas e 1-bsão menores que not b. Perguntei ao OP se matrizes de 0/ -1são permitidas; nesse caso, ~bé ainda mais curto.
Lynn
2
b ^ 1 também funciona.
Xnor
@xnor E isso seria realmente melhor, porque então o espaço antes do espaço forpoderia ser descartado.
Mego 16/09
Eu não sabia que isso 1forseria analisado como dois tokens separados. TIL.
Steven H.
6

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);
hstde
fonte
5

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:

insira a descrição da imagem aqui

insira a descrição da imagem aqui

insira a descrição da imagem aqui

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

ElPedro
fonte
2
Oh meu Deus ... Minha empresa simplesmente se afastou das notas de lótus; Eu esperava nunca mais vê-lo. +1 para esse retrocesso.
Magic Octopus Urn
Eu acho que muitas empresas estão @carusocomputing e provavelmente com razão. Trabalho com ele há mais de 20 anos e ainda me surpreende o que a linguagem de fórmula pode fazer com as iterações de lista às vezes. É divertido para abrir designer de vez em quando e ver o quanto eu ainda me lembro :-)
ElPedro
5

J, 2 bytes

-.

Este é o verbo de negação.

Caso de teste

   -. 0 1 0 0 1
1 0 1 1 0
Conor O'Brien
fonte
5

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.

mklbtz
fonte
Um impressionante resposta curta para uma linguagem que é terrível para golfe em :).
DJMcMayhem
Eu sinto que violei uma regra ou algo assim. Não tenho certeza de como eles são julgados. : D
mklbtz 16/09
Isso é incrível.
JAL
5

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
Cobre
fonte
4

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: {}
Phoenix socrático
fonte
4

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
AdmBorkBork
fonte
4

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
Ton Hospel
fonte
3

Queijo Cheddar, 10 bytes

@.map((!))

Espero ter contado direito enquanto escrevo por telefone

Downgoat
fonte
11
Penso que, equivalentemente, fn.vec((!))se algum dia foi lançado: P
Conor O'Brien
3

Java, 58 bytes

void f(boolean[]a){for(boolean i:a)System.out.print(!i);}
Numberknot
fonte
Maneiras de jogar golfe: mude arrpara a(economiza 4 bytes), escreva em int[]avez de int a[](economiza 1 byte), #:
Olivier Grégoire
oops! como eu esqueço isso? como eu sou louco. e obrigado @
OlivierGrégoire
3

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

gtwebb
fonte
3

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

clismique
fonte
Eu acho que você pode remover o espaço entre oute !binp.
acrolith 22/09/16
@daHugLenny Huh, eu não sabia que você poderia fazer isso. Obrigado!
clismique 23/09/16
2

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
ETHproductions
fonte
2

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.

Erik, o Outgolfer
fonte
2

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]
daniero
fonte