Гарний простий

Вхідні дані

Враховуючи логічний масив (або прийнятну альтернативу), ви можете припустити, що масив ніколи не буде більше 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>

Матлаб, 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.

Перл 6 , 4 байти

"Французька" / версія Unicode:

!«*

"Техас" / версія 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 за допомогу в гольфі.

Ця програма трохи дивна для програми «Лабіринт» - вона не використовує двовимірний характер мови, а насправді відскакує назад і назад. У першій прямій поїздці ми маємо:

[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

Наступне виникнення $тоді XOR має існуючий 0 на стеці з c, на відміну від неявного 0 у нижній частині стека, як у першому запуску. Обидві ситуації залишають стек як[c] , і програма повторюється після цього.

Альтернативно 9-байт:

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

Математика, 7 байт

Not/@#&

або без літер:

!#&/@#&

Що стосується синтаксичного цукру: він &позначає правий кінець безіменної функції і має дуже низький пріоритет. #посилається на перший аргумент найближчого та заключного &. !є оператором для Not. Отже, !#&це лише неназвана функція, яка заперечує її аргумент, інакше кажучи, ідентична вбудованій Not. /@є оператором для Map. Таким чином, код також був би еквівалентний дещо читабельнішому Map[Not, #]&.

Пітона, 27 25 24 байти

Дякуємо Лінні за те, що вони грають у два байти, а також 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.

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]. Один "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-байтовий штраф.

Безголівки:

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 bytes

:{-$_}a

Try it online!

Explanation

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

Cheddar, 10 bytes

@.map((!))

I hope I counted right as I'm writing from phone

Java, 58 bytes

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

brainfuck (58 Bytes)

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

Try it here

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

Takes an input of undivided 1s or 0s (11001).

Logicode, 9 8 bytes

out!binp

Simple, really.

Takes input as a binary string, as Logicode doesn't have support for lists (so [true, false] would be 10).

The out outputs the line's result.

The ! command calculates the NOT of every bit in the string, so something like !111 would be 000.

The binp is binary input.

1 byte saved thanks to @daHugLenny

CJam, 4 bytes

{:!}

Input is a list of 0s and 1s.

Try it online!

Japt, 3 bytes

¡!X

Japt doesn't have boolean input, so input is an array of 0s and 1s. Test it online!

How it works

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

Retina, 3 bytes

%`0

Try it online!

For each line (%), count the number of 0s.

Python 2, 24 bytes (non-competing)

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

Logic is similar to Steven's, but I tried to use this comment's idea, but different, because it still takes 0/1 arrays, not 0/-1. There is no byte shaving for using 0/-1, so let's be sane. Note that this is non-competing, until Steven or Lynn allows me to use the idea. If so, I might remove the non-competing mark. Note that this code cannot be shamelessly stolen, it's still here. Only Steven can use it for his answer.

Ruby, 14 bytes

Anonymous function:

->a{a.map &:!}

Test it:

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