Dada uma matriz de números inteiros não negativos, sua tarefa é manter apenas alguns elementos, conforme descrito abaixo.

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

• Primeiro, obtenha o primeiro elemento da matriz n,. Mantenha os primeiros nelementos e descarte o próximo (descarte o dia n+1). A nova matriz é [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Então, você pega o elemento após o removido e faz exatamente a mesma coisa. Reaplicando o processo, obtemos[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Você repete o processo até chegar fora dos limites da matriz / não há elementos restantes na matriz. Paramos porque 11é maior que o comprimento da matriz.

• Agora você deve gerar o resultado.

A entrada / saída pode ser obtida / fornecida em qualquer formato padrão. A matriz nunca estará vazia e conterá apenas números inteiros não negativos. Todas as brechas padrão são proibidas.

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

Casos de teste

Entrada -> Saída

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

* O último caso de teste envolve 0, então decidi postar o processo para que fique mais claro:

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

^{( Inspirado por este desafio de Erik, o Outgolfer )}

Pitão, 18 bytes

#IgZlQB .(Q=Z@QZ)Q

Experimente aqui.

JavaScript (ES6), 45 bytes

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

Casos de teste

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:)é uma função anônima que recebe e retorna uma lista de Ints, use como (g.pure.(0:))[1,2,3,4,5].

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

Experimente online!

Como funciona

• A função gusa um argumento de tupla representando uma lista dividida. aé a lista de elementos iniciais mantidos na etapa anterior, _é o elemento a ser descartado, bé o próximo elemento a ser usado como um comprimento e cos elementos restantes.
  • Se houver elementos suficientes na segunda parte da tupla para selecionar a b, uma nova divisão será executada e gocorrerá novamente. Caso contrário, ele será interrompido acomo resultado.
• A função anônima g.pure.(0:)inicia tudo chamando gcom a tupla ([],0:l), onde lestá a entrada e 0é imediatamente descartada por g.
  • pureaqui usa a Applicativeinstância para tuplas (binárias) e, com o tipo de resultado, ([Int],[Int])coloca convenientemente seu argumento como o segundo elemento em uma tupla com []o primeiro 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

Experimente online!

Haskell , 51 bytes

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

Experimente online! Exemplo de utilização: f [1,2,3,4,5].

Java 8, 68 bytes

Este lambda aceita um mutável List<Integer>(suporta remove(int), por exemplo ArrayList). Saída com entrada mutada. Atribuir 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);}

Experimente Online

O fluxo de controle para esse problema é muito irritante. A cada iteração, precisamos remover um elemento e colocá-lo na próxima posição, e ambas as operações requerem uma verificação de alcance (e podem acionar a conclusão do programa). Uma estratégia é realizar as duas operações em uma iteração de loop único, com a atualização do índice protegida por sua própria verificação de intervalo. Outra estratégia, que acabou sendo mais curta, é alternar entre as operações de cada iteração de loop, que é o que esta solução faz.

APL (Dyalog Classic) , 32 bytes

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

Explicação

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

Experimente online!

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

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

Experimente online!

Haskell, 99 bytes (88 sem recuo)

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 + ?, e <Esc>para Escape, obviamente. Cada um deles conta com 1 byte (consulte meta ).

Entrada

O arquivo de entrada deve conter 1 número inteiro por linha + 1 linha em branco no final, exemplo:

1
2
3
4
5
⁣

Podemos ver cada linha do arquivo de entrada como um elemento de matriz 1 :: 2 :: 3 :: 4 :: 5 :: [], como em alguns idiomas (caml, por exemplo).

Lançamento

Você pode iniciar o vi com o seguinte comando e digitar o traço da solução por traço:

vi -u NONE input

Você também pode 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

Isso deve produzir um arquivo outputcom o resultado correto de um arquivo de entrada input.

Explicações

Para apresentar a solução, apresentarei primeiro uma solução de 19 bytes que funciona apenas para matrizes sem 0. Essa solução usa uma macro recursiva, usada com poucas modificações na solução final:

Yqa@0ddYgg@aquggY@a

Explicação de uma solução 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

O truque aqui é usar o "0registrador para armazenar o número inteiro atual (e a quebra de linha, muito importante). Portanto, o comando @0permite pular nlinhas (chame no valor de "0). Se o salto exceder o número de linhas no arquivo, a macro falhará e o programa será interrompido (fora dos limites da matriz, conforme necessário).

Mas esta solução não funciona se a entrada contiver 0. De fato, se o "0valor do registro for igual 0, então @0pulará uma linha (devido à quebra de linha), não 0como gostamos. Portanto, o próximo comando ( dd) não excluirá o 0º número inteiro, mas o 1º (não correto).

Uma solução válida para lidar com o 0é sempre incrementar o número inteiro antes de puxá-lo e diminuí-lo logo depois. Assim, o @0comando irá pular n+1linhas ( né o número inteiro atual que foi incrementado). É knecessário um comando para ir para a linha n(linha anterior). Usando esse truque, é necessária uma linha em branco no final do arquivo de entrada, para evitar pular fora da matriz (encerrando o programa), já que agora sempre pulamos as n+1linhas antes de pular para a linha anterior.

Explicação da solução 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)

Escrever o conteúdo da macro dentro do arquivo antes de registrá-lo permite salvar alguns bytes:

• evita escrever qa...qe desfazer todas as alterações após o registro
• evita :let @a="...")

Editar% s

# 1

• escreva o conteúdo da macro na primeira linha (em vez da última linha)
• alterar entrada (1 linha em branco no final)
• adicione uma linha para testar na linha de comando

Pitão, 32 bytes

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

Experimente online

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

Experimente online!

Isso pega uma lista de entradas e a modifica. Eu vi algumas respostas Java que contornam as importações usando o nome completo na definição de argumento Lambda. Se isso não for permitido, posso remover esta resposta.

R , 64 53 bytes

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

Função recursiva. Possui uma entrada obrigatória,, aa lista a ser pulada. ié o índice do número de itens a serem saltados (o padrão é 1) e dé o índice do próximo item após a remoção do valor necessário, que também é o índice do item a ser removido. Retorna numeric(0), um vetor vazio, para saída vazia.

Experimente online!

Ungolfed:

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