Niezły prosty

Wejście

Biorąc pod uwagę tablicę boolowską (lub dopuszczalną alternatywę), możesz założyć, że tablica nigdy nie będzie miała więcej niż 32 elementy.

[false, false, true, false, false]

Wynik

Odwróć każdy element tablicy i wyślij go.

[true, true, false, true, true]

Zasady

• Możesz napisać pełny program lub tylko funkcję
• Obowiązują standardowe luki
• Najkrótszy kod w bajtach, na język, wygrywa!

Przypadki testowe

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

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

05AB1E , 1 bajt

Kod:

_

Wyjaśnienie:

_     # Logical not

Wypróbuj online!

Galaretka , 1 bajt

¬

Wypróbuj online!

¬jest logiczne NIE (1 jeśli false-y, w przeciwnym razie 0). C(„Uzupełnienie”, 1 − z ) również działa.

JavaScript ES6, 15 bajtów

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

Chyba nie trzeba było wiele wyjaśnień

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

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

<pre id=a>

Matlab, 4 1 bajt

To powinno być oczywiste.

~

Matlab ma jednobajtowy operator negacji ~, jeśli potrzebujesz funkcji, której możesz użyć @not.

Haskell, 7 bajtów

map not

Przykład:

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

MATL , 1 bajt

~

Wypróbuj online!

~jest logicznym nie , a wiele funkcji, może być również stosowany do tablic / matryce.

C, 46 bajtów wersja rekurencyjna

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

C, 47 Bajtowa wersja iteracyjna

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

Uruchom za pomocą tej głównej funkcji

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

i takie dane wejściowe

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

R, 1 bajt

!

Przykład:

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

Działa również z wprowadzaniem numerycznym:

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

Nie ograniczamy się również do tablic jednowymiarowych. Zróbmy macierz i losowo zapełnij ją zerami i jedynkami:

> 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

Możemy to równie łatwo odwrócić:

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

Możemy to nadal robić dla dowolnej liczby wymiarów. Oto przykład czterowymiarowej tablicy:

> 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

Obawiam się, że nie działa dla postaci.

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

Perl 6 , 4 bajty

Wersja „francuska” / Unicode:

!«*

Wersja „Texas” / ASCII:

!<<*

Dane wejściowe to pojedyncza wartość, którą można traktować jako listę.

Jest to cokolwiek lambda ( *) z logicznym operatorem nieprefiksowym ( !) połączonym za pomocą przedrostka hyper operator ( «) .

W rzeczywistości jest to to samo, co:

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

Stosowanie:

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

Labirynt , 9 bajtów

,$:)%#$.,

Wypróbuj online! Zakłada wejście oddzielone znakiem nowej linii z końcowym znakiem nowej linii. Dzięki @MartinEnder za pomoc w grze w golfa.

Ten program jest trochę dziwny jak na program Labirynt - nie wykorzystuje dwuwymiarowej natury języka i faktycznie odbija się tam iz powrotem. Podczas pierwszej podróży do przodu mamy:

[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

Kolejne wystąpienie $XOR to istniejące 0 na stosie c, w przeciwieństwie do niejawnego 0 na dole stosu, jak w pierwszym uruchomieniu. Obie sytuacje pozostawiają stos jako [c], a program powtarza się później.

Alternatywne 9 bajtów:

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

Mathematica, 7 bajtów

Not/@#&

lub bez liter:

!#&/@#&

Jeśli chodzi o cukier syntaktyczny: &oznacza prawy koniec nienazwanej funkcji i ma bardzo niski priorytet. #odnosi się do pierwszego argumentu najbliższego i otaczającego &. !jest operatorem dla Not. Tak więc !#&jest to tylko nienazwana funkcja, która neguje jej argument, innymi słowy jest identyczna z wbudowaną Not. /@jest operatorem dla Map. Więc kod byłby również równoważny z nieco bardziej czytelnym Map[Not, #]&.

Python, 27 25 24 bajtów

Dzięki Lynn za grę w golfa za dwa bajty, a Xnor i Mego za grę w golfa za drugim.

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

C #, 19 bajtów

jako funkcja anonimowa przyjmuje bool [] i zwraca IEnumerable

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

lub w 36 bajtach z

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

Formuła IBM / Lotus Notes, 2 bajty

!a

Stosowanie:

Utwórz formularz Notatki z dwoma polami o nazwach a i b.

a (wejście) = edytowalne, liczba, wiele wartości, oddzielone przecinkami

b (wynik) = obliczony, liczba, wiele wartości, oddzielone przecinkami

Wklej powyższą formułę do b i ustaw domyślną wartość 0.

Utwórz nowy dokument za pomocą formularza, wprowadź listę binarną w punkcie i naciśnij klawisz F9, aby zaktualizować dane wyjściowe.

Przykłady:

Działa, ponieważ biorąc pod uwagę listę jako dane wejściowe, formuła programu Notes zastosuje dowolne określone działanie do każdego elementu na liście.

J, 2 bajty

-.

To jest czasownik przeczący.

Przypadek testowy

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

Swift 3 (7 bajtów)

.map(!)

na przykład

[true, false].map(!)

Wyjaśnienie

Wydaje się to dość oczywiste. Wzywa maptablicę [true, false]. „Gotcha” polega na tym, że w Swift operatory są tylko funkcjami i mogą być przekazywane jako argumenty. Oznacza to map(!)przekazanie funkcji „nie” !do map.

Język programowania Szekspira , 240 bajtów

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

Zajmuje wejście jako ciąg \0i \1znaków sterujących. Dane wyjściowe jako ciąg 0lub 1. Jeśli wejście musi być taka sama jak na wyjściu, wymienić Open thy heartz Speak thy mindbez zmiany bytecount. Jeśli \0i \1nie może być używany, należy wykonać powyższe, ale także wymienić Open your mindsię Listen to thy heartna kary 5-bajtowego.

Nie golfowany:

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]

To z grubsza przekłada się na następujący pseudokod C:

int romeo;

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

Scene2:;

Używam tego tłumacza . Przykładowy przebieg:

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

JAISBaL , 1 bajt

!

Podobnie jak wszystkie inne odpowiedzi 1-bajtowe, jest to operator negacji, który w razie potrzeby może działać na tablicy. Pozostawia to wynik na stosie, który jest drukowany na końcu programu.

W przypadku dwóch bajtów tablicę można jawnie wydrukować:

!§

Dane wejściowe są w niezwykle dziwnym formacie tablicowym JAISBaL (który wymyśliłem, ale mi się nie podoba ...).

Przypadki testowe (dane wyjściowe z interpretera 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 bajtów

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

Myślę, że może to nawet działać w wersji 1, dlatego zostawiłem numer wersji wyłączony z tytułu. Pętle przechodzą przez dane wejściowe $argsi kolejno negują każdy element. Powstała tablica jest pozostawiana w potoku.

Ciekawe jest jednak to, że PowerShell jest tak luźny w swoich wymaganiach dotyczących rzutowania, że ​​możesz wykonać całkowicie mieszane dane wejściowe i uzyskać odpowiednią wartość logiczną. Na przykład tutaj są dosłowne wartości logiczne $false/ $true, liczby 0 1i 123456789jako liczby całkowite, pusty ciąg, niepusty ciąg, pusta tablica i niepusta tablica -

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 bajtów

Obejmuje +2 za -lp

Podaj każdą wartość logiczną jako 0 lub 1 w osobnym wierszu

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 bajtów

:{-$_}a

Wypróbuj online!

Wyjaśnienie

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

Cheddar, 10 bajtów

@.map((!))

Mam nadzieję, że policzyłem, pisząc z telefonu

Java, 58 bajtów

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

brainfuck (58 bajtów)

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

Wypróbuj tutaj

Nie golfił

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

Pobiera dane wejściowe niepodzielnych 1 lub 0 (11001).

Kod logiczny , 9 8 bajtów

out!binp

Naprawdę proste.

Pobiera dane wejściowe jako ciąg binarny, ponieważ Logicode nie obsługuje list (tak też [true, false]byłoby 10).

outWyprowadza wynik tej linii.

!Polecenie oblicza NIE każdego bitu w ciągu, więc coś !111będzie 000.

Jest binpto wejście binarne.

1 bajt zapisany dzięki @daHugLenny

CJam , 4 bajty

{:!}

Dane wejściowe to lista 0s i 1s.

Wypróbuj online!

Japt, 3 bajty

¡!X

Japt nie ma danych logicznych, więc dane wejściowe to tablica zer i jedynek. Przetestuj online!

Jak to działa

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

Siatkówka , 3 bajty

%`0

Wypróbuj online!

Dla każdej linii ( %) policz liczbę 0s.

Python 2, 24 bajty (niekonkurujące)

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

Logika jest podobna do Stevena, ale próbowałem użyć pomysłu tego komentarza, ale inaczej, ponieważ wciąż zajmuje 0/ 1tablice, a nie 0/ -1. Nie ma golenia bajtowego przy użyciu 0/ -1, więc bądźmy rozsądni. Zauważ, że to nie konkuruje, dopóki Steven lub Lynn nie pozwolą mi skorzystać z tego pomysłu. Jeśli tak, to może usunąć niekonkurującymi ślad. Pamiętaj, że ten kod nie może zostać bezwstydnie skradziony, nadal istnieje. Tylko Steven może użyć go do swojej odpowiedzi.

Rubinowy, 14 bajtów

Funkcja anonimowa:

->a{a.map &:!}

Sprawdź to:

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