Intro

Ogni anno, Dyalog Ltd. organizza una competizione studentesca. La sfida è scrivere un buon codice APL. Questa è un'edizione linguistica indipendente dal codice golf dell'ottavo problema di quest'anno.

Ho il permesso esplicito di pubblicare questa sfida qui dall'autore originale del concorso. Sentiti libero di verificare seguendo il link fornito e contattando l'autore.

Problema

Dato un elenco booleano *, "disattiva" tutte le verità dopo la prima verità.

Nessuna verità? Nessun problema! Restituisce l'elenco non modificato.

Esempi

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

[] → []

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

* Tutte le tue verità devono essere identiche e tutte le tue falsità devono essere identiche. Questo include l'output.

Python 2 , 35 byte

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

Provalo online! Input e output sono linee di True / False.

Basato sulla soluzione di Dennis . Ridefinisce la variabile Trueda inserire Falsedopo che Trueè stato rilevato un input. In questo modo, eventuali ulteriori input di Trueverranno valutati Falsee stampati come tali.

La ridefinizione è True&=b<1, cioè True = True & (b<1). Quando l'input bè True, allora (b<1)è False (poiché True==1), così Truediventa False.

APL , 2 byte

<\

Valuta la funzione "scansiona usando meno di". Provalo online!

Spiegazione

In APL, l'operatore \(scansione) riduce ciascun prefisso non vuoto di un array da destra utilizzando la funzione fornita. Ad esempio, dato l'array 0 1 0, calcola 0(prefisso di lunghezza 1), 0<1(prefisso di lunghezza 2) e 0<(1<0)(prefisso di lunghezza 2) e inserisce i risultati in un nuovo array; le parentesi si associano a destra. Riducendo da <destra si ottiene 1esattamente quando l'ultimo elemento dell'array è 1e il resto lo è 0, quindi il prefisso corrispondente all'estrema sinistra 1è ridotto a 1e gli altri a 0.

Aceto , 19 17 byte non concorrenti

Nuova versione (17 byte):

Questa nuova versione prende i personaggi uno alla volta e viene eseguita al meglio con l' -Fopzione. Funziona in modo simile, ma non identico alla soluzione precedente:

 >,
Op0
p|1u
,ip^

Vecchia risposta (19 byte):

(Non competitiva perché ho dovuto correggere due bug nell'interprete)

|p1u
iOp<
|!`X
rd!r

Questa è la prima risposta di Aceto che evidenzia cosa può fare relativamente bene, direi. Gli "elenchi" sono flussi di input, con un input per riga, "1" per true e "0" per false, con una stringa vuota che indica la fine dell'elenco.

I programmi Aceto vengono eseguiti su una curva di Hilbert, iniziando in basso a sinistra e terminando in basso a destra. Per prima cosa, noi rleggiamo una stringa, la dpotenziamo e la neghiamo ( !), trasformando le stringhe vuote in Vero, tutto il resto in Falso. Quindi c'è uno specchio orizzontale condizionale ( |): se l'elemento superiore nella pila è vero, rispondi orizzontalmente. Questo succede quando la stringa era vuota. Se facciamo il mirroring, atterriamo sul X, che uccide l'interprete.

Altrimenti, convertiamo la copia rimanente nello stack in un numero iintero e facciamo un altro mirror orizzontale condizionale: Questa volta, poiché 1 è verità e 0 è falsa, rispecchiamo se vediamo il (primo) valore vero. Se non eseguiamo il mirroring (quindi abbiamo visto uno 0) printingiamo ciò che è nello stack (poiché lo stack è vuoto, uno zero) e saltiamo Oall'origine della curva, da dove abbiamo iniziato, avviando di nuovo l'intero processo.

Altrimenti, quando abbiamo visto un 1, ci specchiamo e atterriamo sul u, che inverte la direzione in cui ci muoviamo sulla curva di Hilbert. 1pstampa un 1, e ora continuiamo lo stesso Oche avremmo fatto se avessimo visto uno 0, ma poiché siamo in "modalità inversa", la nostra origine è in basso a destra , quindi saltiamo lì.

Ora rsuoniamo un'altra stringa e la neghiamo. Se la stringa era vuoto, e quindi l'elemento pila superiore è truthy, `sarà non sfuggire il comando successivo ( X), facendoci smesso.

In caso contrario (se la stringa non era vuoto), ci facciamo sfuggire l' Xe ignoriamo. In tal caso, andiamo a sinistra ( <), print 0 (perché lo stack è vuoto) e torniamo indietro a Origin.

Java8, 24 19 byte

Long::highestOneBit

Spero che questo sia legale; Ho avuto l'impressione che l'input / output non debba essere valutato come vero / falso nella lingua. Richiede un input lungo e ne fornisce uno come output, con quelli veri e zero nella falsa rappresentazione binaria. Ad esempio, il binario 00101 è 5 e restituirebbe il binario 00100 che è 4.

Cinque byte grazie a @puhlen

Retina , 6 byte

1>`1
0

Provalo online!

Input è un elenco di 0s (per Falso) e 1s (per Vero).

Abbina tutto 1e sostituisce ciascuno tranne il primo ( 1>) con a 0.

V , 7 byte

f1òf1r0

Provalo online!

La mia prima presentazione V! \ O /

Come funziona

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 byte

Funzione anonima che accetta e restituisce un elenco di messaggi Bool.

Usa come (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

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

Provalo online!

Come funziona

• Piega su un elenco da destra, anteponendo nuovi elementi e possibilmente modificando quelli seguenti.
• xè l'elemento da anteporre all'elenco secondario l.
• Usi che Falseconfrontano meno di True, quindi map(x<)ltrasformeranno qualsiasi Trues lin Falseif xis True.

Gelatina , 4 byte

+\=a

Provalo online!

Ecco un algoritmo piuttosto diverso dalla maggior parte delle altre soluzioni linguistiche di golf (anche se dopo averlo pubblicato, ho notato che anche la soluzione R utilizza questo algoritmo) e legare con l'attuale detentore del record Jelly.

Spiegazione

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

Finché tutti gli elementi a sinistra di un elemento sono 0, la somma cumulativa fino a un elemento sarà uguale all'elemento stesso. A destra del primo 1, i due sono diversi (perché ora stiamo aggiungendo il totale diverso da zero degli elementi a sinistra). Quindi, +\=ci fornisce un elenco contenente 1 (vale a dire vero) fino al primo elemento di verità incluso. Infine, AND logico con l'elenco originale ci darà un 1 solo per il primo elemento di verità.

JavaScript (ES6), 33 26 byte

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

L'I / O è in matrici di 0 e 1 secondi.

05AB1E , 6 byte

Codice:

ā<s1kQ

Spiegazione:

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

Utilizza la codifica 05AB1E . Provalo online!

Simulatore di macchine di Turing , 39 byte

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

Provalo online!

Brainfuck , 55 byte

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

Provalo online!

Gelatina , 4 byte

Una porta della mia risposta 05AB1E.

i1=J

Spiegazione (argomento α ):

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

Provalo online!

R , 24 byte

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

Provalo online!

Esempio:

Per i FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tritorni di input TRUE TRUE FALSE FALSE. La F nella scansione garantisce un input logico.
FALSE TRUE TRUE FALSEed TRUE TRUE FALSE FALSEè FALSE TRUE FALSE FALSE. Un singolo &esegue un confronto elementally.

Ottava, 23 byte

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

Provalo online!

Prima differenza del massimo cumulativo dell'elenco.

J , 3 byte

</\

Definisce un verbo monadico. Questa è una porta banale della mia risposta APL . Provalo online!

Python, 58 byte

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

Se x[i]è falso, l'output è falso; in caso contrario, indica se l'elemento è la prima occorrenza nell'array di se stesso.

PHP, 37 byte

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

Perl 5, 20 byte

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

La verità è 1e la falsità è ''(una stringa vuota).

Spiegazione:

map@_passa in rassegna gli elementi dell'elenco , gli argomenti passano alla subroutine, impostando ciascun elemento su $ _ localmente e restituendo una matrice dei valori restituiti che calcola da ciascun elemento. $_&&!$x++genera $_if $_è falso e !$x++se è vero. (Nota che && è in corto circuito, quindi !$x++non viene eseguito fino a quando non viene raggiunto il primo valore di verità). $x++ritorna 0(che è falso) la prima volta che viene eseguito e quindi aumenta ogni volta (e quindi rimane vero). Il !nega $x++, e quindi ritorna verità la prima volta che viene incontrato e falsa da allora in poi.

Pyth - 9 byte

.e&b!s<Qk

Provalo qui

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

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

Input e output sono un valore booleano ( Vero o Falso ) per riga.

Provalo online!

C #, 77 byte

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

Compila per a Func<bool[], bool[]>. Niente di veramente intelligente, solo una soluzione semplice.

sed , 16 19 byte

15 18 byte codice sorgente + 1 byte per -r flag (o -E flag per BSD sed).

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

Provalo online!

Modifica: Grazie Riley per aver segnalato un errore.

Gelatina , 4 byte

TḊṬ^

Provalo online!

Come?

Questo fa ciò che è stato chiesto in senso piuttosto letterale:

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 (con builtin gcc), 40

Un approccio leggermente diverso:

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

Questo può essere dichiarato non valido, nel qual caso lo contrassegnerò felicemente come non competitivo.

Gli "array" di input e output sono numeri interi senza segno a 32 bit - questo limita la dimensione dell'elenco di input a esattamente 32 - questo può essere un squalificatore. Se l'ingresso ha una lunghezza inferiore a 32 bit, potrebbe essere completato con zero bit alla fine.

Provalo online .

Lotto, 85 73 byte

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

Accetta input come argomenti della riga di comando. Per eample:1.bat 0 1 0 1 0 0 1

Versione precedente

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

Brain-Flak , 230 byte

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

Spiegherò presto ma mia mamma mi ha cucinato delle patate fritte

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

Provalo online!

Ringraziamenti speciali

Un ringraziamento speciale a Wheat Wizard e Riley per avermi aiutato un sacco con il codice!

Python 3, 69 66 64 60 54 53 byte

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

Accetta un array di falses e trues. Questa è una comprensione della lista di falses, tranne se il valore dell'iterazione corrente è trueed è il primo truenell'input.

Questo sembra un po 'lungo (ed è il mio primo lambda), quindi se riesci a trovare un modo per giocare a golf, sarebbe molto apprezzato!

Brain-Flak , 146 144 byte

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

Provalo 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 byte

10 byte codice + 2 per -pl.

$_&&=!$-++

Provalo online!