Хороший простой

вход

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

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

Мы не ограничены одномерными массивами. Давайте сделаем матрицу и случайным образом заполним ее нулями и единицами:

> 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 версия:

!<<*

Ввод - это одно значение, которое можно рассматривать как список.

Это все лямбда ( *) с логическим не префиксным оператором ( !), объединенным с использованием префиксного гипероператора ( «) .

Фактически это так же, как:

-> $_ { $_.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 байтов:

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

Mathematica, 7 байтов

Not/@#&

или без букв:

!#&/@#&

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

Python, 27 25 24 байта

Спасибо Линн за игру в гольф на два байта, и xnor и Мего за игру в гольф от другого.

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 Formula, 2 байта

!a

Использование:

Создайте форму Notes с двумя полями с именами a и b.

a (ввод) = редактируемый, число, многозначный, разделенный запятыми

b (вывод) = вычислено, число, многозначное значение, через запятую

Вставьте приведенную выше формулу в b и установите значение по умолчанию 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для каких - либо изменений в ByteCount. Если \0и \1не может быть использована, сделать выше, но и заменить Open your mindс Listen to thy heartна 5-байтовый штраф.

Ungolfed:

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 байт

!

Как и все другие однобайтовые ответы, это оператор отрицания, который может работать с массивом при необходимости. Это оставляет вывод в стеке, который печатается в конце программы.

Для двух байтов массив может быть явно напечатан:

!§

Входные данные находятся в невероятно странном формате массива 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

Брахилог , 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);}

брейкфук (58 байт)

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

Попробуй здесь

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

Принимает ввод неделимых 1 или 0 (11001).

Логикод , 9 8 байт

out!binp

Просто, правда.

Принимает ввод в виде двоичной строки, так как Logicode не поддерживает списки (так [true, false]будет 10).

outВыводит результат в линии.

Команда !вычисляет НЕ для каждого бита в строке, поэтому что-то вроде !111бы будет 000.

Это binpдвоичный вход.

1 байт сохранен благодаря @daHugLenny

CJam , 4 байта

{:!}

Вход представляет собой список 0s и 1s.

Попробуйте онлайн!

Japt, 3 байта

¡!X

Japt не имеет логического ввода, поэтому input представляет собой массив из 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]

Логика похожа на Стивена, но я попытался использовать идею этого комментария, но отличается, потому что она все еще принимает 0/ 1массивы, а не 0/ -1. Для использования 0/ нет байтового бритья -1, так что давайте будем в здравом уме. Обратите внимание, что это не конкурирует, пока Стивен или Линн не позволят мне использовать эту идею. Если так, я мог бы удалить неконкурентный знак. Обратите внимание, что этот код не может быть бесстыдно украден, он все еще здесь. Только Стивен может использовать это для своего ответа.

Рубин, 14 байтов

Анонимная функция:

->a{a.map &:!}

Проверь это:

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