Introduzione e credito

Oggi senza un preludio di fantasia: si prega di attuare takewhile.

Una variazione di questo (su una struttura di dati non banale) era un incarico nel mio corso di programmazione funzionale universitaria. Questo compito è ora chiuso ed è stato discusso in classe e ho il permesso del mio professore di pubblicarlo qui (ho chiesto esplicitamente).

specificazione

Ingresso

L'input sarà un elenco (o il concetto equivalente della tua lingua) di numeri interi positivi.

Produzione

L'output dovrebbe essere un elenco (o il concetto equivalente della tua lingua) di numeri interi positivi.

Cosa fare?

Il tuo compito è quello di implementare takewhile(sono ammessi gli insiemi di lingue) con il predicato che il numero in esame è pari (per concentrarti sul tempo necessario).

Quindi iterate l'elenco dall'inizio alla fine e mentre la condizione (è pari) rimane, copiate nella lista di output e non appena colpite un elemento che non rende la condizione vera, interrompete l'operazione e l'output (un esempio dettagliato è di seguito). Questa funzionalità di ordine superiore è anche chiamata takeWhile ( takewhile).

Casi d'angolo potenziali

L'ordine dell'elenco di output rispetto all'elenco di input potrebbe non essere modificato, ad esempio [14,42,2]potrebbe non esserlo [42,14].

L'elenco vuoto è un input e un output validi.

Chi vince?

Questo è code-golf quindi vince la risposta più breve in byte!

Ovviamente si applicano le regole standard.

Test vettori

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

Esempio passo-passo

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 byte

#~TakeWhile~EvenQ&

Un altro glorioso built-in che è battuto da un fattore 3 da golf lingue senza il built-in ...

Haskell, 13 byte

fst.span even

spandivide l'elenco di input in una coppia di elenchi appena prima del primo elemento in cui il predicato (-> even) è falso. fstprende il primo elemento della coppia.

Versione alternativa, 13 byte:

fst.break odd

breakè l'opposto di span, cioè divide la lista nel primo elemento dove il predicato è vero.

Certo che c'è anche

takeWhile even

ma sono 14 byte.

MATL , 6 byte

toYs~)

Provalo online!

Spiegazione

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

Esagonia , 19

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

Leggibile:

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

Provalo online!

Probabilmente questo può essere golfato da un byte o due, ma ciò potrebbe richiedere un layout davvero ingegnoso, che potrebbe essere più facilmente trovato tramite la forza bruta (anche se potrebbe richiedere piuttosto tempo per trovarlo).

Spiegazione di alto livello

Il programma segue principalmente questo pseudocodice:

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

Ciò abusa del modo in cui Hexagony tenta di leggere un numero quando STDIN è vuoto (restituisce uno zero). Un grande ringraziamento a Martin per l'aiuto nel trovare questo approccio.

Spiegazione completa

Non ho ancora armeggiato con Mono per far funzionare il fantastico IDE esoterico di Timwi , quindi mi sono appoggiato a Martin per fornirmi alcune belle immagini utili!

Innanzitutto, un piccolo primer sul flusso di controllo di base in Hexagony. Il primo puntatore di istruzione (IP), che è l'unico utilizzato in questo programma, inizia nella parte superiore sinistra del codice sorgente esagonale e inizia a spostarsi verso destra. Ogni volta che l'IP lascia il bordo dell'esagono, sposta le side_length - 1file verso il centro dell'esagono. Poiché questo programma utilizza un esagono di lunghezza laterale di tre, l'IP si sposterà sempre di due file quando ciò accade. L'unica eccezione è se si sposta al di fuori della riga centrale, dove si sposta in modo condizionale verso la parte superiore o inferiore dell'esagono, a seconda del valore del bordo di memoria corrente.

Ora un po 'di condizionali. Gli unici condizionali in Hexagony di flusso di controllo sono >, <e il bordo centrale dell'esagono. Tutti seguono una regola costante: se il valore sul bordo di memoria corrente è zero o il flusso di controllo negativo si sposta a sinistra e se è positivo, il controllo scorre a destra. Le parentesi maggiore di e minore di reindirizzano l'IP ad angoli di sessanta gradi, mentre il bordo dell'esagono controlla a quale riga salta l'IP.

Hexagony ha anche un modello di memoria speciale, in cui tutti i dati sono memorizzati sui bordi di una griglia esagonale infinita. Questo programma utilizza solo tre bordi: uno per memorizzare due, uno per il numero attualmente letto e uno per il numero modulo due. Sembra qualcosa del tipo:

Mod  \ / Input
      |
      2

Non spiegherò attentamente dove siamo in memoria in ogni punto durante la spiegazione del programma, quindi torna qui se rimani confuso da dove siamo in memoria.

Con tutto ciò fuori mano, la vera spiegazione può iniziare. Innanzitutto, popoliamo il bordo "2" in memoria con un 2, quindi eseguiamo un no-op e spostiamo il puntatore della memoria verso destra ( 2.}).

Successivamente, iniziamo il ciclo principale del programma. Leggiamo il primo numero da STDIN e quindi colpiamo un condizionale ( ?<). Se non ci sono numeri rimasti in STDIN, questo legge uno zero nel bordo di memoria corrente, quindi giriamo a sinistra su @, che termina il programma. Altrimenti, rimbalziamo da uno specchio, spostiamo il puntatore della memoria all'indietro ea sinistra, avvolgiamo l'esagono per calcolare il resto della divisione dell'input per 2 e quindi colpiamo un altro condizionale ( /"%>).

Se il resto era uno (cioè il numero era dispari), giriamo a destra seguendo il percorso blu sopra iniziando eseguendo di nuovo la no-op, quindi ci spostiamo sul fondo dell'esagono, moltiplichiamo il bordo corrente per 10 e quindi aggiungiamo otto, rimbalzare su un paio di specchi, fare di nuovo la stessa moltiplicazione e aggiunta, rimettendo 188 sul bordo corrente, avvolgendosi nuovamente in cima all'esagono, eseguendo di nuovo la no-op e infine terminando il programma ( .8/\8.@). Questo contorto risultato fu un felice incidente, inizialmente avevo scritto un po 'di logica molto più semplice, ma notai che avrei potuto rimuoverlo a favore della no-op, che pensavo fosse più nello spirito di Hexagony.

Se il resto era zero, giriamo invece a sinistra seguendo il percorso rosso, sopra. Questo ci induce a spostare il puntatore della memoria verso sinistra, quindi a stampare lì il valore (il valore di input) come numero. Lo specchio che incontriamo funge da no-op a causa della direzione in cui ci stiamo muovendo ( {/!). Quindi colpiamo il bordo dell'esagono che agisce in modo condizionale con un solo risultato, poiché il valore di input di prima era già testato per essere positivo, quindi ci muoviamo sempre verso destra (se immagini di essere rivolto nella direzione dell'IP) . Quindi moltiplichiamo l'input per 10 e ne aggiungiamo due, solo per cambiare direzione, avvolgiamo e sovrascriviamo il nuovo valore con il valore ascii della lettera maiuscola M, 77. Quindi colpiamo alcuni specchi e usciamo dal bordo del centro di l'esagono con un trampolino (2<M\>$). Poiché 77 è positivo, ci spostiamo a destra verso il fondo dell'esagono e, a causa del trampolino, saltiamo la prima istruzione ( !). Quindi moltiplichiamo il bordo di memoria corrente per 10 e aggiungiamo 8, ottenendo 778. Quindi produciamo questo valore mod 256 (10) come un carattere ASCII, che risulta essere newline. Finalmente usciamo dall'esagono e torniamo indietro al primo ?che sovrascrive il 778 con il successivo valore di input.

Pyth, 13 9 7 byte

uPWs%R2

Riconoscimenti a @FryAmTheEggman per 2 (abbastanza complicati) byte!

Spiegazione:

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

Provalo qui .

Gelatina , 5 byte

Ḃœp⁸Ḣ

Provalo online! o verifica tutti i casi di test .

Come funziona

Ḃœ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 byte

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

La funzione modifica l'argomento in atto .

Grazie a @xnor per il golf di un byte in un modo davvero intelligente!

Provalo su Ideone .

ed, 13

/[13579]$/,$d

Perché i veri programmatori usano l'Editor di testo standard .

Accetta l'input come un numero intero su ogni riga; output nello stesso formato.

Questo trova semplicemente il primo numero dispari (numero che termina in una cifra dispari) ed elimina da quella riga fino alla fine del file.

Clojure, 21 byte

#(take-while even? %)

Clojure alla fine è quasi in competizione! (grazie al fatto che l'attività è integrata) Guardalo online https://ideone.com/BEKmez

Python, 45 44 byte

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

Provalo su Ideone .

R, 25 byte

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

O in modo equivalente

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

05AB1E, 8 7 byte

[DÉO_#¨

Spiegazione

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

Provalo online

Precedente soluzione a 8 byte

vyÈiyˆëq

Spiegazione

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

Provalo online

Brainf ***, 263 byte

Ho preso un piccolo frammento da qui

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

Darei una spiegazione ma anche io non ho idea di come funzioni.

Prevede input come numeri separati da spazio (ad es. 2 432 1)

Pyth, 7 byte

<x%R2Q1

Provalo qui!

Quello che ho provato a fare in Pyke ma l'indice è rotto in quell'atmosfera

Racchetta, 22 byte

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

Il λpersonaggio viene conteggiato come 2 byte.

Non ho mai visto Racket usato in nessuna delle risposte di golf del codice che ho visto, quindi ho dovuto farlo almeno una volta!

Labirinto , 14 byte

?:
"`#
"@%
\!;

L'input e l'output sono elenchi separati da avanzamento riga (anche se in linea di principio, l'input potrebbe utilizzare qualsiasi separatore senza cifre).

Provalo online!

Questo è probabilmente il programma Labyrinth più compatto che abbia mai scritto.

È interessante notare che takewhile(odd)è molto più semplice:

?:#
" %
\!/

Spiegazione

Il solito primer Labyrinth:

• Il modello di memoria è uno stack (in realtà ce ne sono due, ma ne avremo solo uno per questo programma), che contiene numeri interi di precisione arbitraria e inizialmente contiene un numero infinito (implicito) di zeri.
• Non ci sono istruzioni per il flusso di controllo. Invece, il movimento del puntatore dell'istruzione (IP) è determinato dal layout del codice (gli spazi sono considerati "muri" e non possono essere attraversati dall'IP). Normalmente , il codice dovrebbe assomigliare a un labirinto, in cui l'IP segue curve e curve diritte, ma ogni volta che raggiunge una giunzione, questo funge da condizionale in cui la nuova direzione dell'IP viene determinata in base allo stato corrente. Le regole per scegliere una direzione si riducono a questo: se la parte superiore dello stack è zero, l'IP continua ad andare avanti; se la parte superiore è positiva, l'IP gira a destra; se la parte superiore è negativa, l'IP gira a sinistra. Se una di queste direzioni è bloccata da un muro, l'IP prende invece la direzione opposta. Ciò significa che i programmi senzai corridoi chiari sono di solito incredibilmente difficili da lavorare, perché ogni singolo comando fungerebbe da incrocio. Il fatto che questo abbia funzionato in questo caso è un po 'un miracolo.
• L'IP inizia dal primo carattere non spaziale nell'ordine di lettura ( ?in questo caso), spostandosi verso est.

Il flusso principale attraverso il programma è un singolo ciclo attorno al perimetro:

>v
^>v
^@v
^<<

Come succede, sappiamo che la parte superiore dello stack è zero dopo !e "quindi l'IP è garantito per non girare verso il centro. `e %d'altra parte sono usati come condizionali in cui l'IP potrebbe spostarsi verso il centro in modo da @terminare il programma, o potrebbe continuare a muoversi lungo il perimetro.

Diamo un'occhiata al codice nel loop:

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

E poi il ciclo ricomincia.

Ciò solleva la questione del perché takewhile(odd)sia molto più semplice. Ci sono due ragioni:

• Poiché EOF viene restituito come 0(che è pari), non è necessario un controllo EOF separato. L'elenco verrebbe comunque tagliato a quel punto.
• Ora vogliamo terminare quando N % 2è 0(al contrario di 1), il che significa invece del flusso di controllo condizionale possiamo semplicemente dividere l'altra copia Nper N % 2: se l'input è dispari, quello se ne va Ne ci liberiamo persino del N % 2(quindi non t bisogno ;), ma se l'input è pari, ciò termina semplicemente il programma con un errore (silenzioso) divisione per zero.

Quindi, l'altro codice è un semplice ciclo che non consente alcuna ramificazione.

Brachylog , 19 16 byte

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

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

Spiegazione

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

Oggi ho imparato un trucco accurato (che è stato usato nella risposta a 19 byte): ~b.hHè più breve di :[H]rc.aggiungere un elemento all'inizio di un elenco. Il primo significa "L'output è il risultato con un elemento aggiuntivo all'inizio, e il primo elemento dell'output è H" , mentre l'altro è chiaramente "L'output è la concatenazione di [[H], Result]".

J, 10 byte

{.~2&|i.1:

Spiegazione

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

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

Tronca lfino all'indice della prima occorrenza di un numero dispari. L'indice si trova cercando un 1nei valori modulo 2. Per evitare che venga trovato alcun numero dispari, 1viene messo un alla fine.

C #, 50 byte

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

CJam , 11 byte

Grazie a @Dennis per due correzioni e un byte di sconto!

{1+_2f%1#<}

Questo è un blocco di codice (equivalente a una funzione; consentito per impostazione predefinita) che prevede l'array di input nello stack e lascia l'array di output nello stack.

Provalo online!

Spiegazione

{         }    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 byte

 ?\d*[13579]\b.*

L'alimentazione di linea finale è significativa. Input e output sono elenchi separati da spazi.

Provalo online!

Questa è una semplice sostituzione regex, corrisponde al primo numero dispari (cioè un numero che termina in una cifra dispari) e, se possibile, lo spazio che lo precede e tutto ciò che lo segue e lo sostituisce con una stringa vuota, cioè tutti gli elementi da lì in seguito vengono rimossi dall'input.

Come sottolinea Leaky Nun, prendendo l'elenco in binario, possiamo salvare 6 byte, ma sembra un po 'economico, quindi probabilmente continuerò a contare la versione decimale:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 byte

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

V , 13 byte

íä*[13579]¾.*

Provalo online!

Spiegazione:

í              "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, lo stesso codice funziona per verificare tutti i casi di test contemporaneamente.

Dyalog APL , 11 byte

{⍵/⍨∧\~2|⍵}

2| resto della divisione dalla divisione con 2

~ negare

∧\ AND-scan (si spegne dal primo 0)

/⍨ seleziona dove

Rubino, 25 byte

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

Penso di perdere ...

Pyke, 8 byte

0+2L%fhO

Interprete riparato, utilizzare altri collegamenti

Utilizza il metodo di Dennis tranne la mia funzione split_at che include la modifica, probabilmente un bug

O con bugfix, 7 byte

2L%1R@<

Provalo qui!

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

O dopo il 2 ° bugfix, 6 byte

2L%fhO

Provalo qui!

Spiegazione:

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

GolfScript, 11 byte

Questo è un programma GolfScript completo che legge un array GolfScript stringato letterale (ad esempio [28 14 7 0]) e stampa lo stesso array con il primo elemento dispari e tutto ciò che è stato rimosso:

~1\{~&.},p;

Provalo online. (Inoltre: versione estesa con cablaggio di prova. )

Versione de-golf con commenti:

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

Questa soluzione si basa sull'operatore del { },filtro GolfScript , che esegue il contenuto del blocco di codice su ciascun elemento di un array e seleziona gli elementi dell'array per i quali il codice nel blocco restituisce un valore vero (ovvero diverso da zero) su parte superiore della pila.

Pertanto, ad esempio, {1&},selezionerebbe tutti i numeri dispari in un array e {~1&},selezionerebbe tutti i numeri pari. La sfida, quindi, è quella di creare un filtro che selezioni i numeri pari fino a quando non trova il primo dispari , e successivamente non seleziona alcun numero.

La soluzione che ho usato è quella di sostituire la maschera di bit costante 1(utilizzata per estrarre il bit più basso di ciascun numero di input) con una variabile nello stack che memorizza il risultato (0 o 1) della precedente iterazione del loop di filtro (ed è inizializzata su 1 prima del loop). Pertanto, non appena il filtro restituisce 0 una volta, anche la maschera di bit viene impostata su 0, impedendo al filtro di restituire nuovamente 1.

Avanti, 114 byte

Forth non ha davvero elenchi. I parametri devono essere inseriti nello stack in ordine inverso, come è tipico in Forth. Il risultato verrà lasciato nello stack nello stesso ordine. Questo non funziona su Ideone per qualche motivo, ma funziona su repl. La nuova linea è necessaria per rimuovere l'ambiguità di qualche 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 ;

Provalo online

Ungolfed, con commenti:

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

Questo programma (il mio tentativo precedente) stampa i risultati fino a quando non raggiunge un numero dispari. Tutto ciò che resta (non preso) verrà lasciato in pila.

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

Non riesce anche se solo numeri interi

Befunge, 35 byte

Questo codice gestisce numeri compresi tra 0 e 65535

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

Formato di input:

number_of_values    values(separated by a space)

Ecco una versione che mostra i valori alla fine del processo:

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

Puoi testare il codice qui , ma dovrai aggiungere una riga finale con spazi finali, in quanto questa interpretazione specifica:

«Il codice toro è grande solo quanto il programma iniziale. Inserisci più righe o spazio finale se i dati verranno inseriti oltre la fine del codice. »

Non so se questo sia accettabile, poiché non ho contato questo trailing nel byte count
nb: sembra che, poiché sto memorizzando il numero nel codice, l'interprete non permetterà a questo programma di funzionare due volte nel modo corretto modo. Dovrai ricaricarlo.

Come funziona: l'interprete segue le frecce e salta un'istruzione quando attraversa '#'

I punti grigi vengono testati e la linea rossa rimuove le variabili non necessarie dalla pila

Usando il qui nell'interprete sopra, i valori salvati vengono visualizzati nel codice usando le loro rappresentazioni (non conosco il formato). Sì, Befunge è un linguaggio piuttosto riflessivo