Вступ

Щорічно ТОВ «Діялог» проводить конкурс студентів. Завдання полягає в тому, щоб написати хороший код 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.

Ацето , 19 17 байт, що не змагаються

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

Ця нова версія містить символів один за одним і найкраще виконувати за допомогою -Fпараметра. Це працює аналогічно, але не ідентично попередньому рішенню:

 >,
Op0
p|1u
,ip^

Стара відповідь (19 байт):

(Неконкурент, тому що мені довелося виправити дві помилки в перекладачі)

|p1u
iOp<
|!`X
rd!r

Це перша відповідь Ацето, яка підкреслює, що це може зробити порівняно добре. "Списки" - це вхідні потоки з одним входом на рядок, "1" для істинного та "0" для помилкових, з порожнім рядком, що означає кінець списку.

Програми Aceto запускаються на кривій Гільберта, починаючи зліва внизу і закінчуючи внизу праворуч. Спочатку ми нав'язуємо rрядок, dускладнюємо та заперечуємо ( !), перетворюючи порожні рядки в True, а все інше - у False. Тоді є умовне горизонтальне дзеркало ( |): Якщо верхній елемент на стеці є простий, дзеркально горизонтально. Це відбувається, коли рядок був порожнім. Якщо ми робимо дзеркальне відображення, ми приземляємось на той X, що вбиває перекладача.

В іншому випадку ми перетворюємо решту копій на стеку в integer і робимо ще одне умовне горизонтальне дзеркало. Цього разу, оскільки 1 є простім, а 0 - хибним, ми відображаємо, якщо бачимо (перше) справжнє значення. Якщо ми не віддзеркалюємось (тому ми побачили 0), ми показуємо pте, що є на стеку (оскільки стек порожній, нуль) і переходимо до Oригея кривої, з якої ми почали, починаючи весь процес заново.

В іншому випадку, побачивши 1, ми дзеркально і приземляємось на той u, який повертає напрямок, який рухаємо по кривій Гільберта. 1pдрукує 1, і тепер ми продовжуємо те саме, що Oми пішли б, якби бачили 0, але оскільки ми перебуваємо в "зворотному режимі", наше походження знаходиться внизу праворуч , тому ми туди стрибаємо.

Тепер ми rнав'язуємо ще один рядок і заперечуємо його. Якщо рядок був порожнім, а отже, верхній елемент стека є truthy, не` вийде з наступної команди ( ), змусивши нас вийти.X

В іншому випадку (якщо рядок не була порожньою), ми дійсно рятуючись від Xі ігнорувати його. У такому випадку ми переходимо ліворуч ( <), print 0 (тому що стек порожній) та відскакуємо назад до Oріга.

Java8, 24 19 байт

Long::highestOneBit

Сподіваюся, що це законно; У мене склалося враження, що введення / вихід не повинен оцінювати як істинне / хибне в мові. Займає довгий вхід і дає один як вихідний, причому ті є істинними, а нулі - хибними у двійковому поданні. Наприклад, двійковий 00101 дорівнює 5 і повертає бінарний 00100, який дорівнює 4.

П'ять байтів завдяки @puhlen

Сітківка , 6 байт

1>`1
0

Спробуйте в Інтернеті!

Введення - це список 0s (для False) і 1s (для True).

Відповідає всім 1і замінює кожен, крім першого ( 1>), а 0.

V , 7 байт

f1òf1r0

Спробуйте в Інтернеті!

Моє перше подання V! \ o /

Як це працює

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 (тобто істинний), аж до першого елемента truthy. Нарешті, логічний AND з оригінальним списком дасть нам 1 лише для першого елемента.

JavaScript (ES6), 33 26 байт

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

I / O знаходиться в масивах 0s і 1s.

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

Спробуйте в Інтернеті!

мозковий ебать , 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 . Спробуйте в Інтернеті!

Пітон, 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++,@_}

Truthy є 1і falsey є ''(порожня струна).

Пояснення:

mapпетлі над елементами його списку @_, аргументи передаються підпрограмі, встановлюючи кожен елемент на $ _ локально і повертаючи масив повернених значень, які він обчислює з кожного елемента. $_&&!$x++виводить, $_якщо $_є фальси, і !$x++якщо він є правдою. (Зверніть увагу, що && - це коротке замикання, тому !$x++не виконується, поки не буде досягнуто першого значення truthy). $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

Введення та вихід - один логічний ( істинний чи помилковий ) на рядок.

Спробуйте в Інтернеті!

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]

c (з 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

Вводиться як аргументи командного рядка. Для eample: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

Мозок-Флак , 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

Спробуйте в Інтернеті!

Особлива подяка

Особлива вдячність пшеничному майстру та Райлі за те, що вони допомогли мені тонну з кодом!

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на вході.

Це здається трохи довгим (і це моя перша лямбда), тому якщо ви зможете знайти спосіб покататися на ньому, це буде дуже вдячно!

Мозок-Флак , 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.

$_&&=!$-++

Спробуйте в Інтернеті!