¡Salta como un conejo!

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

Dada una lista de enteros no negativos en cualquier formato razonable, repítelo, omitiendo todos los elementos que indique cada entero que pise.


Aquí hay un ejemplo trabajado:

[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 

Otro ejemplo trabajado, no tan deltas iguales:

[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 

Un ejemplo fuera de límites:

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

Reglas

  • No puedes usar ningún truco aburrido entre estos , hacen que el desafío sea aburrido y sin interés.
  • Solo debe devolver / imprimir el resultado final. La salida de STDERR se ignora.
  • No puede obtener la entrada como una cadena de dígitos en cualquier base (por ejemplo, "0102513162" para el primer caso).
  • Debe usar la orden de izquierda a derecha para la entrada.
  • Como en los ejemplos trabajados, si sale de límites, la ejecución termina como si no fuera así.
  • Deberías usar 0 para saltar 0 elementos.
  • Dada la lista vacía ( [] ) como entrada, debe devolver [] .

Casos de prueba

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

Esto es , ¡así que la respuesta más corta gana!

5 Comments
Erik the Outgolfer 07/28/2017
Sandbox (solo 2k + usuarios)
3 Shaggy 07/28/2017
Sí, lo vi. / pone lentes en
2 Rod 07/28/2017
Probablemente un leprechaun ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
¿Está bien tener ceros al final en mi matriz? me salvaría ~ 18 bytes
1 Erik the Outgolfer 07/28/2017
@ RomanGräf Lo siento pero no, eso sería demasiado ambiguo ya que hay casos en los que deberías tener 0 s en la salida.

30 Answers


Rod 07/28/2017.

Python 2 , 36 bytes

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

¡Pruébalo en línea!

4 comments
Mr. Xcoder 07/28/2017
Esperaba que me superaran, pero no tanto :)
Erik the Outgolfer 07/28/2017
¿No puedes hacer x[0] lugar de x[:1] ?
Rod 07/28/2017
@EriktheOutgolfer sí, pero debe ser una lista, por lo que sería [x[0]]
Erik the Outgolfer 07/28/2017
@Rod Usted no está guardando ningún byte con x[:1] todos modos ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2 , 49 46 * 41 bytes

Tachado 4 sigue siendo regular 4 :(

* -3 thanks to @ASCII-only .

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

¡Pruébalo en línea!

Imprime los resultados separados por una nueva línea, como el OP permitido en el chat. No creo que pueda acortarse como un non-recursive full program .


¿Como funciona esto?

  • l=input() - Lee la lista de la entrada estándar.

  • while l: - Abusa del hecho de que las listas vacías son falsas en Python, bucles hasta que la lista esté vacía.

  • print l[0]; - Imprime el primer elemento de la lista.

  • l=l[l[0]+1:] - "Salta como un conejo" - Recorta el primer l[0]+1 de la lista.

Tomemos un ejemplo

Dada la lista [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] como entrada, el código realiza lo siguiente (según la explicación anterior) - Imprime el primer elemento del array: 5 , recorte los primeros 6: [2, 1, 2, 1, 0, 0] . Luego imprimimos 2 y recortamos los primeros 3: [1,0,0] . Del mismo modo, generamos 1 , recortamos los 2 primeros y obtenemos [0] . Por supuesto, 0 se imprime y el programa termina.

1 comments

w0lf 07/28/2017.

Haskell, 29 27 26 bytes

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

Ahorro de 1 byte gracias a Zgarb.

Pruébalo en línea.

2 comments
Zgarb 07/28/2017
f x=x en la segunda línea guarda un byte.
w0lf 07/28/2017
@Zgarb Cool, gracias!

Adnan 07/28/2017.

05AB1E , 10 9 bytes

[¬Dg>#=ƒ¦ 

Utiliza la codificación 05AB1E . ¡Pruébalo en línea!

1 comments
Magic Octopus Urn 07/28/2017
Sí, eso es mucho mejor de lo que estaba pensando.

Martin Ender 07/28/2017.

Mathematica, 46 44 bytes

SequenceCases[#,NO 

Alternativas:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
¡Wow eso es genial!

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] 

Vieja solución 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 

¡Pruébalo en línea!

Versión completa / Formateada:

 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();
        }
    }
} 

Devolver una lista es más largo en 107 bytes.

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
¿Por qué alguien ha votado negativamente?
Thomas Ayoub 07/31/2017
Para redondear su puntaje y hacer un perfecto 5k?
TheLethalCoder 07/31/2017
@ThomasAyoub Solo podemos suponer que fue alguien con TOC sí.

Zgarb 07/28/2017.

Cáscara , 8 6 bytes

←TU¡Γ↓ 

¡Pruébalo en línea!

-2 bytes (y una idea de solución completamente nueva) ¡gracias a Leo!

Explicación

Estoy usando la función de coincidencia de patrones de lista Γ . Toma una función f una lista con la cabeza x cola xs , y aplica f a x y xs . Si la lista está vacía, Γ devuelve un valor predeterminado consistente con su tipo, en este caso, una lista vacía. Tomamos f para ser , que arroja x elementos de xs . Esta función se itera y los elementos resultantes se recopilan en una 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
Puede soltar el valor predeterminado de ø, y todo seguirá funcionando mágicamente :)
Zgarb 07/28/2017
@Leo Oh wow, eso es inteligente!
Erik the Outgolfer 07/28/2017
¿Por qué tuviste esto?
Zgarb 07/28/2017
@ErikTheOutgolfer Eso fue un error (estoy en mi teléfono y aparentemente empujé algo por accidente). Estoy tratando de deshacerlo ...

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 

¡Pruébalo en línea!

2 comments
1 Rod 07/28/2017
Puede usar l[i:i+l[i-1]]=[] vez de del l[i:i+l[i-1]] para guardar un byte
1 ASCII-only 07/28/2017

Dave 07/28/2017.

Pyth, 22 Bytes

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

Se eliminó un byte inútil

4 comments
Erik the Outgolfer 07/28/2017
Veo 23 bytes allí.
Dave 07/28/2017
Typo :) lo siento ...
3 Wheat Wizard 07/28/2017
No estoy seguro de por qué tienes un voto negativo. Existe la posibilidad de que cuando editó la solución de su respuesta esto haya desencadenado un "voto automático hacia abajo". Las razones de este downvote automático son confusas y terribles, pero sucede si el sistema considera que su respuesta es de "baja calidad" en función de su heurística. También es posible que a alguien no le haya gustado tu respuesta, pero no veo nada mal con ella en este momento, así que no estoy seguro de por qué sería ese el caso.
isaacg 07/31/2017
¡Me alegra que estés usando Pyth!

Rod 07/28/2017.

Python 2 , 60 42 bytes

-18 bytes gracias a Luis Mendo

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

¡Pruébalo en línea!


Martin Ender 07/28/2017.

Retina , 36 bytes

El conteo de bytes asume la codificación ISO 8859-1.

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

La entrada y la salida están separadas por un salto de línea con un avance de línea posterior.

¡Pruébalo en línea! (Utiliza comas en lugar de avances de línea para permitir suites de prueba convenientes).


Riley 07/28/2017.

Brain-Flak , 64 bytes

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

¡Pruébalo en línea!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
¡Santo cielo! Escribí una solución y luego me desplacé hacia abajo para publicarla, pero resultó que escribimos exact misma solución byte por byte. Incluso detalles menores como ({}[()]<{}>) vs ({}<{}>[()]) eran lo mismo. ¡Qué casualidad!
2EZ 4RTZ 07/28/2017
@DJMcMayhem robando toda la 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
No pude resistir la tentación de jugar este golf código; mi respuesta esta abajo

jkelm 07/28/2017.

C # (.NET Core) , 68 bytes

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

¡Pruébalo en línea!

Toma entrada como una matriz de enteros, devuelve una cadena que contiene los valores no saltados.

3 comments
TheLethalCoder 07/28/2017
Una buena manera de hacerlo y viene al mismo tiempo que la impresión.
jkelm 07/28/2017
Amo las soluciones simples. Todavía tengo que aprender LINQ, como he visto que acortan tantas lambdas c #.
TheLethalCoder 07/28/2017
Se acorta porque puede regresar implícitamente la mayor parte del tiempo. Aunque es un lanzamiento entre retorno implícito con el using System.Linq; y un bucle normal.

Jarko Dubbeldam 07/28/2017.

R, 58 bytes

f=function(x,p=1)NO 

Función recursiva. Toma un vector x como argumento e inicia un puntero p . Esto imprime la entrada correspondiente de x , comprueba si p+x[p] saldrá de los límites, y si no, llama a la función para el nuevo puntero.

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 es una solución comparable que devuelve un vector adecuado en lugar de imprimir los dígitos.

3 comments
Giuseppe 07/28/2017
¿Qué tal una entrada de numeric(0) ? también conocido como matriz vacía.
Jarko Dubbeldam 07/28/2017
@Giuseppe lo echaré un vistazo cuando esté detrás de mi pc
Giuseppe 08/24/2017
57 bytes! y maneja la caja vacía también.

Roman Gräf 07/28/2017.

Java (OpenJDK 8) , 53 bytes

Gracias a @ PunPun1000 y @TheLethalCoder

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

¡Pruébalo en línea!

5 comments
TheLethalCoder 07/28/2017
¿Imprimiría los resultados, como en mi respuesta de C #, le ahorraría algo?
Roman Gräf 07/28/2017
@TheLethalCoder Lo intentaré
TheLethalCoder 07/28/2017
¿Puedes guardar un byte moviendo n en el bucle?
TheLethalCoder 07/28/2017
Además, esto no parece funcionar en este momento.
PunPun1000 07/28/2017
Te está faltando un paréntesis después del (a[n+=1+a[n]] . La función también arroja un error después de mostrar el valor correcto, no sé el consenso sobre si esto está permitido o no (la pregunta no decir cualquier cosa al error estándar es ignorar). Si esa era la intención, entonces puedes eliminar la n en el ciclo for. Finalmente, el código TIO no se ejecuta como está, incluso con el paréntesis. un Consumer y uso func.accept(test)

Martin Ender 07/28/2017.

Alice , 15 bytes

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

¡Pruébalo en línea!

Ingrese y genere una lista separada por líneas de enteros decimales.

Explicación

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

Almacenar un entero n en la cola del iterador hace que el siguiente comando se ejecute n veces. Los espejos como / no son comandos, por lo que el siguiente comando será I Por lo tanto, si solo leemos e imprimimos un valor x , leeremos x+1 valores en la siguiente iteración, y el último de ellos terminará en la parte superior de la pila. Esto omite los elementos de la lista de números requeridos.


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

Golfing adicional del fino método de user202729.

±NO 

Las reglas no parecen especificar explícitamente el formato de salida, así que tal vez:

±NO 

La salida para la segunda función se ve así: 0.2.4.{} - notablemente {} todavía se devuelve para un conjunto vacío, conforme a la regla final.

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO puede ser ±NO porque ± tiene una precedencia menor que Infix .
Mr.Wizard 07/28/2017
@JungHwanMin Me lo perdí; ¡Gracias!

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)& 

¡Pruébalo en línea!


w0lf 07/28/2017.

Ruby, 36 33 31

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

Pruébalo en línea.

4 comments
sethrin 07/30/2017
Puedes restar f= como un elemento de encabezado.
w0lf 07/30/2017
@sethrin ¿Incluso si necesito llamarlo recursivamente?
sethrin 07/30/2017
Hmm, buena pregunta. Supongo que no. Eso me gustó mucho sobre su solución, por cierto.
w0lf 07/30/2017
@sethrin ¡Gracias! :)

AnonymousReality 07/28/2017.

Swift, 63 bytes

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

Esta es mi primera entrada, nunca, así que no estoy 100% seguro de las reglas, pero espero que esta respuesta sea suficiente. Estoy un poco inseguro de las reglas sobre cómo obtener la entrada en un sistema. Tengo una respuesta más corta si se me permite asumir una función en alguna parte que puede devolver la entrada.

2 comments
Stephen 07/28/2017
Bienvenido a PPCG! Las reglas predeterminadas son que puede tener un código que funcione como un programa completo, por lo tanto ingrese (normalmente) en STDIN y envíe (normalmente) a STDOUT, or una función, ingrese (normalmente) desde los parámetros de la función y genere (normalmente) desde retorno de la función.
AnonymousReality 07/28/2017
@StepHen - gracias! Supongo que eso hace que mi otra versión sea inválida entonces. ¡Esperamos contribuir más!

Perl 6 , 31 bytes

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

Pruébalo

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 ayudar a comprender cómo funciona el código, sin [*;0] esto generaría una secuencia como la siguiente:

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

Common Lisp, 51 bytes

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

¡Pruébalo en línea!


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< 

Pruébalo en línea

Lo horrible (c/91?"":" ") Es el espacio correcto en la salida. Sin él (-15 bytes) la salida está en forma: [0,2,4] , cuando lo cambio a simple " " (-9 bytes) la salida es como [ 0, 2, 4] (espacio adicional al principio) .

<<(c/93?"":"]") en el extremo es solo para manejar [] entrada vacía

Imprime sin final de línea.

1 comments
Erik the Outgolfer 07/30/2017
También puede imprimir los números separados por un separador de no dígitos, sin necesidad de [] y puede tener salida vacía para ese borde de caso, y no es necesario (c/91?"":" ") . No tiene que coincidir con el formato de los ejemplos en el desafío.

Jonathan Allan 07/29/2017.

Jelly , 8 bytes

ḢṄ‘ṫ@µL¿ 

Un programa completo que imprime los resultados, cada uno seguido de una nueva línea (la lista vacía no produce ningún resultado).

Try it online!

¿Cómo?

ḢṄ‘ṫ@µ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 una respuesta Jelly! Por cierto, puedo hacerlo en 7 bytes.
Erik the Outgolfer 07/30/2017
Y también tengo una función de devolución de lista en 18 bytes.

Evpok 07/30/2017.

Python 3 , 35 bytes

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

¡Pruébalo en línea!

Ejecútelo con f(*l) donde l es su entrada. Podría decirse que estirar las reglas de entrada, pero me encanta el desembalaje avanzado.


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) 

Comienza con los parámetros iniciales [0 []] , donde 0 es el contador y [] es el resultado. Si el primer elemento en esta lista es 0 añade el elemento n del argumento al resultado y pasa más lejos esta lista [n [... n]] contrario, disminuye el primer elemento. (esta explicación me parece horrible)

Véalo en línea


Dead Possum 07/28/2017.

Python 2.4, 85 bytes

No hay posibilidad de ganar en python con él, pero me encantan los oneliners y este podría ser interesante para los demás.
Resulta que hay un truco de magia para acceder a la lista de construcción dentro de la comprensión, pero solo funciona en 2.4 y con algunas ediciones en <= 2.3.
locals()['_[1]'] es. Python crea el nombre secreto _[1] para la lista, mientras está creado y lo almacena en los locals . También los nombres _[2] , _[3] ... se usan para listas anidadas.

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

Entonces cuenta la cantidad de elementos ya agregados más su suma. El resultado es el índice del siguiente elemento deseado.
Creo que debería haber una forma de evitar enumerar. Me gusta acceder a la matriz de entrada directamente por índice: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] . Pero no puedo encontrar una manera compacta de protegerlo del índice fuera de rango (mientras lo mantiene en línea)

enter image description here


Neil 07/28/2017.

Lote, 69 bytes

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

(Necesito el () s () alrededor del otro caso, for contrario, el goto sucede dentro del bucle).

Related questions

Hot questions

Language

Popular Tags