вступление

Ежегодно ООО «Дьялог» проводит студенческий конкурс. Задача состоит в том, чтобы написать хороший код APL. Это не зависящий от языка код-гольф издание восьмой проблемы этого года.

У меня есть явное разрешение опубликовать этот вызов здесь от первоначального автора конкурса. Не стесняйтесь проверить, перейдя по предоставленной ссылке и связавшись с автором.

проблема

Учитывая булевский список *, "выключите" все Истины после первой Истины.

Нет правды? Нет проблем! Просто верните список без изменений.

Примеры

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

* Все ваши правды должны быть идентичны, и все ваши ложные сообщения должны быть идентичны. Это включает в себя вывод.

Python 2 , 35 байт

while 1:b=input();print b;True&=b<1

Попробуйте онлайн! Вход и выход - это линии True / False.

По решению Дениса . Переопределяет переменную, Trueкоторая будет Falseпосле Trueввода. Таким образом, любые последующие материалы Trueбудут оцениваться Falseи печататься как таковые.

Переопределение True&=b<1, то есть True = True & (b<1). Когда входной сигнал bявляется True, то (b<1)это значение False (с True==1), так что Trueстановится False.

APL , 2 байта

<\

Оценивает функцию "сканирование с использованием менее чем". Попробуйте онлайн!

объяснение

В APL оператор \(сканирование) уменьшает каждый непустой префикс массива справа, используя предоставленную функцию. Например, для данного массива 0 1 0он вычисляет 0(префикс длины 1), 0<1(префикс длины 2) и 0<(1<0)(префикс длины 2) и помещает результаты в новый массив; круглые скобки связаны справа. Снижение <справа 1показывает, когда последний элемент массива равен 1остальному 0, а остальные равны , поэтому префикс, соответствующий крайнему левому краю 1, уменьшается до 1остальных 0.

Aceto , 19 17 байт не конкурирует

Новая версия (17 байт):

Эта новая версия принимает символы по одному и лучше всего выполняется с -Fопцией. Он работает аналогично, но не идентично предыдущему решению:

 >,
Op0
p|1u
,ip^

Старый ответ (19 байт):

(Не конкурирует, потому что мне пришлось исправить две ошибки в интерпретаторе)

|p1u
iOp<
|!`X
rd!r

Это первый ответ Aceto, который подчеркивает, на что он способен относительно хорошо, я бы сказал. «Списки» - это входные потоки, с одним вводом на строку, «1» для истины и «0» для «ложь», с пустой строкой, обозначающей конец списка.

Программы Aceto работают по кривой Гильберта, начиная слева внизу и заканчивая справа внизу. Во-первых, мы читаем rстроку, dуточняем и отрицаем ее ( !), превращая пустые строки в True, а все остальное в False. Затем есть условное горизонтальное зеркало ( |): если верхний элемент в стеке верен, зеркально отразите по горизонтали. Это происходит, когда строка была пустой. Если мы делаем зеркалирование, мы приземляемся на того X, который убивает переводчика.

В противном случае мы конвертируем оставшуюся копию в стеке в integer и делаем другое условное горизонтальное зеркало: на этот раз, потому что 1 истинно, а 0 ложно, мы зеркально отображаем, если видим (первое) истинное значение. Если мы не зеркально pотображаем (так что мы увидели 0), мы набираем то, что находится в стеке (поскольку стек пуст, ноль), и переходим к Oначалу кривой, откуда мы начали, снова запуская весь процесс.

В противном случае, когда мы увидели 1, мы отражаемся и приземляемся на u, что меняет направление, в котором мы движемся по кривой Гильберта. 1pпечатает 1, и теперь мы продолжаем то же самое, Oчто и если бы мы видели 0, но, поскольку мы находимся в «обратном режиме», наш источник находится внизу справа , поэтому мы прыгаем туда.

Теперь мы читаем rеще одну строку и отрицаем ее. Если строка была пустой, и, следовательно, верхний элемент стека является правдивым, не` произойдет следующая команда ( ), что заставит нас выйти.X

В противном случае (если строка не была пустой), мы действительно спасаясь от Xи игнорировать его. В этом случае мы идем влево ( <), print 0 (потому что стек пуст) и возвращаемся к Origin.

Java8, 24 19 байт

Long::highestOneBit

Надеюсь, это законно; У меня сложилось впечатление, что ввод / вывод не должен оцениваться как истинный / ложный в языке. Принимает long в качестве входного значения и дает один в качестве выходного, причем единицы имеют значение true, а нули - false в двоичном представлении. Например, двоичный код 00101 равен 5 и возвращает двоичный код 00100, который равен 4.

Пять байтов благодаря @puhlen

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

1>`1
0

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

Ввод - это список 0s (для False) и 1s (для True).

Соответствует всем 1и заменяет все, кроме первого ( 1>), на 0.

V , 7 байт

f1òf1r0

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

Моя первая подача V! \ О /

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

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Haskell , 25 байт

Анонимная функция, принимающая и возвращающая список Bools.

Используйте как (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

foldr(\x l->x:map(x<)l)[]

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

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

• Сворачивает список справа, добавляя новые элементы и, возможно, изменяя следующие.
• xэто элемент, который будет добавлен к подсписку l.
• Пользы , что Falseсопостовительные меньше True, так map(x<)lбудут превратить любого Trueс в lв , Falseесли xесть True.

Желе , 4 байта

+\=a

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

Вот алгоритм, довольно отличающийся от большинства других языковых решений для игры в гольф (хотя после того, как я его опубликовал, я заметил, что решение R также использует этот алгоритм), и привязка к текущему держателю записи Jelly.

объяснение

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

Пока все элементы слева от элемента равны 0, совокупная сумма до элемента будет равна самому элементу. Справа от первого 1 они различаются (потому что теперь мы добавляем ненулевое общее количество элементов слева). Таким образом, +\=дает нам список, содержащий 1 (т. Е. Истина) до и включая первый истинный элемент. Наконец, логическое И с исходным списком даст нам 1 только для первого истинного элемента.

JavaScript (ES6), 33 26 байт

a=>a.map(e=>e&!(i-=e),i=1)

Ввод / вывод находится в массивах 0 и 1.

05AB1E , 6 байтов

Код:

ā<s1kQ

Объяснение:

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

Использует кодировку 05AB1E . Попробуйте онлайн!

Симулятор машины Тьюринга , 39 байт

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

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

Brainfuck , 55 байт

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

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

Желе , 4 байта

Порт моего ответа 05AB1E.

i1=J

Пояснение (аргумент α ):

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

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

R , 24 байта

cumsum(T<-scan(,F))==T&T

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

Пример:

Для ввода FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tвозвращается TRUE TRUE FALSE FALSE. F в скане обеспечивает логический ввод.
FALSE TRUE TRUE FALSEи TRUE TRUE FALSE FALSEесть FALSE TRUE FALSE FALSE. Сингл &делает поэлементное сравнение.

Октава, 23 байта

@(a)diff([0 cummax(a)])

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

Первое отличие совокупного максимума списка.

J , 3 байта

</\

Определяет монадический глагол. Это тривиальный порт моего ответа APL . Попробуйте онлайн!

Python, 58 байт

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

Если x[i]ложь, вывод ложен; в противном случае он определяет, является ли элемент первым вхождением в сам массив.

PHP, 37 байт

foreach($_GET as$v)echo$v*!$$v++,' ';

Perl 5, 20 байт

sub{map$_&&!$x++,@_}

Истина 1и ложь'' (пустая строка).

Объяснение:

mapперебирает элементы списка it @_, аргументы передаются в подпрограмму, устанавливает для каждого элемента значение $ _ локально и возвращает массив возвращаемых значений, которые он вычисляет из каждого элемента. $_&&!$x++выводит, $_если $_это фальсификация и !$x++если это правда. (Обратите внимание, что && имеет короткое замыкание, поэтому !$x++не выполняется, пока не будет достигнуто первое истинное значение). $x++Возвращает 0(что неверно) при первом запуске, а затем увеличивается каждый раз (и поэтому остается правдивым). В !отменяет $x++, и поэтому она возвращает truthy первый раз , когда он встречается и falsey после этого.

Pyth - 9 байт

.e&b!s<Qk

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

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

Python 2 , 45 36 байт

r=0
while 1:n=input();print n>r;r+=n

Вход и выход - один логический ( True или False ) на строку.

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

C #, 77 байт

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

Компилирует в Func<bool[], bool[]>. Ничего умного на самом деле, просто прямое решение.

sed , 16 19 байтов

15 Исходный код 18 байтов + 1 байт для флага -r (или -E для BSD sed).

:
s/1(0*)1/1\10/
t

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

Редактировать: Спасибо Райли за указание на ошибку.

Желе , 4 байта

TḊṬ^

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

Как?

Это делает то, что было задано в буквальном смысле:

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

с (со встроенными gcc), 40

Немного другой подход:

f(n){return!n?0:1<<31-__builtin_clz(n);}

Это может быть признано недействительным - в этом случае я с радостью отмечу это как не конкурирующее.

Входные и выходные «массивы» представляют собой 32-разрядные целые числа без знака - это ограничивает размер списка ввода ровно 32 - это может быть дисквалификатором. Если длина входа меньше 32 бит, то он может быть дополнен нулевыми битами в конце.

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

Пакетная, 85 73 байта

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

Принимает ввод в качестве аргументов командной строки. Для примера:1.bat 0 1 0 1 0 0 1

Предыдущая версия

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

Brain-Flak , 230 байт

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<>({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{}(([])<{{}(({})())({<{}>{}((<()>))}<{}{}>)({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<>([]){{}({}<>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}{}<>

Я скоро объясню, но моя мама приготовила мне немного жареной картошки

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

([]){{}({}<>)<>([])}{}<> Flip stack

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

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

Особая благодарность

Отдельное спасибо Wheat Wizard и Riley за помощь в написании кода!

Python 3, 69 66 64 60 54 53 байта

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

Принимает массив falses и trues. Это список из falses, за исключением случаев, когда значение текущей итерации равно trueпервому trueво входных данных.

Это кажется немного длинным (и это моя первая лямбда), так что, если вы найдете способ поиграть в гольф, это будет с благодарностью!

Brain-Flak , 146 144 байта

([]){{}({}<>)(())<>([])}{}<>((())){{}({}<>)<>}{}<>(()){{}((){[()](<{}>)}{})(<>)<>}<>(())<>([]){{}(<{}<>>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}<>{}

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

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Perl 5 , 12 байт

Код 10 байтов + 2 для -pl.

$_&&=!$-++

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