一个不错的简单的

输入项

给定一个布尔数组（或可接受的替代方法），您可以假定该数组的长度永远不会超过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字节

¬

在线尝试！

¬是逻辑NOT（如果为false-y，则为1，否则为0）。C（“ complement”，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

我们也不限于一维数组。让我们做一个矩阵，并用0和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

我们可以轻松地将其反转：

> !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个字节

“法语” / Unicode版本：

!«*

“德州” / 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在高尔夫方面的帮助。

对于迷宫程序，该程序有点奇怪-它没有利用语言的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

下一次出现的情况是$，对堆栈上的现有0 与进行XOR，这与c第一次运行时在堆栈底部的隐式0相反。两种情况都将堆栈保留为[c]，然后程序重复执行。

备用9个字节：

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

Mathematica，7个字节

Not/@#&

或不带字母：

!#&/@#&

至于语法糖：&标记未命名函数的右端，并且优先级很低。#指的是最接近且包含在内的第一个参数&。!是的运算符Not。所以!#&只是一个无名函数，否定其说法，换句话说，它等同于内置Not。/@是的运算符Map。因此，代码也将等效于更具可读性的代码Map[Not, #]&。

Python，27 25 24字节

感谢Lynn打高尔夫球两个字节，以及xnor和Mego打高尔夫球另一个字节。

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

C＃，19个字节

作为匿名函数，采用bool []并返回IEnumerable

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

或36个字节

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

IBM / Lotus Notes公式，2个字节

!a

用法：

创建一个具有两个名为a和b的字段的Notes窗体。

（输入）=可编辑，数字，多值，逗号分隔

b（输出）=计算，数字，多值，逗号分隔

将上面的公式粘贴到b中，并给a默认值为0。

使用该表单创建一个新文档，在中输入一个二进制列表，然后按F9更新输出。

例子：

之所以有效，是因为给定一个列表作为输入，Notes公式会将指定的操作应用于列表中的每个元素。

J，2个字节

-.

这是否定动词。

测试用例

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

Swift 3（7个字节）

.map(!)

例如

[true, false].map(!)

说明

似乎很明显。调用map数组[true, false]。一个“陷阱”是，在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保持字节数不变。如果\0并且\1不能使用，请执行上述操作，但也可以替换Open your mind为Listen to thy heart了5个字节的惩罚。

取消高尔夫：

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]

这大致翻译为以下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);}

脑干（58字节）

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

在这里尝试

不打高尔夫球

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

接受未分1或0（11001）的输入。

逻辑码，9 8字节

out!binp

很简单，真的。

需要输入的二进制字符串，如Logicode不具有列表（这样的支持[true, false]会10）。

的 out输出线的结果。

该!命令将计算字符串中每一位的NOT，因此!111将000。

的 binp是二进制输入。

@daHugLenny节省了1个字节

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]

逻辑类似于Steven的逻辑，但是我尝试使用此注释的想法，但是有所不同，因为它仍然采用0/ 1数组，而不是0/ -1。使用0/ 不会刮胡子-1，所以让我们理智。请注意，这是不竞争的，直到Steven或Lynn允许我使用这个想法。如果是这样，我可能会删除非竞争标记。请注意，此代码不能被偷偷窃，它仍然在这里。只有史蒂文才能将其用作答案。

Ruby，14个字节

匿名函数：

->a{a.map &:!}

测试一下：

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