좋은 간단한 것

입력

부울 배열 (또는 허용 가능한 대안)이 주어지면 배열의 길이가 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 )도 작동합니다.

자바 스크립트 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.

하스켈, 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.

펄 6 , 4 바이트

"프랑스어"/ 유니 코드 버전 :

!«*

"텍사스"/ ASCII 버전 :

!<<*

입력은 목록으로 취급 할 수있는 단일 값입니다.

이것은 접두사 하이퍼 연산자 ( )를 사용하여 결합한 논리적 인 접두사없는 연산자 ( )를 가진 무엇이든 람다 ( *) 입니다 .!«

실제로 이것은 다음과 같습니다.

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

다음 번 발생은 $스택 c의 맨 아래에있는 암시 적 0이 아니라 첫 번째 실행에서와 같이 스택의 기존 0을 XOR합니다 . 두 상황 모두 스택을로 남겨두고 [c]프로그램은 이후에 반복됩니다.

대체 9 바이트 :

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

Mathematica, 7 바이트

Not/@#&

또는 문자없이 :

!#&/@#&

구문 설탕 &은 명명되지 않은 함수의 오른쪽 끝을 표시하고 우선 순위가 매우 낮습니다. #가장 근접하고 둘러싼 첫 번째 인수를 나타냅니다 &. !의 연산자입니다 Not. 따라서 !#&이름없는 함수는 인수를 무효화하는, 즉 내장 함수와 동일합니다 Not. /@의 연산자입니다 Map. 따라서 코드는 다소 읽기 쉬운 코드와 동일합니다 Map[Not, #]&.

파이썬, 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라는 두 개의 필드로 Notes 양식을 작성하십시오.

a (입력) = 편집 가능, 숫자, 다중 값, 쉼표로 구분

b (출력) = 계산, 숫자, 다중 값, 쉼표로 구분

위의 공식을 b에 붙여넣고 aa 기본값 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(!)"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]

(A)의 문자열로 입력을 받아 \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

펄, 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((!))

전화로 글을 쓸 때 올바르게 계산했으면 좋겠습니다.

자바, 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).

로직 , 9 8 바이트

out!binp

정말 간단합니다.

Logicode는 목록을 지원하지 않으므로 입력을 이진 문자열로 가져옵니다 [true, false].10 ).

그만큼 out 라인의 결과를 출력한다.

이 !명령은 문자열에서 모든 비트의 NOT을 계산하므로 다음과 같습니다 !111.000 .

그만큼 binp 이진 입력된다.

@daHugLenny 덕분에 1 바이트 절약

CJam , 4 바이트

{:!}

입력은의 목록 0이며1 s의 .

온라인으로 사용해보십시오!

apt, 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이 아이디어를 사용할 수있을 때까지 이것은 경쟁이 아닙니다. 그렇다면 경쟁이 아닌 마크를 제거 할 수 있습니다 . 이 코드는 부끄럽게 도난 당할 수 없으며 여전히 여기 있습니다. Steven만이 그의 대답에 사용할 수 있습니다.

루비, 14 바이트

익명의 기능 :

->a{a.map &:!}

그것을 테스트하십시오 :

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