Sé el primero 1 (deja solo la primera verdad)

47

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

Adán
fuente
2
¿Podemos usar listas de bits u otras representaciones de listas de verdad / falsedad que sean más naturales en nuestro idioma de elección?
Martin Ender
1
Bueno, sí, si hablas de "veracidad" y "falsedad" en el desafío en lugar de "booleanos", "verdadero" y "falso". ;)
Martin Ender
1
No estoy claro sobre los booleanos. ¿Podemos usar 0/1 incluso si nuestro idioma tiene verdadero / falso?
xnor
1
@xnor Ah, buen punto. Creo que sería justo permitir elegir la entrada, pero la salida debe coincidir, ¿no crees?
Adám
1
@xnor Te escucho, pero si Haskell no puede tratar los números como booleanos, o no puede hacer aritmética en booleanos, entonces esa es una limitación real en el poder de golf de Haskell, y debería reflejarse en el recuento de bytes al requerir conversiones u otro trabajo vueltas ¿Qué opinas de la formulación de la nota al pie?
Adám

Respuestas:

36

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.

xnor
fuente
19
Puedes redefinir True ??? Esto merece un +1 solo porque hax> _>
HyperNeutrino
1
@HyperNeutrino Sí, pero no en Python 3. (Lo cual está bien porque el lenguaje aquí es Python 2.)
Brian McCutchon
@BrianMcCutchon Ok, gracias. Sin embargo, eso es extraño ...
HyperNeutrino
@HyperNeutrino Probablemente valga la pena mencionar que puedes hacerlo True, False = False, True.
Brian McCutchon,
1
@HyperNeutrino - no. Las incorporaciones aún devuelven el valor 'real', es solo 'Verdadero' que escriba los cambios. (O módulos, en algunos casos ...). Entonces bool (1) devuelve True, pero bool (1) == True devuelve False.
TLW
30

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.

Zgarb
fuente
¡Finalmente! Me he estado preguntando.
Adám
Ahora supongo que también puedes responder en J, ¿no?
Adám
@ Adám Sí, en J son 3 bytes: </ \ Jelly probablemente también tenga una solución análoga de 2 bytes.
Zgarb
No, no lo creo, porque Jelly es de izquierda a derecha.
Adám
Debe publicar respuestas de idiomas separadas como publicaciones separadas.
Adám
22

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.

ilustración de flujo de código

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 escapar del Xe ignorarlo. En ese caso, vamos a la izquierda ( <), print 0 (porque la pila está vacía) y volvemos al Origin.

L3viatán
fuente
2
Felicitaciones por su primer desafío adecuado resuelto en Aceto.
Adám
2
Mira el diagrama. Correcto ...
Adám
1
@ Adám Probablemente no ayudará (si no conoce Aceto) por sí solo, pero pensé que sería bueno ver junto al texto para poder seguirlo mejor.
L3viathan
15

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

Bromista alegre
fuente
44
Buen enfoque. Java siendo competitivo‽
Adám
3
Wow, JAVA como respuesta competitiva‽
Zacharý
No del todo seguro si esto es válido para las reglas codegolf, pero esto se podría mejorar a 19 caracteres mediante el uso de una referencia método: Long::highestOneBitque produce el resultado idéntico con una sintaxis más corta
puhlen
Las expresiones @puhlen que evalúan funciones anónimas están permitidas.
Cyoce
2
@NathanMerrill El java.langpaquete se importa de forma predeterminada. De la especificación de idioma "Una unidad de compilación tiene acceso automáticamente a todos los tipos declarados en su paquete y también importa automáticamente todos los tipos públicos declarados en el paquete predefinido java.lang".
JollyJoker
12

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.

Martin Ender
fuente
Puedo verlo ahora. Estás trabajando en una oficina en algún sistema operativo. Un gerente se acerca y te grita por escribir un sistema operativo completo con expresiones regulares.
Christopher
10

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
Monja permeable
fuente
¿Como funciona esto?
Brian McCutchon,
@BrianMcCutchon Explicación agregada.
Leaky Nun
Esto falla para un 1 en la primera posición :(
nmjcman101
@ nmjcman101 fijo.
Leaky Nun
Dado que ha cambiado el formato de entrada, puede intercambiar r0con <C-x>para disminuir los y guardar un byte.
nmjcman101
9

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.
Ørjan Johansen
fuente
9

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.


fuente
8

JavaScript (ES6), 33 26 bytes

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

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

Neil
fuente
8

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!

Adnan
fuente
1k>sƶ-_es otra, peor sin embargo. Sin liftembargo, la idea puede tener potencial.
Magic Octopus Urn
4

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!

Adnan
fuente
4

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.

MickyT
fuente
@rturnbull desafortunadamente el formato de entrada tiene que ser el mismo que el de salida.
MickyT
4

Octava, 23 bytes

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

Pruébalo en línea!

Primera diferencia del máximo acumulativo de la lista.

rahnema1
fuente
3

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.

Hiperneutrino
fuente
3

PHP, 37 bytes

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

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.

Chris
fuente
Sus dudas estaban justificadas: debe presentar una función completa (o un programa completo); y este es solo un fragmento (por lo tanto, no válido sin el sub{...}).
Dada
2

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']
Maria
fuente
1
Parece que es más eficaz utilizar una variable y justo situar sobre ella normalmente: m&!~|Z.
FryAmTheEggman
2

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!

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

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

TheLethalCoder
fuente
2

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.

Maxim Mikhaylov
fuente
@Riley ¡Gracias por señalar eso! Parece que TIO tiene una versión de sed que es diferente de la mía (BSD). No puedo dejar las etiquetas vacías. Es bueno saber esto.
Maxim Mikhaylov
Si lo siento TIO utiliza GNU sed. Es una característica convertida en error.
Riley
2

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]
Jonathan Allan
fuente
2

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 .

Trauma digital
fuente
2

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
Andrei Odegov
fuente
2

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!

Christopher
fuente
2

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!

OldBunny2800
fuente
¿Puedes explicar?
Adám
Oh, vaya, interpreté mal la pregunta.
OldBunny2800
Undeleted y arregló la respuesta
OldBunny2800
Puede guardar un byte haciendo 0 for 0for.
Zacharý
Funciona para 1if y 1else, ¿verdad? ¡Gracias!
OldBunny2800
2

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