Intro

Jedes Jahr veranstaltet Dyalog Ltd. einen Studentenwettbewerb. Die Herausforderung besteht darin, guten APL-Code zu schreiben . Dies ist eine sprachunabhängige Code-Golf- Ausgabe des diesjährigen achten Problems.

Ich habe die ausdrückliche Erlaubnis, diese Herausforderung hier vom ursprünglichen Autor des Wettbewerbs zu posten. Sie können dies jederzeit überprüfen, indem Sie dem angegebenen Link folgen und den Autor kontaktieren.

Problem

Schalten Sie bei einer Booleschen * Liste alle Wahrheiten nach der ersten Wahrheit aus.

Keine Wahrheiten? Kein Problem! Senden Sie einfach die Liste unverändert zurück.

Beispiele

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

[] → []

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

* Alle deine Wahrheiten müssen identisch sein, und alle deine Fälschungen müssen identisch sein. Dies schließt die Ausgabe ein.

Python 2 , 35 Bytes

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

Probieren Sie es online! Eingabe und Ausgabe sind Zeilen mit Wahr / Falsch.

Basierend auf Dennis 'Lösung . Definiert die Variable neu True, die Falsenach dem Auftreten einer TrueEingabe vorhanden sein soll. Auf diese Weise werden alle weiteren Eingaben von Trueausgewertet Falseund als solche gedruckt.

Die Neudefinition ist True&=b<1, dh True = True & (b<1). Wenn die Eingabe bist True, dann (b<1)ist False (seit True==1), so Truewird False.

APL , 2 Bytes

<\

Wertet die Funktion "Scannen mit kleiner als" aus. Probieren Sie es online!

Erläuterung

In APL \reduziert der Operator (Scan) jedes nicht leere Präfix eines Arrays mithilfe der bereitgestellten Funktion von rechts. Wenn das Array beispielsweise angegeben wird 0 1 0, berechnet es 0(Präfix der Länge 1), 0<1(Präfix der Länge 2) und 0<(1<0)(Präfix der Länge 2) und fügt die Ergebnisse in ein neues Array ein. Die Klammern stehen rechts. Das Reduzieren von <von rechts ergibt 1genau, wann das letzte Element des Arrays ist 1und wann der Rest ist 0, also wird das Präfix, das ganz links 1steht, auf 1und die anderen auf reduziert 0.

Aceto , 19 17 Bytes nicht konkurrierend

Neue Version (17 Bytes):

Diese neue Version nimmt die Zeichen einzeln auf und wird am besten mit der -FOption ausgeführt. Es funktioniert ähnlich, aber nicht identisch mit der vorherigen Lösung:

 >,
Op0
p|1u
,ip^

Alte Antwort (19 Bytes):

(Nicht konkurrierend, da ich zwei Fehler im Interpreter beheben musste)

|p1u
iOp<
|!`X
rd!r

Dies ist die erste Aceto-Antwort, die zeigt, was sie relativ gut kann, würde ich sagen. Die "Listen" sind Eingabeströme mit einer Eingabe pro Zeile, "1" für "wahr" und "0" für "falsch", wobei eine leere Zeichenfolge das Ende der Liste kennzeichnet.

Aceto-Programme laufen auf einer Hilbert-Kurve, die links unten beginnt und rechts unten endet. Zuerst rlesen wir eine Zeichenkette, dduplizieren sie und negieren sie ( !), indem wir leere Zeichenketten in True umwandeln , alles andere in False. Dann gibt es einen bedingten horizontalen Spiegel ( |): Wenn das oberste Element auf dem Stapel wahr ist, spiegeln Sie es horizontal. Dies passiert, wenn die Zeichenfolge leer war. Wenn wir das Spiegeln machen, landen wir auf dem X, was den Dolmetscher umbringt.

Andernfalls konvertieren wir die verbleibende Kopie auf dem Stapel in eine integer-Zahl und führen eine weitere bedingte horizontale Spiegelung durch: Diesmal spiegeln wir, da 1 wahr und 0 falsch ist, wenn wir den (ersten) wahren Wert sehen. Wenn wir nicht spiegeln (wir haben also eine 0 gesehen), pdrucken wir, was sich auf dem Stapel befindet (da der Stapel leer ist, eine Null) und springen zum ORigin der Kurve, wo wir begonnen haben, und starten den gesamten Prozess erneut.

Wenn wir eine 1 sahen, spiegeln wir und landen auf der u, was die Richtung umkehrt, in die wir uns auf der Hilbert-Kurve bewegen. 1pdruckt eine 1 und jetzt gehen wir auf dasselbe, was Owir gegangen wären, wenn wir eine 0 gesehen hätten, aber da wir uns im "umgekehrten Modus" befinden, ist unser Ursprung unten rechts , also springen wir dorthin.

Jetzt rlesen wir eine andere Zeichenkette und negieren sie. Wenn die Zeichenfolge leer war und daher das oberste Stapelelement wahr ist, `wird der nächste Befehl ( ) nicht ignoriert X, wodurch wir beendet werden.

Andernfalls (wenn die Zeichenfolge nicht leer war), werden wir die maskieren Xund ignorieren. In diesem Fall gehen wir nach links ( <), print 0 (weil der Stapel leer ist) und springen zurück zum Origin.

Java8, 24 19 Bytes

Long::highestOneBit

Hoffe das ist legal; Ich habe den Eindruck, dass die Eingabe / Ausgabe in der Sprache nicht als wahr / falsch bewertet werden muss. Nimmt eine lange als Eingabe und gibt eine als Ausgabe, wobei Einsen wahr und Nullen falsch in der binären Darstellung sind. Zum Beispiel ist die Binärzahl 00101 5 und würde die Binärzahl 00100 zurückgeben, die 4 ist.

Fünf Bytes dank @puhlen

Netzhaut , 6 Bytes

1>`1
0

Probieren Sie es online!

Die Eingabe ist eine Liste von 0s (für False) und 1s (für True).

Stimmt mit allen 1überein und ersetzt sie mit Ausnahme der ersten ( 1>) durch a 0.

V , 7 Bytes

f1òf1r0

Probieren Sie es online!

Meine erste V Einreichung! \O/

Wie es funktioniert

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 Bytes

Anonyme Funktion, die eine Liste von Bools aufnimmt und zurückgibt .

Verwenden Sie als (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

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

Probieren Sie es online!

Wie es funktioniert

• Blendet eine Liste von rechts ein, stellt neue Elemente voran und ändert möglicherweise die folgenden.
• xist das Element, das der Unterliste vorangestellt werden soll l.
• Anwendungen , die Falseweniger als vergleicht True, so map(x<)lwird sich alle Trues in lin , Falsewenn xist True.

Gelee , 4 Bytes

+\=a

Probieren Sie es online!

Hier ist ein anderer Algorithmus als bei den meisten anderen Golf-Sprachlösungen (obwohl ich nach dem Veröffentlichen festgestellt habe, dass die R-Lösung auch diesen Algorithmus verwendet) und mit dem aktuellen Jelly-Rekordhalter verknüpft.

Erläuterung

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

Solange alle Elemente links von einem Element 0 sind, entspricht die kumulative Summe bis zu einem Element dem Element selbst. Rechts von der ersten 1 unterscheiden sich die beiden (da wir jetzt die Summe der Elemente ungleich Null links hinzufügen). So +\=gibt uns eine Liste mit 1 (dh true) bis einschließlich dem ersten truthy Elemente. Schließlich gibt uns das logische UND mit der ursprünglichen Liste eine 1 nur für das erste wahrheitsgemäße Element.

JavaScript (ES6), 33 26 Bytes

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

I / O ist in Arrays von 0s und 1s.

05AB1E , 6 Bytes

Code:

ā<s1kQ

Erläuterung:

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Turing Maschinensimulator , 39 Bytes

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

Probieren Sie es online!

Brainfuck , 55 Bytes

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

Probieren Sie es online!

Gelee , 4 Bytes

Ein Port meiner 05AB1E Antwort.

i1=J

Erklärung (Argument α ):

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

Probieren Sie es online!

R , 24 Bytes

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

Probieren Sie es online!

Beispiel:

Für die Eingabe FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tzurückkehrt TRUE TRUE FALSE FALSE. Das F im Scan stellt die logische Eingabe sicher.
FALSE TRUE TRUE FALSEund TRUE TRUE FALSE FALSEist FALSE TRUE FALSE FALSE. Eine Single &führt einen elementweisen Vergleich durch.

Oktave, 23 Bytes

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

Probieren Sie es online!

Erster Unterschied des kumulativen Maximums der Liste.

J , 3 Bytes

</\

Definiert ein monadisches Verb. Dies ist eine belanglose Portierung meiner APL-Antwort . Probieren Sie es online!

Python, 58 Bytes

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

Wenn x[i]false ist, ist die Ausgabe false. Andernfalls wird angegeben, ob das Element das erste Vorkommen in dem Array von sich selbst ist.

PHP, 37 Bytes

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

Perl 5, 20 Bytes

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

Wahrheit ist 1und Falschheit ist ''(eine leere Zeichenfolge).

Erläuterung:

mapDurchläuft Elemente der Liste @_, die an die Unterroutine übergebenen Argumente, setzt jedes Element lokal auf $ _ und gibt ein Array der Rückgabewerte zurück, die es aus jedem Element berechnet. $_&&!$x++Ausgänge $_wenn $_ist Falsey und !$x++wenn es truthy. (Beachten Sie, dass && kurzgeschlossen !$x++ist und erst ausgeführt wird, wenn der erste Wahrheitswert erreicht ist.) Gibt $x++zurück 0(was falsch ist), wenn es zum ersten Mal ausgeführt wird, und erhöht sich dann jedes Mal (und bleibt somit wahr). Die !negiert $x++, und so kehrt truthy sie das erste Mal auftritt und Falsey danach.

Pyth - 9 Bytes

.e&b!s<Qk

Probieren Sie es hier aus

.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 Bytes

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

Eingabe und Ausgabe sind ein Boolescher Wert ( Wahr oder Falsch ) pro Zeile.

Probieren Sie es online!

C #, 77 Bytes

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

Kompiliert zu a Func<bool[], bool[]>. Eigentlich nichts Schlaues, nur eine einfache Lösung.

sed , 16 bis 19 Bytes

15 18-Byte-Quellcode + 1 Byte für -r Flag (oder -E Flag für BSD sed).

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

Probieren Sie es online!

Edit: Danke Riley für den Hinweis auf einen Fehler.

Gelee , 4 Bytes

TḊṬ^

Probieren Sie es online!

Wie?

Dies tut, was im wahrsten Sinne des Wortes gefragt wurde:

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 (mit eingebauten gcc), 40

Ein etwas anderer Ansatz:

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

Dies kann für ungültig erklärt werden - in diesem Fall werde ich dies gerne als nicht konkurrierend markieren.

Eingabe- und Ausgabe- "Arrays" sind 32-Bit-Ganzzahlen ohne Vorzeichen - dies begrenzt die Größe der Eingabeliste auf genau 32 - dies kann ein Disqualifizierer sein. Wenn der Eingang kürzer als 32 Bit ist, kann er am Ende mit Null-Bits aufgefüllt werden.

Probieren Sie es online aus .

Batch, 85 73 Bytes

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

Übernimmt Eingaben als Befehlszeilenargumente. Zum Beispiel:1.bat 0 1 0 1 0 0 1

Vorherige Version

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

Brain-Flak , 230 Bytes

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

Ich werde es bald erklären, aber meine Mutter hat mir Bratkartoffeln gekocht

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

Probieren Sie es online!

Besonderen Dank

Besonderer Dank geht an Wheat Wizard und Riley, die mir mit Code eine Menge geholfen haben!

Python 3, 69 66 64 60 54 53 Bytes

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

Nimmt eine Reihe von falses und trues. Dies ist ein Listenverständnis von falses, es sei denn, der Wert der aktuellen Iteration ist trueund es ist der erste truein der Eingabe.

Dies scheint ein wenig lang zu sein (und es ist mein erster Lambda). Wenn Sie also einen Weg finden, Golf zu spielen, wären Sie sehr dankbar!

Brain-Flak , 146 144 Bytes

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

Probieren Sie es 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 Bytes

10 Byte Code + 2 für -pl.

$_&&=!$-++

Probieren Sie es online!