Introducción y crédito

Hoy sin un preludio elegante: impleméntelo takewhile.

Una variación de esto (en una estructura de datos no trivial) fue una tarea en el curso de programación funcional de mi universidad. Esta tarea ahora está cerrada y se ha discutido en clase y tengo el permiso de mi profesor para publicarla aquí (pregunté explícitamente).

Especificación

Entrada

La entrada será una lista (o el concepto equivalente de su idioma) de enteros positivos.

Salida

El resultado debe ser una lista (o el concepto equivalente de su idioma) de enteros positivos.

¿Qué hacer?

Su tarea es implementar takewhile(se permiten las incorporaciones de lenguaje) con el predicado de que el número en consideración es par (centrarse en taketime).

Por lo tanto, itera sobre la lista de principio a fin y mientras la condición se mantiene, copia a la lista de salida y tan pronto como golpea un elemento que no hace que la condición sea verdadera, aborta la operación y la salida (un ejemplo paso a paso está abajo). Esta funcionalidad de orden superior también se llama takeWhile ( takewhile).

Posibles casos de esquina

El orden de la lista de salida en comparación con la lista de entrada no puede ser cambiado, por ejemplo, [14,42,2]no puede llegar a ser [42,14].

La lista vacía es una entrada y salida válida.

¿Quién gana?

Este es el código de golf, por lo que gana la respuesta más corta en bytes.

Se aplican reglas estándar, por supuesto.

Vectores de prueba

[14, 42, 2324, 97090, 4080622, 171480372] -> [14, 42, 2324, 97090, 4080622, 171480372]
[42, 14, 42, 2324] -> [42, 14, 42, 2324]
[7,14,42] -> []
[] -> []
[171480372, 13, 14, 42] -> [171480372]
[42, 14, 42, 43, 41, 4080622, 171480372] -> [42, 14, 42]

Ejemplo paso a paso

Example Input: [42, 14, 42, 43, 41, 4080622, 171480372]

Consider first element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42]

Consider second element: 14
14 is even (7*2)
Put 14 into output list, output list is now [42,14]

Consider third element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42,14,42]

Consider fourth element: 43
43 is not even (2*21+1)
Drop 43 and return the current output list

return [42,14,42]

Mathematica, 18 bytes

#~TakeWhile~EvenQ&

Otro glorioso incorporado que es derrotado por un factor de 3 por los idiomas de golf sin el ...

Haskell, 13 bytes

fst.span even

spandivide la lista de entrada en un par de listas justo antes del primer elemento donde el predicado (-> even) es falso. fsttoma el primer elemento de la pareja.

Versión alternativa, 13 bytes:

fst.break odd

breakes lo opuesto a span, es decir, divide la lista en el primer elemento donde el predicado es verdadero.

Por supuesto también hay

takeWhile even

Pero eso es 14 bytes.

MATL , 6 bytes

toYs~)

Pruébalo en línea!

Explicación

t    % Input array implicitly. Duplicate
o    % Parity of each entry. Gives 0 for even entries, 1 for odd
Ys   % Cumulative sum
~    % Logical negate. Gives true for the first run of even entries, and then false
)    % Use this as logical index into the original array. Implicitly display

Hexagonía , 19

2.}<@>%?<{>$"/\M!8;

Legible:

  2 . }
 < @ > %
? < { > $
 " / \ M
  ! 8 ;

Pruébalo en línea!

Esto probablemente se puede jugar por un byte o dos, pero eso puede requerir un diseño realmente ingenioso, que se puede encontrar más fácilmente a través de la fuerza bruta (incluso si puede tomar bastante tiempo encontrarlo).

Explicación de alto nivel

El programa sigue principalmente este pseudocódigo:

while (read number is not zero) 
{
    if (number is even) 
        print number;
} 

Lo cual abusa de cómo Hexagony intenta leer un número una vez que STDIN está vacío (devuelve un cero). Muchas gracias a Martin por su ayuda con este enfoque.

Explicación completa

Todavía no he jugado con Mono para obtener el fantástico IDE esotérico de Timwi , ¡así que me he apoyado en Martin para que me proporcione algunas bonitas imágenes útiles!

Primero, un pequeño manual sobre el flujo de control básico en Hexagony. El primer puntero de instrucciones (IP), que es el único utilizado en este programa, comienza en la parte superior izquierda del código fuente hexagonal y comienza a moverse hacia la derecha. Cada vez que la IP abandona el borde del hexágono, mueve side_length - 1filas hacia el centro del hexágono. Como este programa utiliza un hexágono de longitud lateral de tres, la IP siempre se moverá dos filas cuando esto suceda. La única excepción es si se mueve fuera de la fila central, donde se mueve condicionalmente hacia la parte superior o inferior del hexágono, dependiendo del valor del borde de memoria actual.

Ahora un poco sobre condicionales. Los únicos condicionales en Hexagony para el flujo de control son >, <y el borde medio del hexágono. Todos estos siguen una regla constante: si el valor en el borde de la memoria actual es cero o el flujo de control negativo se mueve hacia la izquierda y si es positivo, el control fluye hacia la derecha. Los corchetes mayores y menores que redirigen la IP en ángulos de sesenta grados, mientras que el borde del hexágono controla a qué fila salta la IP.

Hexagony también tiene un modelo de memoria especial, donde todos los datos se almacenan en los bordes de una cuadrícula hexagonal infinita. Este programa solo usa tres aristas: una para almacenar un dos, una para el número actualmente leído y otra para el módulo número dos. Se ve algo así como:

Mod  \ / Input
      |
      2

No voy a explicar cuidadosamente dónde estamos en la memoria en cada punto durante la explicación del programa, así que vuelve aquí si te confundes por dónde estamos en la memoria.

Con todo eso fuera del camino, la explicación real puede comenzar. Primero, llenamos el borde "2" en la memoria con un 2, luego ejecutamos un no-op y movemos el puntero de memoria hacia la derecha ( 2.}).

A continuación, comenzamos el ciclo principal del programa. Leemos el primer número de STDIN y luego tocamos un condicional ( ?<). Si no quedan números en STDIN, esto lee un cero en el borde de la memoria actual, así que giramos a la izquierda en el @, que finaliza el programa. De lo contrario, rebotamos en un espejo, movemos el puntero de memoria hacia atrás y hacia la izquierda, envolvemos el hexágono para calcular el resto de dividir la entrada por 2 y luego presionamos otro condicional ( /"%>).

Si el resto era uno (es decir, el número era impar), giramos a la derecha siguiendo el camino azul de arriba, comenzando ejecutando el no-op nuevamente, luego envolvemos la parte inferior del hexágono, multiplicamos el borde actual por 10 y luego suma ocho, rebota en un par de espejos, haz la misma multiplicación y suma nuevamente, obteniendo 188 en el borde actual, volviendo a la parte superior del hexágono, ejecutando el no-op nuevamente y finalmente terminando el programa ( .8/\8.@). Este resultado complicado fue un feliz accidente, originalmente había escrito una lógica mucho más simple, pero noté que podía eliminarlo a favor del no-op, que pensé que estaba más en el espíritu de Hexagony.

Si el resto era cero, giramos a la izquierda siguiendo el camino rojo, arriba. Esto hace que muevamos el puntero de memoria hacia la izquierda y luego imprimamos el valor allí (el valor de entrada) como un número. El espejo con el que nos encontramos actúa como no operativo debido a la dirección en la que nos estamos moviendo ( ). Como 77 es positivo, nos movemos hacia la parte inferior del hexágono y, debido al trampolín, omitimos la primera instrucción ( ). Luego multiplicamos el borde de la memoria actual por 10 y sumamos 8, obteniendo 778. Luego sacamos este valor mod 256 (10) como un carácter ASCII, que resulta ser una nueva línea. Finalmente, salimos del hexágono y volvemos al primero que anula el 778 con el siguiente valor de entrada.{/! ). Luego tocamos el borde del hexágono, que actúa de manera condicional con un solo resultado, ya que el valor de entrada de antes ya se probó como positivo, por lo que siempre nos movemos hacia la derecha (si te imaginas mirando en la dirección de la IP) . Luego multiplicamos la entrada por 10 y agregamos dos, solo para cambiar la dirección, envolver y sobrescribir el nuevo valor con el valor ascii de la letra mayúscula M, 77. Luego golpeamos algunos espejos y salimos por el borde del medio de el hexágono con un trampolín (2<M\>$!?

Pyth, 13 9 7 bytes

uPWs%R2

¡Créditos a @FryAmTheEggman por 2 bytes (bastante difíciles)!

Explicación:

u       Q    keep applying to input until invariant:
 PW          drop last element if...
   s%R2G     ...any one is odd, G is the argument originally given the value of input

Pruébalo aquí .

Jalea , 5 bytes

Ḃœp⁸Ḣ

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

Ḃœp⁸Ḣ  Main link. Argument: A (array)

Ḃ      Bit; yield 1 for odd integers, 0 for even ones.
   ⁸   Yield A.
 œp    Partition A, splitting at 1's in the bit array.
       This yields a 2D array of runs of even integers.
    Ḣ  Head; extract the first chunk.

Python 2, 43 42 bytes

def f(x):
 while"1'"in`map(bin,x)`:x.pop()

La función modifica su argumento en su lugar .

¡Gracias a @xnor por jugar golf en un byte de una manera realmente inteligente!

Pruébalo en Ideone .

ed, 13

/[13579]$/,$d

Porque los programadores reales usan The Standard Text Editor .

Toma la entrada como un entero en cada línea; salidas en el mismo formato.

Esto simplemente encuentra el primer número impar (número que termina en un dígito impar) y lo elimina de esa línea hasta el final del archivo.

Clojure, 21 bytes

#(take-while even? %)

¡Clojure está casi compitiendo por fin! (gracias a que la tarea está integrada) Véalo en línea https://ideone.com/BEKmez

Python, 45 44 bytes

f=lambda x:x and~x[0]%2*x and x[:1]+f(x[1:])

Pruébalo en Ideone .

R, 25 bytes

x=scan()
x[!cumsum(x%%2)]

O equivalente

(y=scan())[!cumsum(y%%2)]

05AB1E, 8 7 bytes

[DÉO_#¨

Explicación

[        # infinite loop start
 DÉO     # count odd numbers
    _    # push negative bool (turning 0->1, X->0)
     #   # if true (no odd numbers exist), break out of loop and implicitly print
      ¨  # else, remove last element from list

Pruébalo en línea

Solución anterior de 8 bytes

vyÈiyˆëq

Explicación

v         # for each y in input
 yÈi      # if y is even
    yˆ    # push y to global array
      ëq  # else terminate program
          # implicitly print global array

Pruébalo en línea

Brainf ***, 263 bytes

Tomé un pequeño fragmento de aquí

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

Daría una explicación, pero ni siquiera tengo idea de cómo funciona esto.

Espera entradas como números separados por espacios (p 2 432 1. Ej. )

Pyth, 7 bytes

<x%R2Q1

Pruébalo aquí!

Lo que intenté hacer en Pyke pero el índice está roto en ese cajero automático

Raqueta, 22 bytes

(λ(n)(takef n even?))

El λcarácter se cuenta como 2 bytes.

No he visto Racket usado antes en ninguna de las respuestas de golf de código que he visto, ¡así que tuve que hacerlo al menos una vez!

Laberinto , 14 bytes

?:
"`#
"@%
\!;

La entrada y la salida son listas separadas por salto de línea (aunque en principio, la entrada podría usar cualquier separador sin dígitos).

Pruébalo en línea!

Este es probablemente el programa Labyrinth más compacto que he escrito.

Curiosamente, takewhile(odd)es mucho más simple:

?:#
" %
\!/

Explicación

La cartilla de laberinto habitual:

• El modelo de memoria es una pila (en realidad hay dos, pero solo necesitaremos uno para este programa), que contiene enteros de precisión arbitraria e inicialmente contiene un número infinito (implícito) de ceros.
• No hay instrucciones de control de flujo. En cambio, el movimiento del puntero de instrucción (IP) está determinado por el diseño del código (los espacios se consideran "muros" y no pueden ser atravesados ​​por la IP). Los corredores despejados suelen ser increíblemente difíciles de trabajar, ya que cada comando actuaría como un cruce. El hecho de que esto funcionó en este caso es un milagro.Normalmente , se supone que el código se asemeja a un laberinto, donde la IP sigue corredores y curvas rectas, pero cada vez que llega a un cruce, esto actúa como un condicional donde la nueva dirección de la IP se determina en función del estado actual. Las reglas para elegir una dirección se reducen a esto: si la parte superior de la pila es cero, la IP sigue avanzando; si la parte superior es positiva, la IP gira a la derecha; Si la parte superior es negativa, la IP gira a la izquierda. Si una de estas direcciones está bloqueada por un muro, la IP toma la dirección opuesta. Esto significa que los programas sin
• La IP comienza en el primer carácter no espacial en el orden de lectura ( ?en este caso), hacia el este.

El flujo principal a través del programa es un bucle único alrededor del perímetro:

>v
^>v
^@v
^<<

De hecho, sabemos que la parte superior de la pila es cero después !y, "por lo tanto, se garantiza que la IP no gire hacia el centro. `y, %por otro lado, se usan como condicionales donde la IP podría moverse hacia el centro de manera que @finalice el programa, o podría seguir moviéndose alrededor del perímetro.

Veamos el código en el bucle:

?   Read decimal integer N from STDIN, or 0 at EOF.
:   Duplicate. Since this is just a corner, the IP always turns south.
`   Negate the copy of the input (i.e. multiply by 1). At EOF, the result
    is still zero and the IP keeps moving south into the @. Otherwise, the
    top of the stack is now negative, and the IP turns east.
#   Push the stack depth (i.e. 2). Again, this is a corner, and the IP
    is forced to turn south.
%   Computer (-N % 2), which is identical to (N % 2) to determine the
    parity of the input. If input was odd, this gives 1, and the IP turns
    west into the @. Otherwise, the result is 0 and the IP keeps moving
    south, continuing the loop.
;   Discard the 0. This is a corner, so the IP is forced to turn west.
!   Print (and discard) N. The top of the stack is now one of the implicit
    zeros at the bottom, so the IP keeps moving west.
\   Print a linefeed. The IP is forced to turn north in the corner.
""  Two no-ops. The top of the stack is still zero, so the IP keeps moving north.

Y luego el ciclo comienza de nuevo.

Eso plantea la pregunta de por qué takewhile(odd)es mucho más simple. Hay dos razones:

• Dado que EOF se devuelve como 0(que es par), no necesitamos una verificación EOF por separado. La lista se cortaría en ese punto de todos modos.
• Ahora queremos terminar cuando N % 2es 0(en lugar de 1), lo que significa que, en lugar del flujo de control condicional, simplemente podemos dividir la otra copia Npor N % 2: si la entrada es impar, eso simplemente se va Ne incluso nos deshacemos del N % 2(así que no ' t need ;), pero si la entrada es par, eso simplemente termina el programa con un error (silencioso) de división por cero.

Por lo tanto, el otro código es un bucle simple que no permite ninguna ramificación en absoluto.

Brachylog , 19 16 bytes

hH: 2% 0,? b & ~ b.hH; [].

s.:Mc?,.:{:2%0}a

Explicación

s.                 Output is an ordered subset of Input
  :Mc?,            The concatenation of Output with a list M is Input
       .:{:2%0}a   All elements of Output are even

Hoy aprendí un buen truco (que se utilizó en la respuesta de 19 bytes): ~b.hHes más corto que :[H]rc.agregar un elemento al comienzo de una lista. El primero significa "Salida es el resultado con un elemento adicional al principio, y el primer elemento de la Salida es H" , mientras que el otro es directamente "Salida es la concatenación de [[H], Result]".

J, 10 bytes

{.~2&|i.1:

Explicación

{.~2&|i.1:  Input: s
   2&|      Take each value in s mod 2
      i.1:  Find the index of the first 1
{.~         Take that many values from s and return

Python, 41 bytes

lambda l:l[:[x%2for x in l+[1]].index(1)]

Trunca lhasta el índice de la primera aparición de un número impar. El índice se encuentra buscando a 1en el módulo de valores 2. Para evitar que no se encuentre ningún número impar, 1se coloca un al final.

C #, 50 bytes

int[]f(int[]a)=>(a.TakeWhile(x=>x%2<1).ToArray());

CJam , 11 bytes

¡Gracias a @Dennis por dos correcciones y un byte de descuento!

{1+_2f%1#<}

Este es un bloque de código (equivalente a una función; permitido por defecto) que espera la matriz de entrada en la pila y deja la matriz de salida en la pila.

Pruébalo en línea!

Explicación

{         }    e# define code block
 1+            e# attach 1 at the end of the array
   _           e# duplicate
    2f%        e# modulo 2 of each entry
       1#      e# find index of first occurrence of 1
         <     e# slice before

Retina , 17 bytes

 ?\d*[13579]\b.*

El avance de línea final es significativo. La entrada y la salida son listas separadas por espacios.

Pruébalo en línea!

Esta es una simple sustitución de expresiones regulares, coincide con el primer número impar (es decir, un número que termina en un dígito impar) y, si es posible, el espacio que lo precede, así como todo lo que está después, y lo reemplaza con una cadena vacía, es decir, todos los elementos de allí en adelante se eliminan de la entrada.

Como señala Leaky Nun, tomando la lista en binario, podemos guardar 6 bytes, pero parece un poco engañoso, por lo que probablemente continuaré contando la versión decimal:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 bytes

a=>[for(x of a)if(!(a|=x&1))x]

V , 13 bytes

íä*[13579]¾.*

Pruébalo en línea!

Explicación:

í              "search for, on every line
 ä*            "Any number of digits
   [13579]     "Followed by an odd digit
          ¾    "Then the end of a word,
           .*  "Followed by anything
               "(implicit) and replace it with nothing.

Convenientemente, el mismo código funciona para verificar todos los casos de prueba simultáneamente.

Dyalog APL , 11 bytes

{⍵/⍨∧\~2|⍵}

2| división resto de dividir con 2

~ negar

∧\ AND-scan (se apaga desde el primer 0)

/⍨ seleccione donde

Rubí, 25 bytes

->a{a.take_while &:even?}

Creo que pierdo ...

Pyke, 8 bytes

0+2L%fhO

Intérprete arreglado, use otros enlaces

Utiliza el método de Dennis, excepto que mi función split_at incluye el cambio, probablemente un error

O con corrección de errores, 7 bytes

2L%1R@<

Pruébalo aquí!

2L%     -   map(%2, input)
   1R@  -  ^.index(1)
      < - input[:^]

O después de la segunda corrección de errores, 6 bytes

2L%fhO

Pruébalo aquí!

Explicación:

2L%    -   map(%2, input)
   f   -  split_at(input, ^)
    hO - ^[0][:-1]

GolfScript, 11 bytes

Este es un programa completo de GolfScript que lee un literal de matriz de GolfScript en cadena (p [28 14 7 0]. Ej. ) E imprime la misma matriz con el primer elemento impar y todo lo demás después de eliminarlo:

~1\{~&.},p;

Pruébalo en línea. (También: versión extendida con arnés de prueba ) .

Versión de golf con comentarios:

~     # evaluate input
1\    # push the number 1 onto the stack and move it under then input array
{     # start of loop body
  ~   #  bitwise negate the input number (making odd numbers even and vice versa)
  &   #  take bitwise AND of input and the saved number (0 or 1) on stack 
  .   #  duplicate result; filter loop will pop off the duplicate
},    # run loop above over input array, select elements for which it returns true
p     # stringify and print filtered array
;     # pop the number 0/1 off the stack

Esta solución se basa en el { },operador de filtro GolfScript , que ejecuta el contenido del bloque de código en cada elemento de una matriz y selecciona los elementos de la matriz para los cuales el código del bloque devuelve un valor verdadero (es decir, distinto de cero) en parte superior de la pila.

Así, por ejemplo, {1&},seleccionaría todos los números impares en una matriz y {~1&},seleccionaría todos los números pares. El desafío, entonces, es hacer un filtro que seleccione números pares hasta que encuentre el primero impar , y luego no seleccione ningún número.

La solución que utilicé es reemplazar la máscara de bits constante 1(utilizada para extraer el bit más bajo de cada número de entrada) con una variable en la pila que almacena el resultado (0 o 1) de la iteración del bucle de filtro anterior (y se inicializa en 1 antes del bucle). Por lo tanto, tan pronto como el filtro devuelve 0 una vez, la máscara de bits también se establece en 0, evitando que el filtro vuelva a devolver 1 nuevamente.

Adelante, 114 bytes

Forth realmente no tiene listas. Los parámetros deben insertarse en la pila en orden inverso, como es típico en Forth. El resultado se dejará en la pila en el mismo orden. Esto no funciona en Ideone por alguna razón, pero funciona en repl. ¿Se requiere la nueva línea para eliminar la ambigüedad de algún tipo?

: D DEPTH ;
: f D IF 1 D 1 DO D 1- ROLL LOOP D 0 DO I PICK 2 MOD IF D I LEAVE THEN LOOP
DO I ROLL DROP LOOP THEN ;

Pruébalo en línea

Sin golf, con comentarios:

: f DEPTH IF                                ( if stack not empty )
        1 DEPTH 1 DO DEPTH 1- ROLL LOOP     ( put 1 on bottom of stack )
        DEPTH 0 DO                          ( loop over entire stack )
            I PICK 2 MOD IF                 ( if stack[i] is odd )
                DEPTH I LEAVE               ( put range and exit loop )
            THEN
        LOOP
        DO I ROLL                           ( roll eyes )
            DROP
        LOOP                                ( iterate that range and remove )
    THEN
;

Este programa (mi intento anterior) imprime los resultados hasta que alcanza un número impar. Todo lo que quede (no tomado) se dejará en la pila.

: f DEPTH IF BEGIN DUP 2 MOD DUP 1- IF SWAP . THEN UNTIL THEN ;

Falla si solo son enteros

Befunge, 35 Bytes

Este código maneja números entre 0 y 65535

1&:v
v-1_@#:@#<
>\:&:2%|
 \+1p4\< ^

Formato de entrada:

number_of_values    values(separated by a space)

Aquí hay una versión que muestra los valores al final del proceso:

1&:v>::   v                >00g1+:4g.v
v-1_^#:>#<>$$\$1-:10p000p0-| -g01p00:<
>\:&:2%|                   @
 \+1p4\< ^

Puede probar el código aquí , pero tendrá que agregar una línea final con espacios finales, ya que esta interpretación especifica:

«El código toro es tan grande como el programa inicial. Inserte más líneas o espacio final si los datos se colocarán más allá del final del código ».

No sé si esto es aceptable, ya que no conté esto al final en el byte count
nb: parece que debido a que estoy almacenando el número en el código, el intérprete no permitirá que este programa se ejecute dos veces en el correcto camino. Tendrás que volver a cargarlo.

Cómo funciona esto: el intérprete sigue las flechas y omite una instrucción al cruzar '#'

Los puntos grises son prueba, y la línea roja elimina las variables innecesarias de la pila

Usando el aquí en el intérprete anterior, los valores guardados se muestran en el código usando sus representaciones (no sé el formato). Sí, Befunge es un lenguaje bastante reflexivo.