Một đơn giản tốt đẹp

Đầu vào

Đưa ra một mảng boolean (Hoặc một sự thay thế chấp nhận được), bạn có thể giả sử rằng mảng sẽ không bao giờ dài hơn 32 phần tử.

[false, false, true, false, false]

Đầu ra

Đảo ngược mọi phần tử của mảng và xuất nó.

[true, true, false, true, true]

Quy tắc

• Bạn có thể viết một chương trình đầy đủ hoặc chỉ là một chức năng
• Áp dụng sơ hở tiêu chuẩn
• Mã ngắn nhất tính theo byte, trên mỗi ngôn ngữ, sẽ thắng!

Các trường hợp thử nghiệm

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

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

05AB1E , 1 byte

Mã số:

_

Giải trình:

_     # Logical not

Hãy thử trực tuyến!

Thạch , 1 byte

¬

Hãy thử trực tuyến!

¬là logic KHÔNG (1 nếu sai-y, khác 0). C(Bổ sung cho cộng đồng, 1 − z ) cũng hoạt động.

Javascript ES6, 15 byte

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

Tôi đoán không cần nhiều lời giải thích

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

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

<pre id=a>

Matlab, 4 1 byte

Điều này nên được tự giải thích.

~

Matlab có toán tử phủ định một byte ~, nếu bạn muốn một hàm bạn có thể sử dụng @not.

Haskell, 7 byte

map not

Thí dụ:

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

MATL , 1 byte

~

Hãy thử trực tuyến!

~là logic không và nhiều hàm, nó cũng có thể được áp dụng cho mảng / ma trận.

Phiên bản đệ quy C, 46 Byte

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

Phiên bản lặp C, 47 byte

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

Chạy bằng chức năng chính này

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

và đầu vào như thế này

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

R, 1 byte

!

Thí dụ:

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

Nó cũng hoạt động với đầu vào số:

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

Chúng tôi cũng không bị giới hạn trong các mảng một chiều. Chúng ta hãy tạo một ma trận và điền ngẫu nhiên vào 0 và 1:

> 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

Chúng ta có thể đảo ngược điều này một cách dễ dàng:

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

Chúng ta có thể tiếp tục làm điều này cho số lượng kích thước tùy ý. Đây là một ví dụ về mảng bốn chiều:

> 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

Không làm việc cho các nhân vật, tôi sợ.

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

Perl 6 , 4 byte

"Phiên bản tiếng Pháp" / Unicode:

!«*

Phiên bản "Texas" / ASCII:

!<<*

Đầu vào là một giá trị duy nhất có thể được coi là một danh sách.

Đây là aa Dù lambda ( *) với toán tử logic không phải tiền tố ( !) được kết hợp bằng cách sử dụng toán tử siêu tiền tố ( «) .

Thực tế, điều này giống như:

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

Sử dụng:

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

Mê cung , 9 byte

,$:)%#$.,

Hãy thử trực tuyến! Giả sử đầu vào được phân tách bằng dòng mới với một dòng mới. Cảm ơn @MartinEnder đã giúp đỡ chơi golf.

Chương trình này hơi kỳ lạ đối với chương trình Labyrinth - nó không sử dụng bản chất 2D của ngôn ngữ và nó thực sự nảy qua lại. Trong chuyến đi đầu tiên, chúng tôi có:

[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

Sự xuất hiện tiếp theo của $XOR sau đó là 0 hiện tại trên ngăn xếp c, trái ngược với 0 ẩn ở dưới cùng của ngăn xếp như trong lần chạy đầu tiên. Cả hai tình huống đều rời khỏi ngăn xếp [c]và chương trình lặp lại sau đó.

9 byte thay thế:

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

Toán học, 7 byte

Not/@#&

hoặc không có chữ cái:

!#&/@#&

Đối với đường cú pháp: &đánh dấu phần cuối bên phải của hàm không tên và có độ ưu tiên rất thấp. #đề cập đến đối số đầu tiên của gần nhất và kèm theo &. !là toán tử cho Not. Vì vậy, !#&chỉ là một hàm không tên mà phủ nhận đối số của nó, nói cách khác, nó giống hệt với hàm dựng sẵn Not. /@là toán tử cho Map. Vì vậy, mã cũng sẽ tương đương với phần nào dễ đọc hơn Map[Not, #]&.

Python, 27 25 24 byte

Cảm ơn Lynn vì đã chơi golf hai byte, và xnor và Mego đã chơi golf khác.

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

C #, 19 byte

là một hàm đồng nghĩa, lấy bool [] và trả về IEnumerable

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

hoặc trong 36 byte với

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

Công thức ghi chú IBM / Lotus, 2 byte

!a

Sử dụng:

Tạo một biểu mẫu Ghi chú với hai trường có tên a và b.

a (đầu vào) = có thể chỉnh sửa, số, đa giá trị, được phân tách bằng dấu phẩy

b (đầu ra) = được tính, số, đa giá trị, được phân tách bằng dấu phẩy

Dán công thức trên vào b và cho aa giá trị mặc định là 0.

Tạo một tài liệu mới với biểu mẫu, nhập danh sách nhị phân vào a và nhấn F9 để cập nhật đầu ra.

Ví dụ:

Hoạt động vì được đưa ra một danh sách làm đầu vào, công thức Ghi chú sẽ áp dụng bất kỳ hành động nào được chỉ định cho mọi thành phần trong danh sách.

J, 2 byte

-.

Đây là động từ phủ định.

Trường hợp thử nghiệm

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

Swift 3 (7 byte)

.map(!)

ví dụ

[true, false].map(!)

Giải trình

Có vẻ khá rõ ràng. Các cuộc gọi maptrên mảng [true, false]. Một "gotcha" là, trong Swift, các toán tử chỉ là các hàm và có thể được truyền xung quanh dưới dạng đối số. Điều này có nghĩa map(!)là chuyển chức năng "không" !vào map.

Ngôn ngữ lập trình 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]

Đưa đầu vào dưới dạng một chuỗi các ký tự \0và \1điều khiển. Đầu ra dưới dạng một chuỗi 0hoặc 1. Nếu đầu vào phải giống với đầu ra, thay thế Open thy heartbằng Speak thy mindkhông thay đổi trong bytecount. Nếu \0và \1không thể được sử dụng, hãy làm như trên, nhưng cũng thay thế Open your mindbằng Listen to thy hearthình phạt 5 byte.

Ung dung:

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]

Điều này tạm dịch là mã giả C sau đây:

int romeo;

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

Scene2:;

Tôi đang sử dụng trình thông dịch này . Chạy mẫu:

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

JAISBaL , 1 byte

!

Giống như tất cả các câu trả lời 1 byte khác, đây là toán tử phủ định, có thể hoạt động trên một mảng nếu cần. Điều này để lại đầu ra trên ngăn xếp, được in ở cuối chương trình.

Đối với hai byte, mảng có thể được in rõ ràng:

!§

Đầu vào là định dạng mảng cực kỳ kỳ lạ của JAISBaL (mà tôi đã phát minh ra, nhưng tôi không thích nó ...).

Các trường hợp thử nghiệm (Đầu ra từ trình thông dịch 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 byte

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

Tôi nghĩ rằng điều này thậm chí có thể hoạt động trong v1, do đó tôi đã bỏ số phiên bản khỏi tiêu đề. Vòng lặp thông qua đầu vào $argsvà lần lượt phủ nhận từng mục. Mảng kết quả đó được để lại trên đường ống.

Tuy nhiên, điều gọn gàng là do PowerShell quá lỏng lẻo đối với các yêu cầu truyền của nó, bạn có thể thực hiện một đầu vào hỗn hợp hoàn toàn và có được một đầu ra Boolean thích hợp. Ví dụ: đây là các giá trị Boolean theo nghĩa đen $false/ $true, các số 0 1và 123456789dưới dạng số nguyên, một chuỗi rỗng, một chuỗi không trống, một mảng trống và một mảng không trống -

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

Bao gồm +2 cho -lp

Cho mỗi giá trị boolean là 0 hoặc 1 trên dòng riêng của nó

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 byte

:{-$_}a

Hãy thử trực tuyến!

Giải trình

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

Cheddar, 10 byte

@.map((!))

Tôi hy vọng tôi đã tính đúng khi tôi viết từ điện thoại

Java, 58 byte

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

brainfuck (58 byte)

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

Hãy thử nó ở đây

Bị đánh cắp

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

Có đầu vào là 1 hoặc 0 không phân chia (11001).

Logicode , 9 8 byte

out!binp

Đơn giản, thực sự.

Đưa đầu vào dưới dạng chuỗi nhị phân, vì Logicode không hỗ trợ danh sách (vì vậy [true, false]sẽ là10 ).

Các out kết quả đầu ra của dòng.

Các !lệnh tính KHÔNG của mỗi bit trong chuỗi, vì vậy cái gì đó như !111sẽ 000.

Đây binplà đầu vào nhị phân.

Lưu 1 byte nhờ @daHugLenny

CJam , 4 byte

{:!}

Đầu vào là danh sách 0s và 1s.

Hãy thử trực tuyến!

Japt, 3 byte

¡!X

Japt không có đầu vào boolean, vì vậy đầu vào là một mảng 0 và 1. Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

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

Võng mạc , 3 byte

%`0

Hãy thử trực tuyến!

Đối với mỗi dòng ( %), đếm số 0s.

Python 2, 24 byte (không cạnh tranh)

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

Logic là tương tự như của Steven, nhưng tôi cố gắng sử dụng này ý tưởng của bình luận, nhưng khác nhau, bởi vì nó vẫn còn mất 0/ 1mảng, không 0/ -1. Không có cạo byte để sử dụng 0/ -1, vì vậy hãy bình tĩnh. Lưu ý rằng điều này là không cạnh tranh, cho đến khi Steven hoặc Lynn cho phép tôi sử dụng ý tưởng. Nếu vậy, tôi có thể loại bỏ nhãn hiệu không cạnh tranh. Lưu ý rằng mã này không thể bị đánh cắp một cách đáng xấu hổ, nó vẫn ở đây. Chỉ Steven có thể sử dụng nó cho câu trả lời của mình.

Ruby, 14 byte

Hàm ẩn danh:

->a{a.map &:!}

Kiểm tra nó:

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