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

вход

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

code-golf array-manipulation logic

— Шон Уайлд
источник

Как насчет массивов 0(false, все 0 бит) и -1(true, все 1 бит)?

— Линн

5

@Lynn Хотя это решение ОП, я бы сказал, что все зависит от того, считает ли ваш язык правдивым или ложным.

— Мартин Эндер

Связанный. (Учитывая простоту основной задачи, я бы сказал, что различия в формате достаточно значительны, чтобы они не были дубликатами.)

— Мартин Эндер

6

Для меня это больше, чем код-гольф: кто на вашем любимом языке не оператор? Дополнительные пункты, если это работает на списках.

— августа

26

05AB1E , 1 байт

Код:

Объяснение:

_     # Logical not

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

— Аднан
источник

5

Мне нравится объяснение

— Стефан Бийзиттер

14

Желе , 1 байт

¬

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

¬логически НЕ (1, если false-y, иначе 0). C(«Дополнение», 1-z ) также работает.

— Линн
источник

12

Я думаю, что @Dennis будет трудно переиграть тебя.

— flawr 15.09.16

15

@flawr Это всего лишь вопрос времени, когда Деннис сделает это за 0 байтов или меньше.

— Эрик Outgolfer

2

@EriktheGolfer "0 байт или меньше " хмм

— zdimension

1

@zdimension Это Деннис, он может сделать это короче, чем вы думаете (читайте мемы).

— Эрик Outgolfer

13

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>

Развернуть фрагмент

— Bassdrop Cumberwubwubwub
источник

12

Matlab, 4 1 байт

Это должно быть само за себя.

Matlab имеет однобайтовый оператор отрицания ~, если вам нужна функция, которую вы можете использовать @not.

— flawr
источник

22

получить @ругмент, negate o, tutput, erminate, верно?

— Мартин Эндер

2

Ха-ха, верно, я удивлен, что ты так хорошо владеешь Матлабом!

— flawr 15.09.16

LOL, это звучит как Борат "Это должно быть само за себя .... НЕ"

— user2023861

Конечно ~, это правильный ответ, так как это оператор, который получает аргумент. Я думаю, что ~[1,0,0,1,0]это вполне уместно.

— Тасос Папастилиану

1

@TasosPapastylianou Представления операторов однозначно действительны (в некоторых языках, таких как Julia и Mathematica, определение собственных операторов даже является обычной практикой, потому что это короче, чем определение вашей собственной функции), но я уверен, что flawr просто не хочет аннулировать мой комментарий. ;)

— Мартин Эндер

10

Haskell, 7 байтов

map not

Пример:

Prelude> (map not) [False, True, True]
[True,False,False]

— Линн
источник

Вам не нужна скобка в примере, верно?

— flawr

9

Я не знаю, но я хотел продемонстрировать на примере, что мой ответ является допустимым выражением, а не фрагментом.

— Линн

3

Только что было предложено изменить код для создания кода not<$>, но это недопустимое выражение; ты не можешь написать f = not<$>и тогда f [False, True, True]; операторным слайсам нужны круглые скобки вокруг них, что будет способствовать подсчету байтов.

— Линн

2

а также вы не должны предлагать код через редактирование в любом случае

— андерграундмонор

10

MATL , 1 байт

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

~является логическим не так, как многие функции, он также может быть применен к массивам / матриц.

— flawr
источник

2

Работает и в APL.

— августа

10

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]

— cleblanc
источник

Короче, чем я ожидал увидеть для C!

— Крис Джефферсон

10

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.

— rturnbull
источник

1

Чтобы сэкономить на отправке идентичных ответов, это также работает в Юлии (за исключением того, что там не работает с числовым вводом)

— Sp3000

8

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)

— Брэд Гилберт b2gills
источник

Я просто пытался разгадать то же самое. Я только добрался до {!«@_}:)

— Хоббс

!**должно работать тоже

— Джо Кинг

7

Лабиринт , 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 байтов:

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

— Sp3000
источник

2

Этот эффект вперёд-назад действительно крут.

— DLosc

Мне нравится этот ответ. Это счастливо :)

— Фонд Моника иск

6

Mathematica, 7 байтов

Not/@#&

или без букв:

!#&/@#&

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

— Мартин Эндер
источник

11

Как !#&/@#&я должен это читать? :)

— Линн

1

@ Линн Это помогает? :)

— Мартин Эндер

4

Я удивлен, что Notэто не в списке

— Симмонс

@ASimmons Да, я тоже.

— Мартин Эндер,

6

Python, 27 25 24 байта

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

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

— Стивен Х.
источник

1

Допускаются массивы 0/ 1, и они 1-bкороче, чем not b. Я спросил ОП , разрешены ли массивы 0/ -1, в этом случае ~bеще короче.

— Линн

2

б ^ 1 тоже работает.

— xnor

@xnor И это на самом деле было бы лучше, потому что тогда пространство перед тем forможно было бы отбросить.

— Мего

Я не понимал, что 1forэто будет проанализировано как два отдельных токена. Да, пока.

— Стивен Х.

6

C #, 19 байт

как анонимная функция, принимает bool [] и возвращает IEnumerable

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

или в 36 байтах с

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

— hstde
источник

5

IBM / Lotus Notes Formula, 2 байта

!a

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

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

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

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

Вставьте приведенную выше формулу в b и установите значение по умолчанию 0.

Создайте новый документ с формой, введите двоичный список в и нажмите F9, чтобы обновить вывод.

Примеры:

Работает, потому что, учитывая список в качестве входных данных, формула Notes будет применять любое указанное действие к каждому элементу в списке.

— ElPedro
источник

2

Боже мой ... Моя компания просто перешла от лотосных заметок; Я надеялся никогда не увидеть это снова. +1 за этот возврат.

— Волшебная урна осьминога

Я думаю, что многие компании @carusocomputing и, вероятно, это правильно. Я работаю с ним более 20 лет, и меня до сих пор поражает то, что язык формул может иногда делать с итерациями списков.

— Забавно

5

J, 2 байта

-.

Это глагол отрицания.

Прецедент

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

— Конор О'Брайен
источник

5

Swift 3 (7 байт)

.map(!)

например

[true, false].map(!)

объяснение

Кажется довольно очевидным. Звонит mapпо массиву [true, false]. Единственная «ошибка» в том, что в Swift операторы являются просто функциями и могут передаваться в качестве аргументов. Это означает map(!)передачу функции «не» !в map.

— mklbtz
источник

Впечатляюще короткий ответ для языка, который ужасен для игры в гольф. :)

— DJMcMayhem

Я чувствую, что нарушил правило или что-то в этом роде. Я не уверен, как это судят. : D

— mklbtz

Это круто.

— JAL

5

Язык программирования Шекспира , 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

— медь
источник

4

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: {}

— Сократовский феникс
источник

4

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

— AdmBorkBork
источник

4

Perl, 7 байт

Включает +2 для -lp

Присвойте каждому логическому значению значение 0 или 1 в отдельной строке

invert.pl
1
1
0
^D

invert.pl:

#!/us/bin/perl -lp
$_^=1

— Тон Хоспел
источник

3

Брахилог , 7 байт

:{-$_}a

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

объяснение

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

— Fatalize
источник

3

Чеддер, 10 байт

@.map((!))

Надеюсь, я считал правильно, когда я пишу с телефона

— Downgoat
источник

1

Я думаю, что эквивалентно, fn.vec((!))если это когда-либо было выпущено: P

— Конор О'Брайен

3

Java, 58 байт

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

— Numberknot
источник

Способы игры в гольф: измените arrна a(экономит 4 байта), пишите int[]aвместо int a[](сохраняет 1 байт),

— Оливье Грегуар

упс! Как я могу забыть это? Как я безумна. и спасибо @ OlivierGrégoire

— Numberknot

3

брейкфук (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).

— gtwebb
источник

3

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

out!binp

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

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

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

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

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

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

— clismique
источник

Я думаю, что вы можете удалить пространство между outи !binp.

— Акролит

@daHugLenny Да, я не знал, что ты можешь сделать это. Благодарность!

— clismique

2

CJam , 4 байта

{:!}

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

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

— Мартин Эндер
источник

2

Japt, 3 байта

¡!X

Japt не имеет логического ввода, поэтому input представляет собой массив из 0 и 1. Проверьте это онлайн!

Как это устроено

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

— ETHproductions
источник

2

Сетчатка , 3 байта

%`0

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

Для каждой строки ( %) посчитайте количество 0s.

— Мартин Эндер
источник

2

Python 2, 24 байта (не конкурирующий)

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

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

— Эрик Outgolfer
источник

2

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

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

->a{a.map &:!}

Проверь это:

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

— daniero
источник

Инвертировать логический массив

вход

Выход

правила

Контрольные примеры

05AB1E , 1 байт

Желе , 1 байт

Javascript ES6, 15 байт

Matlab, 4 1 байт

Haskell, 7 байтов

MATL , 1 байт

C, 46 байт, рекурсивная версия

C, 47-байтовая итерационная версия

R, 1 байт

Perl 6 , 4 байта

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

Лабиринт , 9 байт

Mathematica, 7 байтов

Python, 27 25 24 байта

C #, 19 байт

IBM / Lotus Notes Formula, 2 байта

J, 2 байта

Прецедент

Swift 3 (7 байт)

объяснение

Язык программирования Шекспира , 240 байт

JAISBaL , 1 байт

PowerShell, 15 байт

Perl, 7 байт

Брахилог , 7 байт

объяснение

Чеддер, 10 байт

Java, 58 байт

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

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

CJam , 4 байта

Japt, 3 байта

Как это устроено

Сетчатка , 3 байта

Python 2, 24 байта (не конкурирующий)

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