คนเรียบง่ายดี

อินพุต

รับอาเรย์บูลีน (หรือทางเลือกที่ยอมรับได้) คุณสามารถสันนิษฐานได้ว่าอาเรย์จะไม่ยาวเกิน 32 องค์ประกอบ

[false, false, true, false, false]

เอาท์พุต

ย้อนกลับทุกองค์ประกอบของอาร์เรย์และส่งออกมัน

[true, true, false, true, true]

กฎระเบียบ

• คุณสามารถเขียนโปรแกรมเต็มหรือเพียงแค่ฟังก์ชั่น
• ช่องโหว่มาตรฐานใช้
• รหัสที่สั้นที่สุดเป็นไบต์ต่อภาษาชนะ!

กรณีทดสอบ

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

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

05AB1E , 1 ไบต์

รหัส:

_

คำอธิบาย:

_     # Logical not

ลองออนไลน์!

เยลลี่ขนาด 1 ไบต์

¬

ลองออนไลน์!

¬ไม่ใช่ตรรกะ (1 ถ้า false-y, อื่น 0) C(“ ส่วนประกอบ”, 1 − z ) ก็ใช้ได้เช่นกัน

Javascript ES6, 15 ไบต์

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

ไม่จำเป็นต้องอธิบายคำอธิบายมากนัก

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

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

<pre id=a>

Matlab, 4 1 ไบต์

สิ่งนี้ควรอธิบายด้วยตนเอง

~

Matlab มีโอเปอเรเตอร์หนึ่งไบต์~ถ้าคุณต้องการฟังก์ชั่นที่คุณสามารถ@notใช้ได้

Haskell ขนาด 7 ไบต์

map not

ตัวอย่าง:

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

MATL , 1 ไบต์

~

ลองออนไลน์!

~ไม่ได้เป็นตรรกะและฟังก์ชั่นมากมายมันยังสามารถนำไปใช้กับอาร์เรย์ / เมทริกซ์

C, 46 ไบต์รุ่นเรียกซ้ำ

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

C, 47 ไบต์ซ้ำรุ่น

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

เรียกใช้ฟังก์ชั่นหลักนี้

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

และอินพุทแบบนี้

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

R, 1 ไบต์

!

ตัวอย่าง:

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

มันยังทำงานได้กับอินพุตตัวเลข:

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

เราไม่ได้ จำกัด เฉพาะอาเรย์หนึ่งมิติ ลองสร้างเมทริกซ์แล้วสุ่มด้วย 0s และ 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

เราสามารถกลับด้านนี้ได้อย่างง่ายดาย:

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

เราสามารถทำเช่นนี้ต่อไปสำหรับจำนวนมิติโดยพลการ นี่คือตัวอย่างของอาเรย์สี่มิติ:

> 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

ใช้งานไม่ได้กับตัวละครฉันกลัว

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

Perl 6 , 4 ไบต์

"French" / เวอร์ชั่น Unicode:

!«*

"Texas" / เวอร์ชัน ASCII:

!<<*

อินพุตเป็นค่าเดียวซึ่งสามารถถือว่าเป็นรายการ

นี่คือ AA สิ่งที่แลมบ์ดา ( *)กับตรรกะประกอบคำนำหน้าไม่ได้ ( !)รวมใช้ประกอบคำนำหน้าไฮเปอร์ (« )

อย่างมีประสิทธิภาพนี้เป็นเช่นเดียวกับ:

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

การใช้งาน:

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

เขาวงกต 9 ไบต์

,$:)%#$.,

ลองออนไลน์! ถือว่าอินพุตที่คั่นด้วยบรรทัดใหม่ขึ้นบรรทัดใหม่ที่ต่อท้าย ขอบคุณ @MartinEnder สำหรับความช่วยเหลือด้านการเล่นกอล์ฟ

โปรแกรมนี้ค่อนข้างแปลกสำหรับโปรแกรม Labyrinth - มันไม่ได้ใช้ประโยชน์จากลักษณะ 2D ของภาษาและจริง ๆ แล้วมันตีกลับไปมา ในการเดินทางไปข้างหน้าครั้งแรกเรามี:

[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

การเกิดขึ้นครั้งถัดไปของ$XORs นั้นคือ 0 ที่มีอยู่บนสแต็กด้วยcเมื่อเทียบกับ 0 โดยปริยายที่ด้านล่างของสแต็กเหมือนในการทำงานครั้งแรก ทั้งสองสถานการณ์ออกจากสแต็กเป็น[c]และโปรแกรมจะทำซ้ำหลังจากนั้น

ทางเลือก 9- ไบต์:

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

Mathematica ขนาด 7 ไบต์

Not/@#&

หรือไม่มีตัวอักษร:

!#&/@#&

สำหรับน้ำตาลซินแทคติค: &ทำเครื่องหมายจุดสิ้นสุดของฟังก์ชันที่ไม่มีชื่อและมีลำดับความสำคัญต่ำมาก หมายถึงอาร์กิวเมนต์แรกของที่ใกล้ที่สุดและการปิดล้อม# เป็นผู้ประกอบการสำหรับ ดังนั้นเป็นเพียงฟังก์ชั่นที่ไม่มีชื่อที่ขัดแย้งโต้แย้งในคำอื่น ๆ ที่เหมือนกันในการในตัว เป็นผู้ประกอบการสำหรับ ดังนั้นรหัสก็จะเทียบเท่ากับที่ค่อนข้างอ่านง่ายขึ้น&!Not!#&Not/@MapMap[Not, #]&

Python, 27 25 24 ไบต์

ขอบคุณ Lynn สำหรับการเล่นกอล์ฟสองไบต์และ xnor และ Mego สำหรับการเล่นกอล์ฟอีกครั้ง

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

C #, 19 ไบต์

เป็นฟังก์ชั่นระบุชื่อใช้บูล [] และส่งกลับ IEnumerable

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

หรือ 36 ไบต์ด้วย

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

สูตร IBM / Lotus Notes ขนาด 2 ไบต์

!a

การใช้งาน:

สร้างฟอร์ม Notes ที่มีสองฟิลด์ชื่อ a และ b

a (อินพุต) = แก้ไขได้, ตัวเลข, หลายค่า, คั่นด้วยเครื่องหมายจุลภาค

b (เอาท์พุท) = คำนวณ, ตัวเลข, หลายค่า, คั่นด้วยเครื่องหมายจุลภาค

วางสูตรข้างต้นลงใน b และกำหนดค่าเริ่มต้นเป็น 0

สร้างเอกสารใหม่ด้วยฟอร์มป้อนรายการเลขฐานสองใน a และกด F9 เพื่ออัปเดตเอาต์พุต

ตัวอย่าง:

ทำงานได้เนื่องจากได้รับรายการเป็นอินพุตสูตร Notes จะใช้การกระทำที่ระบุกับทุกองค์ประกอบในรายการ

J, 2 ไบต์

-.

นี่คือคำกริยาปฏิเสธ

กรณีทดสอบ

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

สวิฟท์ 3 (7 ไบต์)

.map(!)

เช่น

[true, false].map(!)

คำอธิบาย

ดูเหมือนจะค่อนข้างชัดเจน โทรในอาร์เรย์map [true, false]หนึ่ง "gotcha" คือใน Swift ตัวดำเนินการเป็นเพียงฟังก์ชันและสามารถส่งผ่านเป็นอาร์กิวเมนต์ วิธีนี้map(!)จะผ่าน "ไม่ได้" ฟังก์ชั่นลงใน!map

ภาษาการเขียนโปรแกรมของเช็คสเปียร์ , 240 ไบต์

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

รับอินพุตเป็นสตริง\0และ\1อักขระควบคุม เอาท์พุทเป็นสตริงของหรือ0 1หากอินพุตต้องเหมือนกับเอาต์พุตให้แทนที่Open thy heartด้วยSpeak thy mindไม่มีการเปลี่ยนแปลงใน bytecount หาก\0และ\1ไม่สามารถใช้งานได้ให้ทำตามด้านบน แต่ให้แทนที่Open your mindด้วยListen to thy heartค่าปรับ 5 ไบต์

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]

สิ่งนี้แปลโดยประมาณเป็น pseudocode C ต่อไปนี้:

int romeo;

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

Scene2:;

ฉันใช้ล่ามนี้ วิ่งตัวอย่าง:

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

JAISBaLขนาด 1 ไบต์

!

เช่นเดียวกับคำตอบ 1 ไบต์อื่น ๆ ทั้งหมดนี่คือโอเปอเรเตอร์การปฏิเสธซึ่งสามารถทำงานกับอาร์เรย์ได้หากจำเป็น สิ่งนี้จะทิ้งเอาท์พุทลงบนสแต็กซึ่งถูกพิมพ์ที่ส่วนท้ายของโปรแกรม

สำหรับสองไบต์อาร์เรย์สามารถพิมพ์ได้อย่างชัดเจน:

!§

อินพุตอยู่ในรูปแบบอาร์เรย์แปลก ๆ ของ JAISBaL (ซึ่งฉันประดิษฐ์ขึ้น แต่ฉันไม่ชอบ ... )

กรณีทดสอบ (ผลลัพธ์จากล่าม 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 ไบต์

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

ฉันคิดว่านี่อาจใช้งานได้ใน v1 ดังนั้นฉันจึงปล่อยหมายเลขรุ่นออกจากชื่อ วนซ้ำผ่านอินพุต$argsและทำให้แต่ละรายการกลับกัน อาร์เรย์ผลลัพธ์นั้นถูกทิ้งไว้บนไพพ์ไลน์

อย่างไรก็ตามสิ่งที่เรียบร้อยก็คือเนื่องจาก PowerShell หลวมในข้อกำหนดการคัดเลือกคุณสามารถป้อนข้อมูลแบบผสมอย่างสมบูรณ์และรับเอาต์พุตบูลีนที่เหมาะสม ตัวอย่างเช่นนี่คือค่าบูลีนที่แท้จริง$false/$true , ตัวเลข0 1และ123456789เป็นจำนวนเต็ม, สตริงว่าง, สตริงที่ไม่ว่าง, อาเรย์ที่ว่างเปล่าและอาเรย์ที่ไม่ว่าง -

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 ไบต์

รวมถึง +2 สำหรับ -lp

ตั้งค่าบูลีนแต่ละค่าเป็น 0 หรือ 1 ในบรรทัดของมันเอง

invert.pl
1
1
0
^D

invert.pl:

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

Brachylogขนาด 7 ไบต์

:{-$_}a

ลองออนไลน์!

คำอธิบาย

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

Cheddar ขนาด 10 ไบต์

@.map((!))

ฉันหวังว่าฉันจะนับในขณะที่ฉันเขียนจากโทรศัพท์

Java, 58 ไบต์

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

brainfuck (58 ไบต์)

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

ลองที่นี่

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

รับอินพุต 1s หรือ 0s (11001) ที่ไม่มีการแบ่งแยก

Logicodeขนาด9 8 ไบต์

out!binp

ง่ายจริงๆ

รับอินพุตเป็นสตริงไบนารีเนื่องจาก Logicode ไม่รองรับรายการ (เช่น[true, false]นั้น10)

outoutputs ผลสาย

!คำสั่งคำนวณไม่บิตในสตริงทุกครั้งเพื่อสิ่งที่ต้องการจะเป็น!111000

binpคือการใส่ไบนารี

บันทึก 1 ไบต์ขอบคุณ @daHugLenny

CJam , 4 ไบต์

{:!}

อินพุตคือรายการของ0s และ1s

ลองออนไลน์!

Japt, 3 ไบต์

¡!X

Japt ไม่มีอินพุตบูลีนดังนั้นอินพุตคืออาร์เรย์ของ 0 และ 1 ทดสอบออนไลน์!

มันทำงานอย่างไร

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

เรติน่า 3 ไบต์

%`0

ลองออนไลน์!

สำหรับแต่ละบรรทัด ( %) ให้นับจำนวน0s

Python 2, 24 ไบต์ (ไม่แข่งขัน)

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

ลอจิกมีความคล้ายคลึงกับสตีเว่น แต่ฉันพยายามที่จะใช้นี้เป็นความคิดเห็นความคิดที่แตกต่างกัน แต่เพราะมันยังคงใช้เวลา0/ 1อาร์เรย์ไม่ได้/0 -1ไม่มีการโกนแบบไบท์ทีสำหรับใช้0/ -1ดังนั้นขอให้มีสติ โปรดทราบว่านี่ไม่ใช่การแข่งขันจนกว่า Steven หรือ Lynn จะอนุญาตให้ฉันใช้ความคิดนี้ ถ้าเป็นเช่นนั้นฉันอาจลบเครื่องหมายที่ไม่ใช่คู่แข่ง โปรดทราบว่ารหัสนี้ไม่สามารถขโมยได้อย่างไร้ยางอาย สตีเว่นเท่านั้นที่สามารถใช้มันสำหรับคำตอบของเขา

ทับทิมขนาด 14 ไบต์

ฟังก์ชั่นไม่ระบุชื่อ:

->a{a.map &:!}

ทดสอบมัน

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