素敵なシンプルなもの

入力

ブール配列（または受け入れ可能な代替）が与えられた場合、配列の長さが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バイト

¬

オンラインでお試しください！

¬論理否定です（false-yの場合は1、それ以外の場合は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には、~使用できる関数が必要な場合に1バイトの否定演算子があります@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

また、1次元配列に限定されません。マトリックスを作成して、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

任意の数の次元に対してこれを続けることができます。4次元配列の例を次に示します。

> 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とは対照的に、次に発生$するスタック上の既存の0をXORしcます。どちらの状況でもスタックはのまま[c]になり、その後プログラムが繰り返されます。

代替の9バイト：

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

Mathematica、7バイト

Not/@#&

または文字なし：

!#&/@#&

構文糖に関して&は、名前のない関数の右端をマークし、優先順位は非常に低くなっています。#は、最も近く、囲むの最初の引数を参照し&ます。!はの演算子ですNot。だから、!#&ビルトインとその同じ言い換えれば、その引数を否定するだけで無名の関数ですNot。/@はの演算子ですMap。そのため、コードはやや読みやすいコードと同等になりMap[Not, #]&ます。

Python、27 25 24バイト

2バイトのゴルフをしてくれた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という名前の2つのフィールドを持つNotesフォームを作成します。

a（入力）=編集可能、数値、複数値、カンマ区切り

b（出力）=計算済み、数値、複数値、コンマ区切り

上記の式をbに貼り付け、デフォルト値0を指定します。

フォームを使用して新しいドキュメントを作成し、aにバイナリリストを入力し、F9を押して出力を更新します。

例：

入力としてリストを指定すると、Notesの式はリスト内のすべての要素に指定されたアクションを適用するため機能します。

J、2バイト

-.

これは否定動詞です。

テストケース

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

Swift 3（7バイト）

.map(!)

例えば

[true, false].map(!)

説明

かなり明らかなようです。map配列を呼び出します[true, false]。1つの「落とし穴」は、Swiftでは、演算子は単なる関数であり、引数として渡すことができるということです。これはmap(!)、「not」関数をに渡すことを意味!し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 heart5バイトのペナルティについて。

ゴルフをしていない：

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バイトの回答と同様に、これは否定演算子であり、必要に応じて配列を操作できます。これにより、出力がスタックに残り、プログラムの最後に出力されます。

2バイトの場合、配列は明示的に印刷できます。

!§

入力は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

チェダー、10バイト

@.map((!))

私は電話から書いているので、私が正しかったことを願っています

Java、58バイト

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

brainfuck（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）。

Logicode、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]

Logicはスティーブンのに似ていますが、私が使用してみました。このことは、まだかかるので、コメントのアイデアを、異なる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]