Pule como um coelho!

Erik the Outgolfer 08/26/2017. 30 answers, 2.887 views
code-golf array-manipulation

Dada uma lista de inteiros não negativos em qualquer formato razoável, itere sobre ele, ignorando tantos elementos quanto cada inteiro que você diz.


Aqui está um exemplo trabalhado:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done 

Outro exemplo trabalhado, não tão igual a todos os deltas:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done 

Um exemplo fora dos limites:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds) 

Regras

  • Você não pode usar qualquer fraude chata entre estes , eles fazem o desafio chato e desinteressante.
  • Você só deve retornar / imprimir o resultado final. Saída STDERR é ignorada.
  • Você não pode obter a entrada como uma string de dígitos em qualquer base (por exemplo, "0102513162" para o primeiro caso).
  • Você deve usar a ordem da esquerda para a direita para entrada.
  • Como nos exemplos trabalhados, se você sair dos limites, a execução terminará como se de outra forma.
  • Você deve usar 0 para pular 0 elementos.
  • Dada a lista vazia ( [] ) como entrada, você deve retornar [] .

Casos de teste

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4] 

Este é o , então a resposta mais curta ganha!

5 Comments
Erik the Outgolfer 07/28/2017
Sandbox (apenas 2k + usuários)
3 Shaggy 07/28/2017
Sim, apenas descobri isso. coloca os óculos
2 Rod 07/28/2017
Provavelmente um leprechaun ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
Não há problema em ter zeros à direita no meu array? me salvaria ~ 18 bytes
1 Erik the Outgolfer 07/28/2017
@ RomanGräf Desculpe, mas não, isso seria muito ambíguo, pois há casos em que você deve ter 0 s na saída.

30 Answers


Rod 07/28/2017.

Python 2 , 36 bytes

 f=lambda x:x and x[:1]+f(x[x[0]+1:]) 

Experimente online!

4 comments
Mr. Xcoder 07/28/2017
Eu estava esperando para sair do mercado, mas não tão mal :)
Erik the Outgolfer 07/28/2017
Você não pode fazer x[0] vez de x[:1] ?
Rod 07/28/2017
@EriktheOutgolfer sim, mas precisa ser uma lista, então seria [x[0]]
Erik the Outgolfer 07/28/2017
@Rod Você não está salvando nenhum byte com x[:1] ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2 , 49 46 * 41 bytes

Crossed out 4 ainda é regular 4 :(

* -3 thanks to @ASCII-only .

 l=input()
while l:print l[0];l=l[l[0]+1:] 

Experimente online!

Imprime os resultados separados por uma nova linha, como o OP permitido no bate-papo. Eu não acho que pode ficar mais curto como um non-recursive full program .


Como é que isso funciona?

  • l=input() - Lê a lista da entrada padrão.

  • while l: - Abusa o fato de listas vazias serem falsas no Python, fazendo loops até que a lista esteja vazia.

  • print l[0]; - Imprime o primeiro elemento da lista.

  • l=l[l[0]+1:] - "Salta como um coelho" - Apaga o primeiro l[0]+1 da lista.

Vamos dar um exemplo

Dada a lista [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] como entrada, o código executa o seguinte (de acordo com a explicação acima) - Imprime o primeiro item do array: 5 , apare os primeiros 6: [2, 1, 2, 1, 0, 0] . Em seguida, imprimimos 2 e recortamos os primeiros 3: [1,0,0] . Da mesma forma, produzimos 1 , cortamos os 2 primeiros e obtemos [0] . Naturalmente, 0 é impresso e o programa termina.

1 comments

w0lf 07/28/2017.

Haskell, 29 27 26 bytes

 j(x:y)=x:j(drop x y)
j x=x 

Salvo 1 byte graças a Zgarb.

Experimente online.

2 comments
Zgarb 07/28/2017
f x=x na segunda linha salva um byte.
w0lf 07/28/2017
@Zgarb Cool, obrigado!

Adnan 07/28/2017.

05AB1E , 10 9 bytes

[¬Dg>#=ƒ¦ 

Usa a codificação 05AB1E . Experimente online!

1 comments
Magic Octopus Urn 07/28/2017
Sim, isso é muito melhor do que eu estava pensando.

Martin Ender 07/28/2017.

Mathematica, 46 44 bytes

SequenceCases[#,NO 

Alternativas:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
Wow isso é ótimo!

Johan Karlsson 07/28/2017.

JavaScript (ES6), 42 39 35 bytes

a=>a.map((n,i)=>a.splice(i+1,n))&&a 

 let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4] 

Solução antiga 39 bytes

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r 

-3 bytes thanks to @ThePirateBay

1 comments
ThePirateBay 07/28/2017
39 bytes a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

TheLethalCoder 07/28/2017.

C #, 68 bytes

 a=>{for(int i=0;i 

Experimente online!

Versão completa / formatada:

 namespace System
{
    class P
    {
        static void Main()
        {
            Action> f = a =>            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List() { });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
} 

Retornar uma lista é maior em 107 bytes.

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
Por que alguém downvoted isso?
Thomas Ayoub 07/31/2017
Para arredondar sua pontuação e fazer um 5k perfeito?
TheLethalCoder 07/31/2017
@ThomasAyoub Podemos apenas supor que foi alguém com TOC sim.

Zgarb 07/28/2017.

Casca , 8 6 bytes

←TU¡Γ↓ 

Experimente online!

-2 bytes (e uma ideia de solução completamente nova) graças a Leo!

Explicação

Estou usando a função de correspondência de padrões de lista Γ . Ele pega uma função f e uma lista com cabeça x e cauda xs e aplica f a x e xs . Se a lista estiver vazia, Γ retorna um valor padrão consistente com seu tipo, neste caso, uma lista vazia. Nós tomamos f para ser , o que reduz x elementos de xs . Essa função é então iterada e os elementos resultantes são coletados em uma lista.

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4] 
5 comments
Leo 07/28/2017
Você pode diminuir o valor padrão de ø, e tudo ainda funcionará magicamente :)
Zgarb 07/28/2017
@Leo Oh wow, isso é inteligente!
Erik the Outgolfer 07/28/2017
Por que você CW isso?
Zgarb 07/28/2017
@ErikTheOutgolfer Isso foi um erro (estou no meu celular e, aparentemente, empurrei algo por acidente). Estou tentando desfazer isso ...

Ruud 07/28/2017.

Python 2 , 59 55 bytes

 l=input()
i=0
while l[i:]:i+=1;l[i:i+l[i-1]]=[]
print l 

Experimente online!

2 comments
1 Rod 07/28/2017
Você pode usar l[i:i+l[i-1]]=[] vez de del l[i:i+l[i-1]] para salvar um byte
1 ASCII-only 07/28/2017

Dave 07/28/2017.

Pyth, 22 bytes

VQ aY.(Q0VeY .x.(Q0 ;Y 

Removido um byte inútil

4 comments
Erik the Outgolfer 07/28/2017
Eu vejo 23 bytes lá.
Dave 07/28/2017
Typo :) desculpe ...
3 Wheat Wizard 07/28/2017
Não sei por que você tem um voto baixo. Existe a possibilidade de que quando você editou corrigindo sua resposta, isso desencadeou uma "votação automática para baixo". As razões para esse downvote automático são confusas e terríveis, mas isso acontece se o sistema considerar sua resposta como "baixa qualidade" com base na heurística. Também é possível que alguém não tenha gostado da sua resposta, mas não vejo nada de errado com ela no momento, por isso não sei por que isso aconteceria.
isaacg 07/31/2017
Fico feliz que você esteja usando o Pyth!

Rod 07/28/2017.

Python 2 , 60 42 bytes

-18 bytes graças a Luis Mendo

 x=input()
i=0
while 1:print x[i];i+=1+x[i] 

Experimente online!


Martin Ender 07/28/2017.

Retina , 36 bytes

A contagem de bytes pressupõe a codificação ISO 8859-1.

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$ 

Entrada e saída são separadas por alimentação de linha com um avanço de linha à direita.

Experimente online! (Usa vírgulas em vez de linefeeds para permitir conjuntos de testes convenientes.)


Riley 07/28/2017.

Brain-Flak , 64 bytes

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

Experimente online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
Puta merda! Eu escrevi uma solução e, em seguida, rolei para baixo para postá-lo, mas acontece que escrevemos exact mesma solução byte-by-byte! Mesmo pequenos detalhes como ({}[()]<{}>) vs ({}<{}>[()]) foram os mesmos! Que coincidência!
2EZ 4RTZ 07/28/2017
@DJMcMayhem roubando toda a fama XD

user202729 07/28/2017.

Mathematica, 64 50 bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
Eu não pude resistir mais a jogar esse código limpo; minha resposta está abaixo.

jkelm 07/28/2017.

C # (.NET Core) , 68 bytes

 n=>{var t="";for(int i=0;i 

Experimente online!

Recebe entrada como uma matriz de inteiros, retorna uma string contendo os valores não pulados.

3 comments
TheLethalCoder 07/28/2017
Bela maneira de fazê-lo e vem na mesma contagem que a impressão.
jkelm 07/28/2017
Eu amo as soluções simples. Ainda tenho que aprender LINQ embora, como eu vi que encurtar tantos c # lambdas ..
TheLethalCoder 07/28/2017
Encurta isso porque você pode implantar o retorno na maior parte do tempo. Embora seja um lance entre o retorno implícito com o using System.Linq; e um loop normal.

Jarko Dubbeldam 07/28/2017.

R, 58 bytes

f=function(x,p=1)NO 

Função recursiva. Toma um vetor x como argumento e inicia um ponteiro p . Isso imprime a entrada correspondente de x , verifica se p+x[p] sairá dos limites e, se não, chamará a função do novo ponteiro.

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z]))) 

Esta é uma solução comparável que retorna um vetor adequado em vez de imprimir os dígitos.

3 comments
Giuseppe 07/28/2017
que tal uma entrada de numeric(0) ? aka array vazio.
Jarko Dubbeldam 07/28/2017
@Giuseppe eu vou dar uma olhada quando eu estou atras do meu pc
Giuseppe 08/24/2017
57 bytes! e lida com o estojo vazio também.

Roman Gräf 07/28/2017.

Java (OpenJDK 8) , 53 bytes

Graças a @ PunPun1000 e @TheLethalCoder

 a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);} 

Experimente online!

5 comments
TheLethalCoder 07/28/2017
A impressão dos resultados, como na minha resposta do C #, poupa alguma coisa?
Roman Gräf 07/28/2017
@TheLethalCoder Vou tentar
TheLethalCoder 07/28/2017
Você pode salvar um byte movendo n no loop?
TheLethalCoder 07/28/2017
Além disso, isso não parece funcionar no momento.
PunPun1000 07/28/2017
Você está perdendo um paren após o (a[n+=1+a[n]] . Função também gera um erro após a saída do valor correto, eu não sei o consenso sobre se isso é permitido ou não (a questão não dizer qualquer coisa para erro padrão é ignorar.) Se essa era a intenção, então você pode remover o n no loop for. Finalmente, o código TIO não é executado como está, mesmo com o paren. A função deve ser um Consumer e use func.accept(test)

Martin Ender 07/28/2017.

Alice , 15 bytes

/$.. \h&
\I@nO/ 

Experimente online!

Insira e imprima uma lista separada por avanço de linha de números inteiros decimais.

Explicação

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning. 

Armazenar um inteiro n na fila do iterador faz com que o próximo comando seja executado n vezes. Espelhos como / não são comandos, então o próximo comando será I . Portanto, se apenas lermos e imprimirmos um valor x , leremos valores de x+1 na próxima iteração, com o último deles terminando no topo da pilha. Isso ignora os elementos da lista de números necessários.


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

Mais golfe do método fino do user202729.

±NO 

As regras não parecem especificar explicitamente o formato de saída, então talvez:

±NO 

A saída para a segunda função é semelhante a: 0.2.4.{} - notavelmente {} ainda é retornado para um conjunto vazio, em conformidade com a regra final.

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO pode ser ±NO porque ± tem uma precedência menor que Infix .
Mr.Wizard 07/28/2017
@JungHwanMin Eu senti falta disso; obrigado!

Jenny_mathy 07/28/2017.

Mathematica, 65 bytes

(s=#;t=1;w={};While[t<=Length@s,AppendTo[w,k=s[[t]]];t=t+k+1];w)& 

Experimente online!


w0lf 07/28/2017.

Rubi, 36 33 31

f=->l{a,*l=l;a&&f[l.drop(p a)]} 

Experimente online.

4 comments
sethrin 07/30/2017
Você tem permissão para subtrair o f= como um elemento de cabeçalho.
w0lf 07/30/2017
@sethrin Mesmo se eu precisar chamá-lo recursivamente?
sethrin 07/30/2017
Hmm, boa pergunta. Suponho que não. Eu gostei muito da sua solução, a propósito.
w0lf 07/30/2017
@sethrin Obrigado! :)

AnonymousReality 07/28/2017.

Swift, 63 bytes

func a(d:[Int]){var i=0;while i 

Esta é a minha primeira entrada, nunca, então eu não tenho 100% de certeza sobre as regras, mas espero que esta resposta seja suficiente. Estou um pouco inseguro de regras sobre como obter a entrada em um sistema. Eu tenho uma resposta mais curta se eu fosse autorizado a assumir uma função em algum lugar que possa retornar a entrada.

2 comments
Stephen 07/28/2017
Bem vindo ao PPCG! As regras padrão são que você pode ter um código que funcione como um programa completo, então insira (geralmente) em STDIN e emita (geralmente) para STDOUT, or uma função, então insira (normalmente) a partir de parâmetros de função e saída (geralmente) retorno de função.
AnonymousReality 07/28/2017
@StepHen - obrigado! Eu acho que isso faz minha outra versão inválida então. Ansioso para contribuir mais!

Perl 6 , 31 bytes

 {(@_,{.[1+.[0]..*]}...^0)[*;0]} 

Teste-o

Expandido:

 {  # bare block lambda with implicit parameter 「@_」
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
} 

Para ajudar a entender como o código funciona, sem [*;0] isso geraria uma sequência como a seguinte:

 [0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2) 

Renzo 07/29/2017.

Lisp comum, 51 bytes

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x))) 

Experimente online!


C ++ (gcc), 172 bytes

#includeint main(){std::istream& i=std::cin;char c;int a,b;while(i>>c&&i>>a){std::cout<>c&&i>>b);}std::cout< 

Experimente online

O terrível (c/91?"":" ") É para o espaçamento correto na saída. Sem ela (-15 bytes) a saída está em forma: [0,2,4] , quando eu altero para simples " " (-9 bytes) a saída é como [ 0, 2, 4] (espaço adicional no início) .

<<(c/93?"":"]") no final é apenas para lidar com [] caso de canto de entrada vazio

Imprime sem final.

1 comments
Erik the Outgolfer 07/30/2017
Você também pode imprimir os números separados por um separador de nenhum dígito, não há necessidade de [] e você pode ter saída vazia para esse caso de borda, e não há necessidade de (c/91?"":" ") . Você não precisa corresponder ao formato dos exemplos no desafio.

Jonathan Allan 07/29/2017.

Geléia , 8 bytes

ḢṄ‘ṫ@µL¿ 

Um programa completo imprimindo os resultados, cada um seguido por uma nova linha (lista vazia não produz saída).

Try it online!

Como?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         ''' 
2 comments
Erik the Outgolfer 07/30/2017
Finalmente uma resposta da geléia! BTW eu posso fazer isso em 7 bytes.
Erik the Outgolfer 07/30/2017
E eu também tenho uma função de retorno de lista em 18 bytes.

Evpok 07/30/2017.

Python 3 , 35 bytes

 f=lambda h=0,*t:t and[h,*f(*t[h:])] 

Experimente online!

Execute-o com f(*l) onde l é sua entrada. Indiscutivelmente esticando as regras para entrada, mas eu adoro a descompactação avançada.


cliffroot 07/28/2017.

Clojure, 67 bytes

#(nth(reduce(fn[[z k]b](if(= z 0)[b(conj k b)][(- z 1)k]))[0[]]%)1) 

Começa com os parâmetros iniciais [0 []] , onde 0 é o contador e [] é o resultado. Se o primeiro elemento dessa lista for 0 item n é anexado do argumento ao resultado e passa adiante essa lista [n [... n]] caso contrário, decrementa o primeiro elemento. (esta explicação parece horrível para mim)

Veja on-line


Dead Possum 07/28/2017.

Python 2.4, 85 bytes

Nenhuma chance de ganhar em python com ele, mas eu amo oneliners e este pode ser interessante para os outros.
Acontece que há um truque de mágica extravagante para acessar a lista de construção dentro da compreensão, mas ela funciona somente em 2.4 e com algumas edições em <= 2,3
locals()['_[1]'] é. Python cria nome secreto _[1] para lista, enquanto é criado e armazenado nos locals . Também nomes _[2] , _[3] ... são usados ​​para listas aninhadas.

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])] 

Por isso, conta o número de elementos já adicionados mais sua soma. Resultado é o índice do próximo elemento desejado.
Eu acho que deveria haver uma maneira de evitar enumerar. Como acessar a matriz de entrada diretamente pelo índice: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] . Mas eu não consigo descobrir uma forma compacta de protegê-lo do índice fora de alcance (mantendo-o oneliner)

insira a descrição da imagem aqui


Neil 07/28/2017.

Lote, 69 bytes

:l
@if not "%1"=="" echo %1&(for /l %%i in (0,1,%1)do @shift)&goto l 

(Eu preciso do () s ao redor do for caso contrário o goto acontece dentro do loop.)

Related questions

Hot questions

Language

Popular Tags