Sederhana dan bagus

Memasukkan

Diberikan array boolean (Atau alternatif yang dapat diterima), Anda dapat menganggap array tidak akan pernah lebih dari 32 elemen.

[false, false, true, false, false]

Keluaran

Balikkan setiap elemen array dan keluarkan.

[true, true, false, true, true]

Aturan

• Anda dapat menulis program lengkap atau hanya sebuah fungsi
• Celah standar berlaku
• Kode terpendek dalam byte, per bahasa, menang!

Uji kasus

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

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

05AB1E , 1 byte

Kode:

_

Penjelasan:

_     # Logical not

Cobalah online!

Jeli , 1 byte

¬

Cobalah online!

¬adalah logis BUKAN (1 jika false-y, kalau tidak 0). C("Komplemen", 1 − z ) juga berfungsi.

Javascript ES6, 15 byte

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

Kurasa tidak perlu banyak penjelasan

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

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

<pre id=a>

Matlab, 4 1 byte

Ini harus jelas.

~

Matlab memiliki operator negasi satu byte ~, jika Anda menginginkan fungsi yang dapat Anda gunakan @not.

Haskell, 7 byte

map not

Contoh:

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

MATL , 1 byte

~

Cobalah online!

~adalah logis bukan dan banyak fungsi, itu juga dapat diterapkan ke array / matriks.

C, 46 Bytes versi rekursif

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

C, 47 Bytes versi berulang

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

Jalankan menggunakan fungsi utama ini

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

dan masukan seperti ini

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

R, 1 byte

!

Contoh:

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

Ini juga bekerja dengan input numerik:

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

Kami juga tidak terbatas pada array satu dimensi. Mari kita membuat matriks, dan mengisinya secara acak dengan 0s dan 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

Kami dapat membalikkan ini dengan mudah:

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

Kita dapat terus melakukan ini untuk sejumlah dimensi yang berubah-ubah. Berikut ini contoh array empat dimensi:

> 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

Saya rasa tidak bekerja untuk karakter.

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

Perl 6 , 4 byte

"Perancis" / versi Unicode:

!«*

"Texas" / versi ASCII:

!<<*

Input adalah nilai tunggal yang dapat diperlakukan sebagai daftar.

Ini adalah Apapun lambda ( *) dengan operator logika bukan awalan ( !) digabungkan menggunakan operator hiper awalan ( «) .

Secara efektif ini sama dengan:

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

Pemakaian:

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

Labirin , 9 byte

,$:)%#$.,

Cobalah online! Mengasumsikan input yang dipisahkan oleh baris baru dengan baris baru yang tertinggal. Terima kasih kepada @MartinEnder untuk bantuan bermain golf.

Program ini agak aneh untuk program Labyrinth - program ini tidak menggunakan sifat 2D bahasa tersebut, dan sebenarnya memantul ke depan dan ke belakang. Pada perjalanan maju pertama, kami memiliki:

[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

Kejadian selanjutnya dari $XOR adalah 0 yang ada pada stack dengan c, sebagai lawan dari 0 implisit di bagian bawah stack seperti di jalankan pertama. Kedua situasi meninggalkan tumpukan sebagai[c] , dan program berulang setelahnya.

Alternatif 9-byte:

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

Mathematica, 7 byte

Not/@#&

atau tanpa surat:

!#&/@#&

Adapun gula sintaksis: &menandai ujung kanan fungsi yang tidak disebutkan namanya dan memiliki prioritas yang sangat rendah. #mengacu pada argumen pertama yang terdekat dan terlampir &. !adalah operator untuk Not. Jadi !#&hanya fungsi tanpa nama yang meniadakan argumennya, dengan kata lain identik dengan built-in Not. /@adalah operator untuk Map. Jadi kodenya juga akan setara dengan yang agak terbaca Map[Not, #]&.

Python, 27 25 24 byte

Terima kasih kepada Lynn untuk bermain golf dua byte, dan xnor dan Mego untuk bermain golf lainnya.

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

C #, 19 byte

sebagai fungsi anonim, ambil bool [] dan kembalikan IEnumerable

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

atau dalam 36 byte dengan

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

Formula IBM / Lotus Notes, 2 byte

!a

Pemakaian:

Buat formulir Notes dengan dua bidang bernama a dan b.

a (input) = dapat diedit, angka, multi-nilai, dipisahkan koma

b (output) = dihitung, angka, multi-nilai, dipisahkan koma

Rekatkan rumus di atas ke dalam b dan beri nilai default 0.

Buat dokumen baru dengan formulir, masukkan daftar biner di dan tekan F9 untuk memperbarui output.

Contoh:

Berfungsi karena diberi daftar sebagai input, rumus Notes akan menerapkan tindakan apa pun yang ditentukan untuk setiap elemen dalam daftar.

J, 2 byte

-.

Ini adalah kata kerja negasi.

Kasus cobaan

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

Swift 3 (7 byte)

.map(!)

misalnya

[true, false].map(!)

Penjelasan

Tampak cukup jelas. Panggilan mappada array [true, false]. Satu "gotcha" adalah bahwa, di Swift, operator hanyalah fungsi dan dapat diedarkan sebagai argumen. Ini berarti map(!)meneruskan fungsi "tidak" !ke map.

Bahasa Pemrograman Shakespeare , 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]

Mengambil input sebagai string \0dan \1mengontrol karakter. Output sebagai string 0atau 1. Jika input harus sama dengan output, ganti Open thy heartdengan Speak thy mindtanpa perubahan bytecount. Jika \0dan \1tidak dapat digunakan, lakukan di atas, tetapi juga ganti Open your minddenganListen to thy heart untuk penalti 5-byte.

Tidak Disatukan:

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]

Ini secara kasar diterjemahkan ke kode p C berikut:

int romeo;

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

Scene2:;

Saya menggunakan penerjemah ini . Contoh dijalankan:

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

JAISBaL , 1 byte

!

Seperti semua jawaban 1-byte lainnya, ini adalah operator negasi, yang dapat beroperasi melalui array jika diperlukan. Ini meninggalkan output pada stack, yang dicetak pada akhir program.

Untuk dua byte, array dapat dicetak secara eksplisit:

!§

Input dalam format array JAISBaL yang sangat aneh (yang saya temukan, tapi saya tidak menyukainya ...).

Uji Kasus (Output dari Java interpreter, 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]|%{!$_}

Saya pikir ini bahkan dapat bekerja di v1, maka saya meninggalkan nomor versi dari judul Loop melalui input$args dan meniadakan setiap item pada gilirannya. Array yang dihasilkan ditinggalkan di saluran pipa.

Hal yang rapi, bagaimanapun, adalah karena PowerShell sangat longgar pada persyaratan casting-nya, Anda dapat melakukan input yang sepenuhnya tercampur dan mendapatkan output Boolean yang sesuai. Sebagai contoh, berikut adalah nilai Boolean literal $false/ $true, angka 0 1dan 123456789bilangan bulat, string kosong, string tidak kosong, array kosong, dan array tidak kosong -

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

Termasuk +2 untuk -lp

Berikan setiap nilai boolean sebagai 0 atau 1 pada barisnya sendiri

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 byte

:{-$_}a

Cobalah online!

Penjelasan

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

Cheddar, 10 byte

@.map((!))

Saya harap saya menghitung saat saya menulis dari telepon

Java, 58 byte

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

brainfuck (58 Bytes)

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

Coba di sini

Tidak disatukan

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

Mengambil input 1s atau 0s yang tidak terbagi (11001).

Logicode , 9 8 byte

out!binp

Sederhana, sungguh.

Mengambil input sebagai string biner, karena Logicode tidak memiliki dukungan untuk daftar (demikian [true, false]juga 10).

The outoutput hasil garis ini.

The !perintah menghitung TIDAK setiap bit dalam string, jadi sesuatu seperti !111akan000 .

Itu binp adalah input biner.

1 byte disimpan berkat @daHugLenny

CJam , 4 byte

{:!}

Input adalah daftar 0s dan 1s.

Cobalah online!

Japt, 3 byte

¡!X

Japt tidak memiliki input boolean, jadi input adalah array 0s dan 1s. Uji secara online!

Bagaimana itu bekerja

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

Retina , 3 byte

%`0

Cobalah online!

Untuk setiap baris ( %), hitung jumlah 0s.

Python 2, 24 byte (tidak bersaing)

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

Logika ini mirip dengan Steven, tapi saya mencoba untuk menggunakan ini ide komentar, tapi yang berbeda, karena masih membutuhkan 0/ 1array, tidak 0/ -1. Tidak ada byte cukur untuk menggunakan 0/ -1, jadi mari kita waras. Perhatikan bahwa ini tidak bersaing, sampai Steven atau Lynn mengizinkan saya menggunakan gagasan itu. Jika demikian, saya mungkin menghapus tanda yang tidak bersaing. Perhatikan bahwa kode ini tidak dapat dicuri tanpa malu-malu, masih ada di sini. Hanya Steven yang dapat menggunakannya untuk jawabannya.

Ruby, 14 byte

Fungsi anonim:

->a{a.map &:!}

Menguji:

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