Introducción

Cada año, Dyalog Ltd. celebra una competencia estudiantil. El desafío es escribir un buen código APL. Esta es una edición de código de golf agnóstico del octavo problema de este año.

Tengo permiso explícito para publicar este desafío aquí del autor original de la competencia. No dude en verificar siguiendo el enlace proporcionado y contactando al autor.

Problema

Dada una lista booleana *, "apague" todas las Verdades después de la primera Verdad.

No hay verdades? ¡No hay problema! Simplemente devuelva la lista sin modificar.

Ejemplos

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

[] → []

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

* Todas tus verdades deben ser idénticas, y todas tus falsedades deben ser idénticas. Esto incluye salida.

Python 2 , 35 bytes

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

Pruébalo en línea! La entrada y la salida son líneas de verdadero / falso.

Basado en la solución de Dennis . Redefine la variable Trueque será Falsedespués de que Truese encuentre una entrada. De esa manera, cualquier entrada adicional de Truese evaluará Falsee imprimirá como tal.

La redefinición es True&=b<1, es decir True = True & (b<1). Cuando la entrada bes True, entonces (b<1)es False (since True==1), entonces se Trueconvierte en False.

APL , 2 bytes

<\

Evalúa la función "escanear con menos de". Pruébalo en línea!

Explicación

En APL, el operador \(exploración) reduce cada prefijo no vacío de una matriz desde la derecha utilizando la función proporcionada. Por ejemplo, dada la matriz 0 1 0, calcula 0(prefijo de longitud 1), 0<1(prefijo de longitud 2) y 0<(1<0)(prefijo de longitud 2) y coloca los resultados en una nueva matriz; los paréntesis se asocian a la derecha. Reducir <desde la derecha da como resultado 1exactamente cuándo el último elemento de la matriz es 1y el resto son 0, por lo que el prefijo correspondiente al extremo izquierdo 1se reduce a 1y los demás a 0.

Aceto , 19 17 bytes no competitivos

Nueva versión (17 bytes):

Esta nueva versión toma los caracteres de uno en uno y se ejecuta mejor con la -Fopción. Funciona de manera similar, pero no idéntica a la solución anterior:

 >,
Op0
p|1u
,ip^

Respuesta anterior (19 bytes):

(No compite porque tuve que corregir dos errores en el intérprete)

|p1u
iOp<
|!`X
rd!r

Diría que esta es la primera respuesta de Aceto que resalta lo que puede hacer relativamente bien. Las "listas" son flujos de entrada, con una entrada por línea, "1" para verdadero y "0" para falso, con una cadena vacía que significa el final de la lista.

Los programas de Aceto se ejecutan en una curva de Hilbert, comenzando en la parte inferior izquierda y terminando en la parte inferior derecha. Primero, rcolocamos una cadena, la dduplicamos y la negamos ( !), convirtiendo las cadenas vacías en Verdadero, todo lo demás en Falso. Luego hay un espejo horizontal condicional ( |): si el elemento superior de la pila es verdadero, refleje horizontalmente. Esto sucede cuando la cadena estaba vacía. Si hacemos el reflejo, aterrizamos en el X, que mata al intérprete.

De lo contrario, convertimos la copia restante en la pila a un integer y hacemos otro espejo horizontal condicional: esta vez, debido a que 1 es verdadero y 0 es falso, reflejamos si vemos el (primer) valor verdadero. Si no reflejamos (entonces vimos un 0), pdesciframos lo que está en la pila (ya que la pila está vacía, un cero) y Osaltamos al rigin de la curva, donde comenzamos, comenzando todo el proceso nuevamente.

De lo contrario, cuando vimos un 1, reflejamos y aterrizamos en el u, que invierte la dirección en que nos movemos en la curva de Hilbert. 1pimprime un 1, y ahora continuamos de la misma manera Oque hubiéramos ido si hubiéramos visto un 0, pero dado que estamos en "modo inverso", nuestro origen está en la parte inferior derecha , así que saltamos allí.

Ahora rcolocamos otra cuerda y la negamos. Si la cadena estaba vacía, y por lo tanto el elemento de la pila superior es Truthy, `será no escapar el comando siguiente ( X), lo que nos dejamos.

En caso contrario (si la cadena no estaba vacía), que sí escapar del Xe ignorarlo. En ese caso, vamos a la izquierda ( <), print 0 (porque la pila está vacía) y volvemos al Origin.

Java8, 24 19 bytes

Long::highestOneBit

Espero que esto sea legal; Tengo la impresión de que la entrada / salida no tiene que evaluarse como verdadero / falso en el lenguaje. Toma un largo como entrada y da uno como salida, con unos verdaderos y ceros falsos en la representación binaria. Por ejemplo, el binario 00101 es 5 y devolvería el binario 00100 que es 4.

Cinco bytes gracias a @puhlen

Retina , 6 bytes

1>`1
0

Pruébalo en línea!

La entrada es una lista de 0s (para Falso) 1ys (para Verdadero).

Coincide con todos 1y reemplaza cada uno excepto el primero ( 1>) con a 0.

V , 7 bytes

f1òf1r0

Pruébalo en línea!

Mi primera presentación de V! \ o /

Cómo funciona

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

Función anónima que toma y devuelve una lista de Bools.

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

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

Pruébalo en línea!

Cómo funciona

• Se pliega sobre una lista de la derecha, anteponiendo nuevos elementos y posiblemente modificando los siguientes.
• xes el elemento que debe anteponerse a la sublista l.
• Usos que Falsese compara menos True, por lo map(x<)lque convertirá cualquier Trues en len Falsesi xes True.

Jalea , 4 bytes

+\=a

Pruébalo en línea!

Aquí hay un algoritmo bastante diferente a la mayoría de las otras soluciones de lenguaje de golf (aunque después de que lo publiqué, noté que la solución R también usa este algoritmo), y lo relaciono con el actual poseedor del récord Jelly.

Explicación

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

Mientras todos los elementos a la izquierda de un elemento sean 0, la suma acumulativa hasta un elemento será igual al elemento mismo. A la derecha del primer 1, los dos son diferentes (porque ahora estamos agregando el total distinto de cero de los elementos a la izquierda). Por lo tanto, +\=nos da una lista que contiene 1 (es decir, verdadero) e incluye el primer elemento de verdad. Finalmente, lógico Y con la lista original nos dará un 1 solo para el primer elemento de verdad.

JavaScript (ES6), 33 26 bytes

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

I / O está en matrices de 0s y 1s.

05AB1E , 6 bytes

Código:

ā<s1kQ

Explicación:

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

Simulador de máquina de Turing , 39 bytes.

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

Pruébalo en línea!

brainfuck , 55 bytes

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

Pruébalo en línea!

Jalea , 4 bytes

Un puerto de mi respuesta 05AB1E.

i1=J

Explicación (argumento α ):

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

Pruébalo en línea!

R , 24 bytes

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

Pruébalo en línea!

Ejemplo:

Para la entrada FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tdevuelve TRUE TRUE FALSE FALSE. La F en el escaneo asegura la entrada lógica.
FALSE TRUE TRUE FALSEy TRUE TRUE FALSE FALSEes FALSE TRUE FALSE FALSE. Un single &hace una comparación por elementos.

Octava, 23 bytes

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

Pruébalo en línea!

Primera diferencia del máximo acumulativo de la lista.

J , 3 bytes

</\

Define un verbo monádico. Este es un puerto trivial de mi respuesta APL . Pruébalo en línea!

Python, 58 bytes

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

Si x[i]es falso, la salida es falsa; de lo contrario, da si el elemento es o no la primera aparición en la matriz de sí mismo.

PHP, 37 bytes

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

Perl 5, 20 bytes

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

Truthy is 1y falsey is ''(una cadena vacía).

Explicación:

maprecorre los elementos de la lista @_, los argumentos pasados ​​a la subrutina, configurando cada elemento en $ _ localmente y devolviendo una matriz de los valores de retorno que calcula de cada elemento. $_&&!$x++salidas $_si $_es falsey y !$x++si es verdad. (Tenga en cuenta que && está en cortocircuito, por !$x++lo que no se ejecuta hasta que se alcanza el primer valor verdadero). $x++vuelve 0(que es falsey) la primera vez que se ejecuta y luego se incrementa cada vez (y así sigue siendo verdad). Se !niega $x++, por lo que devuelve la verdad la primera vez que se encuentra y se desvanece a partir de entonces.

Pyth - 9 bytes

.e&b!s<Qk

Pruébalo aquí

.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

La entrada y la salida son un booleano ( verdadero o falso ) por línea.

Pruébalo en línea!

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;};

Compila a a Func<bool[], bool[]>. Nada realmente inteligente, solo una solución directa.

sed , 16 19 bytes

15 código fuente de 18 bytes + 1 byte para el indicador -r (o el indicador -E para BSD sed).

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

Pruébalo en línea!

Editar: Gracias Riley por señalar un error.

Jalea , 4 bytes

TḊṬ^

Pruébalo en línea!

¿Cómo?

Esto hace lo que se le pidió en un sentido bastante literal:

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 gcc incorporado), 40

Un enfoque ligeramente diferente:

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

Esto puede considerarse inválido, en cuyo caso lo marcaré felizmente como no competitivo.

Las "matrices" de entrada y salida son enteros sin signo de 32 bits; esto limita el tamaño de la lista de entrada a ser exactamente 32; esto puede ser un descalificador. Si la entrada tiene menos de 32 bits, puede rellenarse con cero bits al final.

Pruébalo en línea .

Lote, 85 73 bytes

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

Toma datos como argumentos de línea de comando. Por ejemplo:1.bat 0 1 0 1 0 0 1

Versión previa

@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

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

Lo explicaré pronto, pero mi mamá me preparó unas papas fritas.

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

Pruébalo en línea!

Gracias especiales

¡Un agradecimiento especial a Wheat Wizard y Riley por ayudarme mucho con el código!

Python 3, 69 66 64 60 54 53 bytes

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

Toma una serie de falsesy trues. Esta es una lista de comprensión de falses excepto si el valor de la iteración actual es truey es el primero trueen la entrada.

Esto parece un poco largo (y es mi primer lambda), así que si puedes encontrar una forma de jugarlo, ¡sería muy apreciado!

Brain-Flak , 146 144 bytes

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

Pruébalo en línea!

# 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

Código de 10 bytes + 2 para -pl.

$_&&=!$-++

Pruébalo en línea!