Dada una serie de enteros no negativos, su tarea es mantener solo ciertos elementos, como se describe a continuación.

• Digamos que la matriz es [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• En primer lugar obtener el primer elemento de la matriz, n. Mantenga los primeros nelementos y descarte el siguiente (descarte el n+1th). La nueva matriz es [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Luego, agarras el elemento que sigue al eliminado y haces exactamente lo mismo. Volviendo a aplicar el proceso, obtenemos[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Repite el proceso hasta llegar fuera de los límites de la matriz / no quedan elementos en la matriz. Nos detenemos porque 11es mayor que la longitud de la matriz.

• Ahora deberías generar el resultado.

La entrada / salida se puede tomar / proporcionar en cualquier forma estándar. La matriz nunca estará vacía, y solo contendrá enteros no negativos. Todas las lagunas estándar están prohibidas.

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

Casos de prueba

Entrada -> Salida

[1, 2, 3, 4, 5] -> [1, 3, 4]

[6, 1, 0, 5, 6] -> [6, 1, 0, 5, 6]

[1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1] -> [1, 2, 11, 5, 2, 0, 13, 10, 1]

[2, 2, 2, 2, 2, 2] -> [2, 2]

[1, 2, 3, 1, 2, 3, 1, 2, 3] -> [1, 2]

[3, 1, 2, 4, 0] -> [] *

* El último caso de prueba implica 0, así que decidí publicar el proceso de manera que sea más claro:

[3, 1, 2, 4, 0] --> [3, 1, 2, 0] --> [1, 2, 0] --> [1, 0] --> [0] --> [] )

^{( Inspirado en este desafío por Erik the Outgolfer )}

Pyth, 18 bytes

#IgZlQB .(Q=Z@QZ)Q

Pruébalo aquí.

JavaScript (ES6), 45 bytes

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

Casos de prueba

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

console.log(JSON.stringify(f([1, 2, 3, 4, 5]))) // --> [1, 3, 4]
console.log(JSON.stringify(f([6, 1, 0, 5, 6]))) // --> [6, 1, 0, 5, 6]
console.log(JSON.stringify(f([1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]))) // --> [1, 2, 11, 5, 2, 0, 13, 10, 1]
console.log(JSON.stringify(f([2, 2, 2, 2, 2, 2]))) // --> [2, 2]
console.log(JSON.stringify(f([1, 2, 3, 1, 2, 3, 1, 2, 3]))) // -> [1, 2]
console.log(JSON.stringify(f([3, 1, 2, 4, 0]))) // --> []

Haskell , 50 bytes

g.pure.(0:)es una función anónima que toma y devuelve una lista de Ints, use as (g.pure.(0:))[1,2,3,4,5].

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

Pruébalo en línea!

Cómo funciona

• La función gtoma un argumento de tupla que representa una lista dividida. aes la lista de elementos iniciales que se mantuvo en el paso anterior, _es el elemento que se descartará, bes el siguiente elemento que se utilizará como longitud y cson los elementos restantes.
  • Si hay suficientes elementos en la segunda parte de la tupla para seleccionar a b, se realiza una nueva división y se grepite. De lo contrario, se detiene acomo resultado.
• La función anónima g.pure.(0:)comienza todo llamando gcon la tupla ([],0:l), donde lestá la entrada y 0se descarta de inmediato g.
  • pureaquí usa la Applicativeinstancia para tuplas (binarias), y con el tipo de resultado ([Int],[Int])coloca convenientemente su argumento como el segundo elemento en una tupla con []como primer elemento.

Python 3 , 59 bytes

f=lambda a,i=0:f(a[:a[i]]+a[a[i]+1:],a[i])if i<len(a)else a

Pruébalo en línea!

Haskell , 51 bytes

f s=s%s
s%(n:_)|(x,_:z)<-splitAt n s=(x++z)%z
s%_=s

Pruébalo en línea! Ejemplo de uso: f [1,2,3,4,5].

Java 8, 68 bytes

Esta lambda acepta un mutable List<Integer>(soporta remove(int), por ejemplo ArrayList). La salida es entrada mutada. Asignar a Consumer<List<Integer>>.

l->{for(int i=0,f=0;i<l.size();f^=1)i=f>0?l.remove(i)*0+i:l.get(i);}

Pruébalo en línea

El flujo de control para este problema es muy molesto. Cada iteración tenemos que eliminar un elemento y colocar el elemento en la siguiente posición, y ambas operaciones requieren una verificación de rango (y cualquiera de ellas puede activar la finalización del programa). Una estrategia es llevar a cabo ambas operaciones en una iteración de bucle único, con la actualización del índice protegida por su propia verificación de rango. Otra estrategia, que resultó ser más corta, es alternar entre las operaciones de cada iteración de bucle, que es lo que hace esta solución.

APL (Dyalog Classic) , 32 bytes

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

Explicación

1∘{                             } bind 1 as starting left argument (⍺)
                             ⍳≢⍵  generate indexes for right argument (⍵)
                   (n←1+⍺⊃⍵)      n is 1+item at position ⍺ 
              w←⍵/⍨         ≠     w is ⍵ with item at n removed
   n∇⍣(n≤≢w)⊢                     recurse with n as left and w as right arg if n <= length of w

Pruébalo en línea!

Perl 5 , 38 + 1 (-a) = 39 bytes

splice@F,$p=$F[$p],1while$p<@F;say"@F"

Pruébalo en línea!

Haskell, 99 bytes (88 sin sangría)

f x y
 |y>=l=f x$l-1
 |e>=l=x
 |True=f (take e x ++ drop (1+e) x) e
 where e=x!!y
       l=length x

VI, 31 25 bytes

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?>corresponde a Control + ?, y <Esc>que Escapeobviamente. Cada uno de estos cuenta para 1 byte (ver meta ).

Entrada

El archivo de entrada debe contener 1 entero por línea + 1 línea en blanco al final, por ejemplo:

1
2
3
4
5
⁣

Podemos ver cada línea del archivo de entrada como un elemento de matriz, como, por ejemplo 1 :: 2 :: 3 :: 4 :: 5 :: [], en algunos idiomas (caml, por ejemplo).

Lanzamiento

Puede iniciar vi con el siguiente comando y escribir la solución trazo a trazo:

vi -u NONE input

También puedes usar este one-liner:

vi -u NONE -c ':exec "norm O@0kdd\<C-v>\<C-a>Y\<C-v>\<C-x>gg@a\<Esc>\"add\<C-a>Y\<C-x>@a"' -c ":w output" -c ':q' input

Esto debería producir un archivo outputcon el resultado correcto de un archivo de entrada input.

Explicaciones

Para presentar la solución, primero presentaré una solución de 19 bytes que funcione solo para matrices sin 0. Esta solución utiliza una macro recursiva, utilizada con poca modificación en la solución final:

Yqa@0ddYgg@aquggY@a

Explicación de una solución parcial.

Y                       # yank first line (first integer + line break) to "0 register
 qa                     # start recording a macro ("a register)
   @0                   # jump n lines, where n is the content of the "0 register
     dd                 # delete the current line (n+1th line)
       Y                # yank current line (integer after the previously deleted line)
        gg              # go back to the first line
          @a            # recurse on macro "a"
            q           # finish recording the macro
             u          # cancel modifications done by the execution of the macro
              gg        # go back to the first line
                Y@a     # apply the recorded macro with first parameter equal to the first integer

El truco aquí es usar el "0registro para almacenar el entero actual (y el salto de línea, muy importante). Por lo tanto, el comando @0permite saltar nlíneas (llamar nal valor de "0). Si el salto excede el número de líneas en el archivo, la macro fallará, por lo que el programa se detendrá (fuera de los límites de la matriz, según sea necesario).

Pero esta solución no funciona si la entrada contiene 0. De hecho, si el "0valor del registro es igual 0, entonces @0saltará una línea (debido al salto de línea), no 0como nos gustó. Entonces, el siguiente comando ( dd) no eliminará el 0º entero, sino el primero (no es correcto).

Una solución válida para manejar el 0es incrementar siempre el número entero antes de tirarlo, y disminuirlo justo después. Por lo tanto, el @0comando saltará n+1líneas ( nes el número entero actual que se ha incrementado). kEntonces se necesita un comando para ir a la línea n(línea anterior). Usando este truco, se necesita una línea en blanco al final del archivo de entrada, para evitar saltar fuera de la matriz (por lo tanto, terminar el programa), ya que ahora siempre saltamos n+1líneas, antes de saltar a la línea anterior.

Explicación de la solución final.

O                                                       # insert a new line at the beginning of the file, enter insert mode to write the macro content
 @0                                                     # jump n lines                                                       
   k                                                    # go to the previous line
    dd                                                  # delete this line
      <C-v><C-a>                                        # type Control+A (C-v is needed because we are in insert mode) to increment the current integer
                Y                                       # yank the incremented integer
                 <C-v><C-x>                             # decrement the current integer
                           gg                           # go to the first line
                             @a                         # recurse on macro "a"
                               <Esc>                    # exit insert mode : at this step, the first line of the file contains the macro content @0kdd^AY^Xgg@a
                                    "add                # copy @0kdd^AY^Xgg@a line to the register "a and delete the line
                                        <C-a>           # increment the first integer
                                             Y          # yank it (into "0)
                                              <C-x>     # decrement the first integer
                                                   @a   # apply macro in a" (initial @0 will jump n+1 lines, since we incremented the first integer before calling the macro)

Escribir el contenido macro dentro del archivo antes de registrarlo permite guardar algunos bytes:

• evita escribir qa...qy deshacer todos los cambios después de registrarse
• evita :let @a="...")

Ediciones

# 1

• escriba el contenido de la macro en la primera línea (en lugar de la última línea)
• cambiar entrada (1 línea en blanco al final)
• agregue una línea para probar en la línea de comandos

Pyth, 32 bytes

VlQIgNlQBK@QNI!K=QYBIgKlQB.(QK;Q

Pruébalo en línea

C # (.NET Core) , 74 bytes

n=>{for(int i=n[0];i<n.Count;){n.RemoveAt(i);i=i<n.Count?n[i]:n.Count+1;}}

Pruébalo en línea!

Esto toma una lista de entradas y la modifica. He visto algunas respuestas de Java que eluden las importaciones utilizando el nombre completo en la definición del argumento Lambda. Si esto no está permitido, puedo eliminar esta respuesta.

R , 64 53 bytes

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

Función recursiva. Tiene una entrada obligatoria a, la lista para omitir. ies el índice de la cantidad de cosas sobre las que se debe saltar (valor predeterminado 1) y des el índice del siguiente elemento después de que se haya eliminado el valor requerido, que también es el índice del elemento que se eliminará. Devuelve numeric(0), un vector vacío, para salida vacía.

Pruébalo en línea!

Sin golf:

f <- function(a, i = 1, d = a[i] + 1) {
  if(is.na(d)) {   # d is NA if and only if a[i] is out of bounds
    a
  } else {
    f( a[-d], d, a[d] + 1 )   # a[-d] is a with the item at index d removed
  }
}