Remova todos os N-ésimos N

41

A tarefa

Nesse desafio, sua entrada é uma lista não vazia de números inteiros positivos, fornecida no formato nativo do seu idioma. Sua saída é a mesma lista, no mesmo formato, com alguns elementos removidos. Você deve remover toda ocorrência 1, toda segunda ocorrência 2, toda terceira ocorrência 3, e assim por diante. Em geral, para cada número inteiro positivo N, você deve remover todas as Nocorrências da Nlista, começando com a Nocorrência.

Exemplo

Considere a lista de entrada

[3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2]

Primeiro, removemos todas as ocorrências de 1:

[3,2,6,    6,2,3,2,6,6,6,6,  6,6,3,3,7,2]

Então, a cada segunda ocorrência de 2:

[3,2,6,    6,  3,2,6,6,6,6,  6,6,3,3,7  ]

Em seguida, cada terceira ocorrência de 3:

[3,2,6,    6,  3,2,6,6,6,6,  6,6,  3,7  ]

Os números 4e 5não ocorrem na entrada, para que possam ser ignorados. Em seguida, removemos a sexta ocorrência de 6:

[3,2,6,    6,  3,2,6,6,6,    6,6,  3,7  ]

Há apenas uma ocorrência de 7, para que também possa ser ignorada. Assim, a saída correta é

[3,2,6,6,3,2,6,6,6,6,6,3,7]

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

[1] -> []
[2] -> [2]
[1,1,1] -> []
[2,2,2] -> [2,2]
[1,1,2,2,2,3,3,3,3] -> [2,2,3,3,3]
[1,2,3,1,2,3,1,2,3,1,2,3] -> [2,3,3,2,3]
[3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2] -> [3,2,6,6,3,2,6,6,6,6,6,3,7]
[5,4,5,4,3,5,4,5,4,5,4,3,5,4,5,3,3,3,4,5,4,5,4,5,4,3,3,3,5,4] -> [5,4,5,4,3,5,4,5,4,3,5,4,5,3,3,4,5,5,4,4,3,3,5,4]
[6,4,5,8,2,9,3,1,8,5,3,5,5,6,3,5,1,2,3,9,3,5,8,7,5,9,1,3,4,8,2,3,4,7,8,5,8,5,3,1] -> [6,4,5,8,2,9,3,8,5,3,5,5,6,3,9,3,5,8,7,5,9,4,8,2,3,4,7,8,5,8,5,3]
[4,4,9,12,9,4,4,4,12,9,12,9,12,4,12,4,4,9,4,9,12,4,12,4,4,12,4,4,9,12,9,12,9,4,9,12,4,9,12,9,12,9,4,9,12,12,4,4,12,4] -> [4,4,9,12,9,4,4,12,9,12,9,12,4,12,4,9,4,9,12,4,12,4,12,4,4,9,12,9,12,4,9,12,9,9,12,9,4,9,12,12,4,4,12]
[2,2,11,11,11,11,6,2,2,6,6,2,2,2,2,6,11,6,11,11,2,11,2,6,6,11,2,11,6,2,6,6,6,6,6,11,2,11,11,6,6,6,11,6,2,6,2,6,6,2,11,2,2,11,11,11,11,2,6,2] -> [2,11,11,11,11,6,2,6,6,2,2,6,11,6,11,11,2,11,6,11,2,11,6,6,6,6,6,2,11,11,6,6,6,11,6,2,6,6,11,2,11,11,11,11,2,6]
[20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102] -> [20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,101,102,20,21,22,100,102,20,21,22,100,101,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102]

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma. Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se você deseja incluir vários números no cabeçalho, verifique se a pontuação real é o último número no cabeçalho:

## Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar snippet de código

code-golf array-manipulation Zgarb
fonte

Respostas:

15

Geléia , 10 8 bytes

=;\S€%af

Graças ao @ Sp3000 por jogar fora 2 bytes!

Experimente online!

Como funciona

=;\S€%af    Main link. Input: A (list)

 ;\         Compute the cumulative concatenations of the elements of A, i.e., the
            list of A's prefixes.
=           Compare the elements of the nth prefix with the nth element of A.
   S€       Compute the sum of the resulting arrays.
     %      Take the nth sum modulo the nth element of A.
      a     Logical AND; replace the nth remainder with the nth element of A
            if the remainder is non-zero.
        f   Filter; remove the zeroes (which do not occur in A) from the result.
Dennis
fonte
como funciona essa etapa de comparação? e são os prefixos de [5,4,3,2,1] [[5], [5,4], [5,4,3], [5,4,3,2], [5,4, 3,2,1]] ou [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]?
quintopia 27/01
@ Quintopia Jelly é da esquerda para a direita, portanto é o primeiro. =compara números inteiros. Por exemplo, [3,2,1]=;\compara-se 3com o elemento de [3], 2com os de [3, 2]e 1com os de [3, 2, 1], dando [1, [0, 1], [0, 0, 1]].
Dennis
Ah, estava faltando que ele comparava uma lista com uma lista elemento a lista.
quintopia 27/01
34

awk, 10 bytes

A entrada é esperada no STDIN, um número por linha.

++a[$1]%$1

Explicação

Mantém um contador para cada número em uma matriz associativa, imprime apenas se o módulo do valor do contador nnão for zero. A impressão está implícita. Versão longa:

++a[$1]%$1{print $0}
Rainer P.
fonte
19

Pitão, 18 15 14 10 9 bytes

f%/aYTTTQ

Eu acho que este é o primeiro código que escrevi que tem cinco referências consecutivas de variáveis ​​em nove bytes.

Eu gostaria que a solução de manipulação de array ( u.DG%HgxHGH{QQ14 bytes) não fosse tão longa.

f%/aYTTTQ       Implicit: Q=input
                 lambda T:
    Y              Variable: starts as empty list.
   a T             Append T to Y. Mutates Y.
  /   T           Number of elts of Y that equal T.
 %     T         Modulo by T
f       Q       Filter that lambda over Q.

Experimente aqui .

lirtosiast
fonte
9

Python, 57 bytes

lambda l:[n for i,n in enumerate(l)if l[:i+1].count(n)%n]
xnor
fonte
8

Perl 6 , 28 bytes

{$_=$;grep {++.{$^n}%$n},@_} # 28 bytes
{
  $_=$;        # put $_ in a clean state
  grep {
    ++.{$^n}   # increment $_{ $n } and declare $n as an argument
    % $n       # check if the count is not divisible by $n
  }, @_        # the input
}

Uso:

# give it a lexical name for ease of use
my &code = {...}

sub check ( @a, @b ){
  say try { so all code(@a) »==« @b } // False
}

check [1], []; # True
check [2], [2]; # True
check [1,1,1], []; # True
check [2,2,2], [2,2]; # True
check [1,1,2,2,2,3,3,3,3], [2,2,3,3,3]; # True
check [1,2,3,1,2,3,1,2,3,1,2,3], [2,3,3,2,3]; # True
check [3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2], [3,2,6,6,3,2,6,6,6,6,6,3,7]; # True

Verifique se os elementos corretos estão sendo jogados fora

# have to change it to a pure number
# when checking $_         V
my &code = {$_=$;grep {++.{+$^n}%$n},@_}
# only matters here because we are using
# a subclass of Int but want it to use
# the same key as a normal Int

sub F ( Int $v ) { IntStr.new: $v, "Fail($v)" }
# prove that it passes through unchanged
say [F(2)];
# (Fail(2))

say code [3,2,6,F(1),F(1),6,F(2),3,2,6,6,6,F(6),F(1),6,6,F(3),3,7,F(2)];
# (3 2 6 6 3 2 6 6 6 6 6 3 7)
Brad Gilbert b2gills
fonte
7

Sério, 22 17 bytes

k╗,;`;;╜o;╗c%`M@░

Hex Dump:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Experimente Online

Explicação:

k╗                                Put empty list in reg0
  ,;                              Two copies of input
    `        `M                   Map over the list
     ;;                           Make 2 extra copies of n
       ╜o                         Load reg0 and push the n onto it
         ;╗                       Put a copy back in reg0
           c                      Count the number of copies of n in the list
            %                     Take the result modulo n
               @░                 Filter the original list with the resulting list
quintopia
fonte
10
Esta linguagem ...
Nico
6

JavaScript ES6, 34 bytes

a=>a.filter(v=>f[v]=-~f[v]%v,f=[])

Acabou sendo o mesmo que o algoritmo Perl de Brad.

Editar: salvou 2 bytes graças a @ edc65.

Neil
fonte
Boa! salve 2 bytes removendo os parênteses internosa=>a.filter(v=>f[v]=-~f[v]%v,f=[])
edc65
5

Mathematica, 40 38 36 bytes

Select[(f@#=#)&/@#,++f[#]~Mod~#>0&]&

Esta é uma função sem nome, que recebe e retorna a List. Ele define uma função nomeada fquando executada (para acompanhar os números), mas cuida de redefinir as definições relevantes de fantemão.

Explicação

O modo como as funções (ou definições de funções) funcionam no Mathematica é realmente poderoso. Como em Haskell (por exemplo), as funções não podem ser sobrecarregadas e definidas apenas para certos tipos, mas também para valores individuais (ou padrões arbitrários de argumentos, na verdade). Mas é ainda mais poderoso do que Haskell: a) esses valores podem ser definidos como efeitos colaterais durante o fluxo de controle eb) os valores também podem ser redefinidos a qualquer momento. Isso significa que as funções são, na verdade, tabelas de pesquisa bastante poderosas (que podem opcionalmente calcular o valor pesquisado em vez de apenas armazená-lo).

Se removermos a golfitude do código, ficaria assim:

g[list_] := (
  Map[
    (f[#] = #) &,
    list
  ];
  Select[
    list,
    Mod[++f[#], #] > 0 &
  ]
)

Então, primeiro, passamos o mouse sobre a entrada e definimos f[x] = x, para todos xna lista. fserá usado para acompanhar com que frequência cada número já apareceu na lista. Por que não contamos 0? O loop sobre a lista é a Map. A expressão f[x] = yretorna y(além de armazenar a definição da função). Portanto, configurando f[x]para x, o mapa será avaliado para a própria lista de entradas. Isso economiza dois bytes, porque não precisamos fornecer listexplicitamente novamente Select. Iniciar em xvez de 0não afeta o cálculo, pois estamos apenas interessados Mod[f[x], x].

(Normalmente, poderíamos simplesmente usar algo como f[_] = 0uma definição de fallback para evitar isso Map, mas não sabemos se nossa função já foi usada antes, o que deixaria alguns valores anteriores definidos que atrapalhariam nossa contagem.)

Em seguida, Selectfiltra a lista mantendo apenas os elementos em que a função sem nome passou como o segundo argumento gera True. Essa função primeiro incrementa o valor de f[x](onde xestá o elemento da lista atual), para contar as ocorrências e, em seguida, leva o módulo de contagem resultante x. Queremos descartar todos os elementos onde isso produz 0.

Martin Ender
fonte
5

CJam, 17 bytes

Lq~{:X+_Xe=X%},p;

Apenas bata ... J? Na verdade, não tenho certeza de quais são minhas expectativas para esse desafio. Observe que ""é a representação do CJam de uma matriz vazia.

Experimente online | Conjunto de testes (o último caso é muito longo para o link permanente)

Explicação

L                     Push empty array (let's call it L)
 q~                   Push input and evaluate

   {         },       Filter the array elements by...
    :X                   Save number to variable X
      +                  Append to L

       _                 Duplicate
        Xe=              Count occurences of X
           X%            Take modulo X

                      The top element is popped to determine whether or not to keep that
                      element, with the updated L kept on the stack for the next iteration

               p      Print the resulting filtered array
                ;     Pop L, which is now equal to the input array
Sp3000
fonte
4

JavaScript ES6, 55 bytes

a=>a.filter((v,i)=>a.filter((w,j)=>j<=i&v==w).length%v)

Explicação

a=>                            //a -> input array
 a.filter(                     //filter array. only keep elements if inside function returns truthy
      (v,i)=>                  //inside function to decide whether to keep items. v -> item; i -> index
           a.filter((w,j)=>    //get all ocurrences of v that occur before index i
                j<=i&v==w      //(this is done by keeping all items w at index j, if j <= i and v == w
           ).length%v          //get length (count ocurrences), and mod v.
                               //this will only be falsy if the number of ocurrences of v up to this index is divisible by v. (0 -> falsy, positive -> truthy) 
 )                             //so, we don't keep every second 2, every third 3, etc.
jrich
fonte
3

J, 18 bytes

#~((0<]|+/@:=){:)\

Uso:

   (#~((0<]|+/@:=){:)\) 1 2 3 1 2 3 1 2 3 1 2 3
2 3 3 2 3

Método bastante simples. Contamos as ocorrências de um número até ele e selecionamos o número apenas se o número dividir a contagem.

Mais explicações vêm depois.

Experimente online aqui.

randomra
fonte
2

PowerShell, 56 bytes

param($a)$b=,0*($a|sort)[-1];$a|%{if(++$b[$_-1]%$_){$_}}

Usa um truque auxiliar-matriz semelhante à resposta de Rainer P , que desenvolvi independentemente, mas aparentemente recebi o FGITW.

Recebe entrada como uma matriz com param($a). Em seguida, criamos nossa matriz auxiliar $bcomo uma matriz preenchida com zeros usando o operador de vírgula juntamente com o operador de multiplicação sobrecarregado. Isso cria $bpara ser igual a @(0,0,0...0)com $b.lengthigual ao número máximo em $a.
(Plugue rápido para minha resposta "Mostre seu idioma", onde descrevo isso em detalhes)

Em seguida é a nossa saída. Passamos por todos os elementos de nossa matriz de entrada $a|%{...}e cada loop verifica uma ifinstrução. O condicional pré-incrementa o valor em nossa matriz auxiliar que corresponde ao elemento atual e, em seguida, verifica se é um múltiplo do elemento atual com o operador módulo. Se for um múltiplo, a %vontade será igual a 0qual é falsey, para ifque não seja executada. Caso contrário, produzimos o elemento atual.

Aproveita a conversão de texto implícita para economizar na formatação da saída. Se uma função ou programa retornar vários elementos e você salvar os resultados em uma variável, o PowerShell criará dinamicamente essa variável como uma matriz. Exemplo:

PS C:\Tools\Scripts\golfing> $testc = .\remove-every-nth-n.ps1 @(2,2,2)

PS C:\Tools\Scripts\golfing> $testc
2
2

PS C:\Tools\Scripts\golfing> $testc.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------             
True     True     Object[]                                 System.Array
AdmBorkBork
fonte
1

R, 110 98 99 92 Bytes

function(a){for(i in 1:max(a))for(j in seq_along(b<-which(a==i)))if(j%%i<1)a[b[j]]=0;a[a>0]}

Edite erros de correção de reescrita completos com o caso de teste 2/3 Editar 2 Economize 7 bytes graças a @ Alex-A

mnel
fonte
11
92 bytes:function(a){for(i in 1:max(a))for(j in seq_along(b<-which(a==i)))if(j%%i<1)a[b[j]]=0;a[a>0]}
Alex A.
1

MATL , 20 bytes

tu"t@=f@@h0h)0w(]tg)

Isso usa a versão atual (10.2.1) do idioma / compilador.

Experimente online!

Explicação

tu        % implicitly input array. Duplicate and get unique elements
"         % for each unique element, say "i"
  t       % duplicate
  @=f     % indices of occurrences of i
  @@h0h   % build index representing i-th occurrences (Matlab's i:i:end)
  )       % keep only indices of i-th occurrences
  0w(     % set those entries to 0
]         % end for loop
tg)       % keep nonzeros only. Implicit display
Luis Mendo
fonte
1

R, 63 bytes

f=function(z){n=seq(z);for(i in n)z[which(z==i)[n*i]]=0;z[z>0]}
lambruscoAcido
fonte
1

C #, 224 bytes

List<int>R(List<int>l,int n=1){l=l.Where(w=>w!=0&&w!=1).ToList();for(int i=0,t=0;i<l.Count;i++){if(l[i]==n&&++t==n){l[i]=0;t=0;}}return !l.Any()||n>l.Max()?l:R(l,++n);}

Este código usa recursão. Com usinginstruções com 224 bytes (160 para o próprio código do método).

Experimente online.

List <int> R(List <int> l, int n = 1)
{
    l = l.Where(w => w > 1).ToList();
    for (int i = 0, t = 0; i < l.Count; i++)
    {
        if (l[i] == n && ++t == n)
        {
            l[i] = 0;
            t = 0;
        }
    }
    return !l.Any() || n > l.Max() ? l : R(l, ++n);
}
Dmitry Stepanov
fonte
Você poderá salvar alguns caracteres removendo a instrução continue. Algo como (não testado)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;
Peter Taylor
@ Peter Taylor, você está certo, obrigado. Além disso, tive que adicionar algum código para corrigir um bug.
Dmitry Stepanov
Se você importou System.Linq, !l.Any()é menor que l.Count<1, que é menor que l.Count==0.
Peter Taylor
@ peter-taylor obrigado, eu também substitui w != 0 && w !=1com w > 1.
Dmitry Stepanov
matrizes deve ser muito bom e que seria um pouco mais curto int [] R (int [] l, int n = 1)
raggy
0

C # - 177 bytes

void r(List<int> i){for(int c=1,k=1,m=i.Max();k<=m;k++){var n=new List<int>();foreach(var o in i)if(o==k&&c++==k)c = 1;else n.Add(o);i=n;}Console.WriteLine(string.Join(" ",i));}

Ungolfed

void r(List<int> i)
{
    for (int c = 1, k = 1, m = i.Max(); k <= m; k++)
    {
        var n = new List<int>();
        foreach (var o in i)
            if (o == k && c++ == k)
                c = 1;
            else
                n.Add(o);
        i = n;
    }
    Console.WriteLine(string.Join(" ", i));
}
Stephan Schinkel
fonte
4
Eu acredito que você precisaria contar as instruções using, caso em que isso teria 241 bytes de comprimento.
LegionMammal978
0

Mathematica, 63 bytes

Fold[Delete[#,Position[#,#2][[#2;;;;#2]]~Check~{}]&,#,Union@#]&

Muito interessante para o golfe! Ignore a mensagem ocasional que aparece.

LegionMammal978
fonte
0

Ruby, 120 bytes

->a{1.upto(a.max).each{|i|k=0;a.length.times.each{|j|k+=1if a[j]==i;a[j]=''if k%i==0&&a[j]==i;a[j]}};a.select{|i|i!=''}}
Connor Clark
fonte
0

TI-BASIC, 47 bytes

Input X
For(I,1,dim(∟X
∟X(I
If fPart(sum(∟X=Ans),1,I)/Ans
Ans→L₁(1+dim(L₁
End
L₁

Isso usa o fato de que, em uma calculadora nova, L₁é inicializado e limpo. Observe que tentar exibir uma lista vazia no TI-BASIC gera um erro.

lirtosiast
fonte
0

APL, 16 caracteres

{⍵/⍨×⍵|+/¨⍵=,\⍵}

Em inglês:

  • ,\⍵: vetor do vetor prefixa até o enésimo elemento do argumento
  • +/¨⍵=: por vetor de prefixo, conte quantos são iguais ao n-ésimo elemento em si
  • ×⍵|: sinais dos mods (ou seja: 0 se o restante da divisão for 0, 1 caso contrário)
  • ⍵/⍨: do argumento mantém apenas o elemento em que o mod é 0
lstefano
fonte
0

Raquete 179 bytes

(λ(l)(define m(apply max l))(let g((n 1)(c 0))(set! l(for/list((i l))(if(= i n)(begin 
(set! c(+ 1 c))(if(= 0(modulo c n))0 i))i)))(if(< n m)(g(+ 1 n)0)(filter(λ(x)(> x 0))l))))

Ungolfed:

(define f
  (λ(l)
    (define m (apply max l))
    (let loop ((n 1) (c 0))
      (set! l (for/list ((i l))
                (if (= i n)
                    (begin
                      (set! c (+ 1 c))
                      (if (= 0 (modulo c n))
                          0 i ))                  ; replace by 0
                    i )))
      (if (< n m)
          (loop (+ 1 n) 0)
          (filter (λ(x)(> x 0)) l)                ; remove all 0s
          ))))

Teste: 

(f '[1]) 
(f '[2]) 
(f '[1 1 1]) 
(f '[2 2 2]) 
(f '[1 1 2 2 2 3 3 3 3])
(f '[1 2 3 1 2 3 1 2 3 1 2 3]) 
(f '[3 2 6 1 1 6 2 3 2 6 6 6 6 1 6 6 3 3 7 2])

Saída:

'()
'(2)
'()
'(2 2)
'(2 2 3 3 3)
'(2 3 3 2 3)
'(3 2 6 6 3 2 6 6 6 6 6 3 7)
rnso
fonte