Wprowadzenie

Każdego roku Dyalog Ltd. organizuje konkurs studencki. Wyzwanie polega na napisaniu dobrego kodu APL. To jest agnostyczna edycja kodu golfa ósmego tegorocznego problemu.

Mam wyraźną zgodę na opublikowanie tutaj tego wyzwania od pierwotnego autora konkursu. Możesz to zweryfikować, klikając podany link i kontaktując się z autorem.

Problem

Biorąc pod uwagę listę logiczną *, „wyłącz” wszystkie Prawdy po pierwszej Prawdzie.

Żadnych prawd? Nie ma problemu! Po prostu zwróć listę bez zmian.

Przykłady

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

[] → []

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

* Wszystkie twoje prawdy muszą być identyczne, a wszystkie twoje kłamstwa muszą być identyczne. Dotyczy to produkcji.

Python 2 , 35 bajtów

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

Wypróbuj online! Dane wejściowe i wyjściowe są wierszami True / False.

Na podstawie rozwiązania Dennisa . Redefiniuje zmienną Truesię Falsepo Truewejście jest spotykane. W ten sposób wszelkie dalsze dane wejściowe Truezostaną ocenione Falsei wydrukowane jako takie.

Redefinicja jest True&=b<1, tzn True = True & (b<1). Gdy dane wejściowe bto True, to (b<1)jest False (od True==1), więc Truestaje się False.

APL , 2 bajty

<\

Zwraca się do funkcji „skanuj za pomocą mniej niż”. Wypróbuj online!

Wyjaśnienie

W APL operator \(skanowanie) redukuje każdy niepusty prefiks tablicy z prawej strony za pomocą dostarczonej funkcji. Na przykład, biorąc pod uwagę tablicę 0 1 0, oblicza 0(prefiks długości 1), 0<1(prefiks długości 2) i 0<(1<0)(prefiks długości 2) i umieszcza wyniki w nowej tablicy; nawiasy są przypisane do prawej. Zmniejszenie o <od prawej powoduje 1dokładnie, kiedy ostatni element tablicy jest, 1a reszta jest 0, więc przedrostek odpowiadający skrajnemu lewemu 1jest zredukowany do, 1a pozostałe do 0.

Aceto , 19 17 bajtów niekonkurujących

Nowa wersja (17 bajtów):

Ta nowa wersja pobiera postacie pojedynczo i najlepiej ją wykonać z -Fopcją. Działa podobnie, ale nie identycznie jak poprzednie rozwiązanie:

 >,
Op0
p|1u
,ip^

Stara odpowiedź (19 bajtów):

(Nie konkuruje, ponieważ musiałem naprawić dwa błędy w tłumaczu)

|p1u
iOp<
|!`X
rd!r

Jest to pierwsza odpowiedź Aceto, która podkreśla, co może zrobić stosunkowo dobrze, powiedziałbym. „Listy” to strumienie wejściowe, z jednym wejściem na linię, „1” dla wartości true i „0” dla wartości false, z pustym ciągiem oznaczającym koniec listy.

Programy Aceto działają na krzywej Hilberta, zaczynając od lewego dolnego rogu, a kończąc na prawym dolnym rogu. Po pierwsze, rwprowadzamy ciąg, dpowielamy i negujemy ( !), zamieniając puste ciągi w True, a wszystko inne w False. Następnie jest warunkowe lustro poziome ( |): Jeśli górny element na stosie jest prawdą, odbij lustro w poziomie. Dzieje się tak, gdy łańcuch jest pusty. Jeśli wykonujemy kopię lustrzaną, lądujemy na X, co zabija tłumacza.

W przeciwnym razie konwertujemy pozostałą kopię na stosie na integer i wykonujemy kolejne warunkowe lustro poziome: Tym razem, ponieważ 1 jest prawdą, a 0 jest fałszem, odbijamy, jeśli widzimy (pierwszą) prawdziwą wartość. Jeśli nie wykonamy lustra (widzieliśmy 0), pprzeszukujemy zawartość stosu (ponieważ stos jest pusty, zero) i przeskakujemy do Osztywności krzywej, gdzie zaczęliśmy, rozpoczynając od nowa cały proces.

W przeciwnym razie, gdy zobaczymy 1, odbijamy lustro i lądujemy na nim u, co odwraca kierunek, w którym poruszamy się po krzywej Hilberta. 1pwypisuje 1, a teraz kontynuujemy to samo, Oco byśmy zrobili, gdybyśmy widzieli 0, ale ponieważ jesteśmy w „trybie odwróconym”, nasze pochodzenie znajduje się w prawym dolnym rogu , więc skaczemy tam.

Teraz mamy rkolejny ciąg i negujemy go. Jeśli łańcuch był pusty, a zatem element najwyższego stosu jest zgodny z prawdą, nie ujdzie następnej komendy ( ), co `spowoduje zamknięcie.X

W przeciwnym wypadku (jeśli łańcuch nie był pusty), my nie uciec Xi zignorować. W takim przypadku przechodzimy do left ( <), print 0 (ponieważ stos jest pusty) i przeskakujemy z powrotem do Origina.

Java8, 24 19 bajtów

Long::highestOneBit

Mam nadzieję, że to jest legalne; Mam wrażenie, że wejście / wyjście nie musi być oceniane w języku jako prawda / fałsz. Trwa długo jako dane wejściowe i daje jedno jako dane wyjściowe, przy czym te są prawdziwe, a zera są fałszywe w reprezentacji binarnej. Na przykład, binarny 00101 ma wartość 5 i zwraca binarny 00100, który ma wartość 4.

Pięć bajtów dzięki @puhlen

Siatkówka , 6 bajtów

1>`1
0

Wypróbuj online!

Dane wejściowe to lista 0s (dla False) i 1s (dla True).

Dopasowuje wszystkie 1i zamienia każde z wyjątkiem pierwszego ( 1>) na 0.

V , 7 bajtów

f1òf1r0

Wypróbuj online!

Moje pierwsze V zgłoszenie! \ o /

Jak to działa

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 bajtów

Anonimowa funkcja przejmująca i zwracająca listę Bools.

Użyj jako (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

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

Wypróbuj online!

Jak to działa

• Składa listę z prawej strony, przygotowując nowe elementy i ewentualnie modyfikując poniższe.
• xjest elementem, który należy dołączyć do listy podrzędnej l.
• Zastosowania, które Falseporównuje mniej niż True, więc map(x<)lokaże żadnych Truesw lna Falserazie xjest True.

Galaretka , 4 bajty

+\=a

Wypróbuj online!

Oto nieco inny algorytm niż większość innych rozwiązań w golfa (chociaż po opublikowaniu go zauważyłem, że rozwiązanie R również używa tego algorytmu) i wiąże się z bieżącym rekordzistą Jelly.

Wyjaśnienie

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

Dopóki wszystkie elementy po lewej stronie elementu mają wartość 0, łączna suma do elementu będzie równa samemu elementowi. Po prawej stronie pierwszego 1 oba są różne (ponieważ teraz dodajemy niezerową sumę elementów po lewej). W ten sposób +\=daje nam listę zawierającą 1 (tj. Prawda) do pierwszego elementu prawdy włącznie. Wreszcie, logiczne I z oryginalnej listy dadzą nam 1 dla tylko pierwszego elementu truthy.

JavaScript (ES6), 33 26 bajtów

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

I / O ma tablice 0 i 1.

05AB1E , 6 bajtów

Kod:

ā<s1kQ

Wyjaśnienie:

ā         # 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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Symulator maszyny Turinga , 39 bajtów

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

Wypróbuj online!

pieprzenie mózgu , 55 bajtów

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

Wypróbuj online!

Galaretka , 4 bajty

Port mojej odpowiedzi 05AB1E.

i1=J

Objaśnienie (argument α ):

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

Wypróbuj online!

R , 24 bajty

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

Wypróbuj online!

Przykład:

Do FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tzwrotów wejściowych TRUE TRUE FALSE FALSE. F w skanie zapewnia logiczne wprowadzanie danych.
FALSE TRUE TRUE FALSEi TRUE TRUE FALSE FALSEjest FALSE TRUE FALSE FALSE. Singiel &dokonuje porównania elementarnego.

Oktawa, 23 bajty

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

Wypróbuj online!

Pierwsza różnica skumulowanego maksimum listy.

J , 3 bajty

</\

Definiuje czasownik monadyczny. To jest trywialny port mojej odpowiedzi APL . Wypróbuj online!

Python, 58 bajtów

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

Jeśli x[i]jest fałszem, wynikiem jest fałsz; w przeciwnym razie określa, czy element jest pierwszym wystąpieniem w tablicy samego siebie.

PHP, 37 bajtów

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

Perl 5, 20 bajtów

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

Prawda jest 1i falsey jest ''(pusty ciąg).

Wyjaśnienie:

mappętle nad elementami listy @_, argumenty przekazywane do podprogramu, ustawiając każdy element lokalnie na $ _ i zwracając tablicę zwracanych wartości, które oblicza z każdego elementu. $_&&!$x++wypisuje, $_jeśli $_jest falsey i !$x++jeśli to jest prawdą. (Zauważ, że && powoduje zwarcie, więc !$x++nie jest wykonywane, dopóki nie zostanie osiągnięta pierwsza prawdziwa wartość). $x++zwraca 0(co jest falsey) przy pierwszym uruchomieniu, a następnie zwiększa za każdym razem (i pozostaje prawdą). W !neguje $x++, a więc zwraca truthy po raz pierwszy jego wykrycia i falsey później.

Pyth - 9 bajtów

.e&b!s<Qk

Wypróbuj tutaj

.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 bajtów

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

Dane wejściowe i wyjściowe mają wartość logiczną ( prawda lub fałsz ) na linię.

Wypróbuj online!

C #, 77 bajtów

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

Kompiluje do Func<bool[], bool[]>. Naprawdę nic sprytnego, tylko proste rozwiązanie.

sed , 16 19 bajtów

15 18 bajtów kod źródłowy + 1 bajt dla flagi -r (lub -E flaga dla BSD sed).

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

Wypróbuj online!

Edycja: Dzięki Riley za wskazanie błędu.

Galaretka , 4 bajty

TḊṬ^

Wypróbuj online!

W jaki sposób?

Robi to, co zostało zadane w dosłownym sensie:

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 (z wbudowanymi gcc), 40

Nieco inne podejście:

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

Można to uznać za nieważne - w takim przypadku z radością oznaczę to jako niekonkurujące.

„Tablice” wejściowe i wyjściowe są 32-bitowymi liczbami całkowitymi bez znaku - ogranicza to rozmiar listy wejściowej do dokładnie 32 - może to być dyskwalifikator. Jeśli sygnał wejściowy ma długość mniejszą niż 32 bity, może być wypełniony zerowymi bitami na końcu.

Wypróbuj online .

Partia, 85 73 bajtów

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

Pobiera dane wejściowe jako argumenty wiersza poleceń. Na przykład:1.bat 0 1 0 1 0 0 1

Poprzednia wersja

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

Brain-Flak , 230 bajtów

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

Wyjaśnię to wkrótce, ale moja mama ugotowała mi smażone ziemniaki

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> 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

Wypróbuj online!

Szczególne podziękowania

Specjalne podziękowania dla Wheat Wizard i Riley za pomoc w tonowaniu kodu!

Python 3, 69 66 64 60 54 53 bajtów

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

Przyjmuje tablicę falses i trues. Jest to zrozumienie listy falses, z wyjątkiem sytuacji, gdy bieżąca iteracja ma wartość truei jest pierwsza truena wejściu.

Wydaje się to trochę długie (i to moja pierwsza lambda), więc jeśli możesz znaleźć sposób na grę w golfa, byłoby to bardzo mile widziane!

Brain-Flak , 146 144 bajtów

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

Wypróbuj online!

# 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 bajtów

Kod 10 bajtów + 2 dla -pl.

$_&&=!$-++

Wypróbuj online!