Sei der Erste 1 (lass nur die erste Wahrheit)


47

Intro

Jedes Jahr veranstaltet Dyalog Ltd. einen Studentenwettbewerb. Die Herausforderung besteht darin, guten APL-Code zu schreiben . Dies ist eine sprachunabhängige 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.


2
Können wir Bitlisten oder andere Darstellungen von Wahrheiten / Falschen Listen verwenden, die in der Sprache unserer Wahl natürlicher sind?
Martin Ender

1
Nun ja, wenn Sie in der Herausforderung von "Wahrhaftigkeit" und "Falschheit" anstatt von "Booleschen", "Richtig" und "Falsch" sprechen. ;)
Martin Ender

1
Mir ist nicht klar, was die Booleschen angeht. Können wir 0/1 verwenden, auch wenn unsere Sprache Wahr / Falsch ist?
7.

1
@xnor Ah, guter Punkt. Ich denke, es wäre fair, die Auswahl der Eingabe zuzulassen, aber die Ausgabe muss übereinstimmen, meinst du nicht auch?
Adám

1
@xnoder ich höre Sie, aber wenn Haskell Zahlen nicht als Boolesche Werte behandeln oder keine Arithmetik für Boolesche Werte ausführen kann, dann ist dies eine echte Einschränkung der Golffähigkeit von Haskell und sollte sich in der Anzahl der Bytes widerspiegeln, indem Konvertierungen oder andere Arbeiten erforderlich werden -Umgebungen. Was halten Sie von der Fußnotenformulierung?
Adám

Antworten:


36

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.


19
Sie können True neu definieren? Dies verdient eine +1, nur weil hax> _>
HyperNeutrino

1
@HyperNeutrino Ja, aber nicht in Python 3. (Das ist in Ordnung, weil die Sprache hier Python 2 ist.)
Brian McCutchon

@ Brian McCutchon Okay, danke. Das ist nur seltsam ...
HyperNeutrino

@HyperNeutrino Es ist wahrscheinlich erwähnenswert, dass Sie tun können True, False = False, True.
Brian McCutchon

1
@HyperNeutrino - nein. Builtins geben weiterhin den "echten" Wert zurück. Es ist nur "True", das Sie eingeben, das sich ändert. (Oder Module, in einigen Fällen ...). Also gibt bool (1) True zurück, aber bool (1) == True gibt False zurück.
TLW

30

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.


Endlich! Ich habe mich gefragt.
Adám

Jetzt können Sie wohl auch mit J antworten, nein?
Adám

@ Adám Ja, in J sind es 3 Bytes: </ \ Jelly hat wahrscheinlich auch eine analoge 2-Byte-Lösung.
Zgarb

Nein, das glaube ich nicht, denn Jelly ist von links nach rechts.
Adám

Sie sollten separate Sprachantworten als separate Beiträge veröffentlichen.
Adám

22

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.

Code Fluss Illustration

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.


2
Herzlichen Glückwunsch zu Ihrer ersten richtigen Herausforderung in Aceto.
Adám

2
Schaut auf Diagramm. Richtig ...
Adám

1
@ Adám Es wird wahrscheinlich nicht helfen (wenn du Aceto nicht kennst), aber ich dachte, es wäre gut, neben dem Text zu sehen, um ihm besser folgen zu können.
L3viathan

15

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


4
Netter Ansatz. Java wird wettbewerbsfähig‽
Adám

3
Wow, JAVA als kompetitive Antwort
Zacharý

Nicht ganz sicher, ob dies für Codegolf-Regeln gültig ist, aber dies könnte durch Verwendung einer Methodenreferenz auf 19 Zeichen verbessert werden: Long::highestOneBitDies ergibt das identische Ergebnis mit einer kürzeren Syntax
puhlen

@ puhlen-Ausdrücke, die anonyme Funktionen auswerten, sind zulässig.
Cyoce

2
@ NathanMerrill Das java.langPaket wird standardmäßig importiert. Aus der Sprachspezifikation "Eine Kompilierungseinheit hat automatisch Zugriff auf alle in ihrem Paket deklarierten Typen und importiert auch automatisch alle öffentlichen Typen, die im vordefinierten Paket java.lang deklariert sind."
JollyJoker

12

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.


Ich kann es jetzt sehen. Sie arbeiten in einem Büro unter einem Betriebssystem. Ein Manager kommt vorbei und schreit Sie an, weil Sie ein ganzes Betriebssystem mit Regex geschrieben haben.
Christopher

10

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

Wie funktioniert das?
Brian McCutchon

@BrianMcCutchon Erläuterung hinzugefügt.
Undichte Nonne

Dies schlägt für eine 1 in der ersten Position fehl :(
nmjcman101

@ nmjcman101 behoben.
Undichte Nonne

Da Sie das Eingabeformat geändert hat , können Sie tauschen r0mit <C-x>denjenigen zu verringern und ein Byte speichern.
nmjcman101

9

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.

9

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.


8

JavaScript (ES6), 33 26 Bytes

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

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


8

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!


1k>sƶ-_ist eine andere, schlimmer. Die liftIdee könnte jedoch Potenzial haben.
Magic Octopus Urn



4

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!


4

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.


@rturnbull leider muss das eingabeformat dem ausgabeformat entsprechen.
MickyT



3

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.



3

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.


Ihre Zweifel waren berechtigt: Sie müssen eine vollständige Funktion (oder ein vollständiges Programm) einreichen. und dies ist nur ein Ausschnitt (daher ungültig ohne das sub{...}).
Dada

2

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']

1
Es scheint , effizienter zu sein , eine Variable zu verwenden und Karte nur über sie normalerweise: m&!~|Z.
FryAmTheEggman


2

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.


2

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.


@ Riley Danke für den Hinweis! Es sieht so aus, als hätte TIO eine andere Version von sed als meine (BSD). Ich kann die Etiketten nicht leer lassen. Gut das zu wissen.
Maxim Mikhaylov

Ja entschuldigung. TIO benutzt GNU sed. Es ist ein Bug-Feature.
Riley

2

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]

2

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 .


2

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

2

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!


2

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!


Können Sie erklären?
Adám

Oh, hoppla, habe die Frage falsch interpretiert.
OldBunny2800

Die Antwort wurde
wiederhergestellt

Sie können ein Byte speichern, indem Sie 0 for 0for.
Zacharý

Es funktioniert für 1if und 1else, richtig? Vielen Dank!
OldBunny2800

2

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

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.