Introdução e Crédito

Hoje sem um prelúdio sofisticado: implemente takewhile.

Uma variação disso (em uma estrutura de dados não trivial) foi uma tarefa no meu curso de programação funcional da universidade. Esta tarefa está encerrada e foi discutida em sala de aula e tenho a permissão do meu professor para publicá-la aqui (perguntei explicitamente).

Especificação

Entrada

A entrada será uma lista (ou o conceito equivalente do seu idioma) de números inteiros positivos.

Saída

A saída deve ser uma lista (ou o conceito equivalente do seu idioma) de números inteiros positivos.

O que fazer?

Sua tarefa é implementar takewhile(built-ins de idioma são permitidos) com o predicado de que o número em consideração é par (para focar no tempo de espera).

Então, você itera sobre a lista do início ao fim e, enquanto a condição (é par) é mantida, copia para a lista de saída e, assim que atinge um elemento que não torna a condição verdadeira, aborta a operação e a saída (um exemplo passo a passo está abaixo). Essa funcionalidade de ordem superior também é chamada de takeWhile ( takewhile).

Casos de canto em potencial

A ordem da lista de saída comparada à lista de entrada não pode ser alterada, por exemplo, [14,42,2]pode não se tornar [42,14].

A lista vazia é uma entrada e saída válida.

Quem ganha?

Isso é código-golfe, então a resposta mais curta em bytes vence!

Regras padrão se aplicam, é claro.

Vetores de teste

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

Exemplo passo a 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 bytes

#~TakeWhile~EvenQ&

Outro glorioso built-in que é batido por um fator de 3 por idiomas de golfe sem o built-in ...

Haskell, 13 bytes

fst.span even

spandivide a lista de entrada em um par de listas imediatamente antes do primeiro elemento em que o predicado (-> even) é falso. fstpega o primeiro elemento do par.

Versão alternativa, 13 bytes:

fst.break odd

breaké o oposto de span, ou seja, divide a lista no primeiro elemento em que o predicado é verdadeiro.

Claro que há também

takeWhile even

mas isso é 14 bytes.

MATL , 6 bytes

toYs~)

Experimente online!

Explicação

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

Hexagonia , 19

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

Legível:

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

Experimente online!

Provavelmente isso pode ser jogado com um byte ou dois, mas isso pode exigir um layout realmente engenhoso, que pode ser encontrado com mais facilidade por força bruta (mesmo que demore um pouco para encontrá-lo).

Explicação de alto nível

O programa segue principalmente esse pseudocódigo:

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

O que abusa de como o Hexagony tenta ler um número quando STDIN está vazio (retorna um zero). Muito obrigado a Martin pela ajuda na criação dessa abordagem.

Explicação completa

Ainda não brinquei com o Mono para executar o fantástico IDE esotérico de Timwi , por isso me apoiei no Martin para me fornecer algumas fotos bonitas e úteis!

Primeiro, uma pequena cartilha sobre o fluxo de controle básico no Hexagony. O primeiro ponteiro de instrução (IP), que é o único usado neste programa, começa no canto superior esquerdo do código-fonte hexagonal e começa a se mover para a direita. Sempre que o IP sai da borda do hexágono, ele se moveside_length - 1 linhas em direção ao meio do hexágono. Como este programa usa um hexágono lateral de três lados, o IP sempre moverá duas linhas quando isso acontecer. A única exceção é se sair da linha do meio, onde se moverá condicionalmente para a parte superior ou inferior do hexágono, dependendo do valor da borda da memória atual.

Agora um pouco sobre condicionais. Os únicos condicionais no Hexagony para fluxo de controle são> , <e a borda média do hexágono. Todos eles seguem uma regra constante: se o valor na borda da memória atual for zero ou se o fluxo de controle negativo se mover para a esquerda e se for positivo, o controle fluirá para a direita. Os colchetes maior e menor que o redirecionam o IP em ângulos de sessenta graus, enquanto a borda do hexágono controla para qual linha o IP salta.

A Hexagony também possui um modelo de memória especial, onde todos os dados são armazenados nas bordas de uma grade hexagonal infinita. Este programa usa apenas três arestas: uma para armazenar duas, uma para o número atualmente lido e uma para o módulo número dois. Parece algo como:

Mod  \ / Input
      |
      2

Não vou explicar cuidadosamente onde estamos na memória em cada ponto durante a explicação do programa; portanto, volte aqui se você ficar confuso com o local em que estamos na memória.

Com tudo isso fora do caminho, a explicação real pode começar. Primeiro, preenchemos a borda "2" na memória com um 2, depois executamos um no-op e movemos o ponteiro da memória para a direita (2.} ).

Em seguida, começamos o loop principal do programa. Lemos o primeiro número de STDIN e, em seguida, atingimos um condicional ( ?<). Se não houver mais números no STDIN, isso indica um zero na borda da memória atual; portanto, vire à esquerda na @, que encerra o programa. Caso contrário, saltamos de um espelho, movemos o ponteiro de memória para trás e para a esquerda, envolvemos o hexágono para calcular o restante da divisão da entrada por 2 e, em seguida, atingimos outra condição ( /"%>).

Se o restante for um (ou seja, o número era ímpar), viramos à direita seguindo o caminho azul acima, iniciando novamente o no-op, depois envolvemos a parte inferior do hexágono, multiplicamos a aresta atual por 10 e adicionamos oito, rebate alguns espelhos, faça a mesma multiplicação e adição novamente, colocando 188 na borda atual, voltando para o topo do hexágono, executando o no-op novamente e finalmente encerrando o programa ( .8/\8.@). Esse resultado complicado foi um acidente feliz, eu originalmente havia escrito um pouco mais lógico da lógica, mas percebi que podia removê-lo em favor do no-op, que eu achava mais no espírito da Hexagony.

Se o restante for zero, vire à esquerda seguindo o caminho vermelho acima. Isso faz com que movamos o ponteiro da memória para a esquerda e imprima o valor lá (o valor de entrada) como um número. O espelho que encontramos age como não operacional por causa da direção que estamos seguindo ( ). Como 77 é positivo, movemos para a direita na parte inferior do hexágono e, por causa do trampolim, pulamos a primeira instrução ( ). Em seguida, multiplicamos a borda da memória atual por 10 e adicionamos 8, obtendo 778. Em seguida, emitimos esse valor mod 256 (10) como um caractere ASCII, que passa a ser uma nova linha. Finalmente, saímos do hexágono e retornamos ao primeiro, que substitui o 778 pelo próximo valor de entrada.{/! ). Em seguida, atingimos a borda do hexágono, que age condicional com apenas um resultado, já que o valor de entrada de antes já foi testado como positivo, então sempre avançamos para a direita (se você se imaginar voltado para a IP) . Em seguida, multiplicamos a entrada por 10 e adicionamos duas, apenas para mudar de direção, envolver e exagerar o novo valor com o valor ASCII da letra maiúscula M, 77. Em seguida, atingimos alguns espelhos e saímos pela borda do meio da tela. o hexágono com um trampolim (2<M\>$!?

Pitão, 13 9 7 bytes

uPWs%R2

Créditos para @FryAmTheEggman por 2 (bastante complicados) bytes!

Explicação:

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

Teste aqui .

Gelatina , 5 bytes

Ḃœp⁸Ḣ

Experimente online! ou verifique todos os casos de teste .

Como 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()

A função modifica seu argumento no lugar .

Obrigado ao @xnor por jogar um byte de uma maneira realmente inteligente!

Teste em Ideone .

ed, 13

/[13579]$/,$d

Como programadores reais usam o Editor de texto padrão .

Recebe a entrada como um número inteiro em cada linha; saídas no mesmo formato.

Isso simplesmente localiza o primeiro número ímpar (número que termina em um dígito ímpar) e exclui essa linha até o final do arquivo.

Clojure, 21 bytes

#(take-while even? %)

Clojure está quase competindo finalmente! (graças à tarefa ser incorporada) Veja-o on-line https://ideone.com/BEKmez

Python, 45 44 bytes

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

Teste em Ideone .

R, 25 bytes

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

Ou equivalente

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

05AB1E, 8 7 bytes

[DÉO_#¨

Explicação

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

Experimente online

Solução anterior de 8 bytes

vyÈiyˆëq

Explicação

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

Experimente online

Brainf ***, 263 bytes

Peguei um pequeno trecho daqui

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

Eu daria uma explicação, mas mesmo eu não tenho idéia de como isso funciona mais.

Espera entrada como números separados por espaço (por exemplo 2 432 1)

Pitão, 7 bytes

<x%R2Q1

Experimente aqui!

O que eu tentei fazer no Pyke, mas o índice está quebrado nesse atm

Raquete, 22 bytes

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

o λ caractere é contado como 2 bytes.

Eu nunca vi o Racket usado antes em nenhuma das respostas de código de golfe que eu vi, então tive que fazer isso pelo menos uma vez!

Labirinto , 14 bytes

?:
"`#
"@%
\!;

Entrada e saída são listas separadas por avanço de linha (embora, em princípio, a entrada possa usar qualquer separador que não seja um dígito).

Experimente online!

Este é provavelmente o programa de labirinto mais compacto que já escrevi.

Curiosamente, takewhile(odd)é muito mais simples:

?:#
" %
\!/

Explicação

A cartilha usual do labirinto:

• O modelo de memória é uma pilha (na verdade existem duas, mas precisamos apenas de uma para este programa), que contém números inteiros de precisão arbitrária e inicialmente contém um número infinito (implícito) de zeros.
• Não há instruções de fluxo de controle. Em vez disso, o movimento do ponteiro de instrução (IP) é determinado pelo layout do código (os espaços são considerados "paredes" e não podem ser atravessados ​​pelo IP). Normalmente , o código deve se assemelhar a um labirinto, onde o IP segue corredores e curvas retas, mas sempre que atinge uma junção, ele age como um condicional, onde a nova direção do IP é determinada com base no estado atual. As regras para escolher uma direção se resumem a isso: se o topo da pilha for zero, o IP continuará avançando; se a parte superior for positiva, o IP vira à direita; se a parte superior for negativa, o IP vira à esquerda. Se uma dessas direções for bloqueada por uma parede, o IP seguirá a direção oposta. Isso significa que os programas semcorredores claros geralmente são incrivelmente difíceis de trabalhar, porque cada comando atuaria como uma junção. O fato de que isso funcionou nesse caso é um milagre.
• O IP começa com o primeiro caractere não espacial na ordem de leitura ( ?neste caso), movendo-se para leste.

O fluxo principal do programa é um loop único ao redor do perímetro:

>v
^>v
^@v
^<<

Por acaso, sabemos que o topo da pilha é zero depois !e, "portanto, é garantido que o IP não volte para o centro. `e, %por outro lado, são usados ​​como condicionais nos quais o IP pode se mover em direção ao centro, de modo que @encerre o programa, ou pode continuar se movendo pelo perímetro.

Vamos dar uma olhada no código no 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 então o loop recomeça.

Isso levanta a questão de por que takewhile(odd)é muito mais simples. Há duas razões:

• Como o EOF é retornado como 0(que é par), não precisamos de uma verificação EOF separada. A lista seria cortada nesse ponto de qualquer maneira.
• Agora queremos encerrar quando N % 2is 0(em oposição a 1), o que significa que, em vez do fluxo de controle condicional, podemos simplesmente dividir a outra cópia Npor N % 2: se a entrada é ímpar, isso simplesmente sai Ne até nos livramos da N % 2(então não fazemos ' Não é necessário ;), mas se a entrada for par, isso simplesmente encerra o programa com um erro (silencioso) de divisão por zero.

Portanto, o outro código é um loop simples que não permite nenhuma ramificação.

Braquilog , 19 16 bytes

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

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

Explicação

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

Hoje eu aprendi um truque interessante (que foi usado na resposta de 19 bytes): ~b.hHé mais curto do :[H]rc.que acrescentar um elemento no início de uma lista. O primeiro significa "Saída é o resultado com um item extra no início, e o primeiro item da Saída é H" , enquanto o outro é diretamente "Saída é a concatenação de [[H], Result]".

J, 10 bytes

{.~2&|i.1:

Explicação

{.~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 laté o índice da primeira ocorrência de um número ímpar. O índice é encontrado procurando um 1no módulo de valores 2. Para evitar que nenhum número ímpar seja encontrado, a 1é colocado no final.

C #, 50 bytes

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

CJam , 11 bytes

Graças a @Dennis por duas correções e um byte de folga!

{1+_2f%1#<}

Este é um bloco de código (equivalente a uma função; permitido por padrão) que espera a matriz de entrada na pilha e deixa a matriz de saída na pilha.

Experimente online!

Explicação

{         }    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.*

O avanço de linha à direita é significativo. Entrada e saída são listas separadas por espaço.

Experimente online!

Esta é uma substituição simples de regex, corresponde ao primeiro número ímpar (ou seja, um número que termina em um dígito ímpar) e, se possível, o espaço que o precede, bem como tudo o que está a seguir, e o substitui por uma sequência vazia, ou seja, todos os elementos de lá em diante são removidos da entrada.

Como Leaky Nun aponta, pegando a lista em binário, podemos economizar 6 bytes, mas parece um pouco barato, então provavelmente continuarei contando a versão decimal:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 bytes

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

V , 13 bytes

íä*[13579]¾.*

Experimente online!

Explicação:

í              "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, o mesmo código funciona para verificar todos os casos de teste simultaneamente.

Dyalog APL , 11 bytes

{⍵/⍨∧\~2|⍵}

2| divisão restante da divisão com 2

~ negar

∧\ AND-scan (desativa desde o primeiro 0)

/⍨ selecione onde

Ruby, 25 bytes

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

Acho que perco ...

Pyke, 8 bytes

0+2L%fhO

Intérprete corrigido, use outros links

Utiliza o método de Dennis, exceto que minha função split_at inclui a alteração - provavelmente um bug

Ou com correção de bug, 7 bytes

2L%1R@<

Experimente aqui!

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

Ou após o segundo bugfix, 6 bytes

2L%fhO

Experimente aqui!

Explicação:

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

GolfScript, 11 bytes

Este é um programa completo do GolfScript que lê uma matriz GolfScript com string (por exemplo [28 14 7 0]) e imprime a mesma matriz com o primeiro elemento ímpar e tudo depois de removido:

~1\{~&.},p;

Experimente online. (Também: versão estendida com equipamento de teste. )

Versão descolada com comentários:

~     # 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 solução é baseada no { },operador de filtro GolfScript , que executa o conteúdo do bloco de código em cada elemento de uma matriz e seleciona os elementos da matriz para os quais o código no bloco retorna um valor verdadeiro (ou seja, não zero) em topo da pilha.

Assim, por exemplo, {1&},selecionaria todos os números ímpares em uma matriz e {~1&},selecionaria todos os números pares. O desafio, então, é criar um filtro que selecione números pares até encontrar o primeiro número ímpar e, a partir de então, nenhum número.

A solução que usei é substituir a máscara de bits constante 1(usada para extrair o bit mais baixo de cada número de entrada) por uma variável na pilha que armazena o resultado (0 ou 1) da iteração anterior do loop de filtro (e é inicializada para 1 antes do loop). Assim, assim que o filtro retornar 0 uma vez, a máscara de bit também será definida como 0, impedindo que o filtro retorne 1 novamente.

Quarto, 114 bytes

Quarto realmente não tem listas. Os parâmetros devem ser empurrados para a pilha na ordem inversa, como é típico em Forth. O resultado será deixado na pilha na mesma ordem. Por algum motivo, isso não funciona no Ideone, mas funciona no repl. A nova linha é necessária para remover a ambiguidade de algum 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 ;

Experimente online

Ungolfed, com comentários:

: 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 (minha tentativa anterior) imprime os resultados até atingir um número ímpar. Tudo o que resta (não tirado) será deixado na pilha.

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

Falha se apenas números inteiros

Befunge, 35 bytes

Este código lida com números entre 0 e 65535

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

Formato de entrada :

number_of_values    values(separated by a space)

Aqui está uma versão que exibe os valores no final do processo:

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

Você pode testar o código aqui , mas precisará adicionar uma linha à direita com espaços à direita, pois esta interpretação especifica:

«O toro de código é tão grande quanto o programa inicial. Insira mais linhas ou espaço à direita se os dados forem colocados além do final do código. »

Não sei se isso é aceitável, pois não contei esse resultado na contagem de bytes
: parece que, como estou armazenando número no código, o intérprete não permitirá que esse programa seja executado duas vezes na correta maneira. Você terá que recarregá-lo.

Como é que isso funciona: O intérprete segue as setas e pula uma instrução ao cruzar '#'

Pontos cinza são testados e a linha vermelha remove variáveis ​​desnecessárias da pilha

Usando o aqui no intérprete acima, os valores salvos são exibidos no código usando suas representações (não sei o formato). Sim, o Befunge é uma linguagem bastante reflexiva