Usuń co N-ty N.

41

Zadanie

W tym wyzwaniu twoja wejściowa informacja jest niepustą listą liczb całkowitych dodatnich, podaną w natywnym formacie twojego języka. Twój wynik to ta sama lista, w tym samym formacie, z usuniętymi niektórymi elementami. Usuniesz każde wystąpienie 1, każde drugie wystąpienie 2, co trzecie wystąpienie 3i tak dalej. Zasadniczo dla każdej dodatniej liczby całkowitej Nnależy usunąć każde Nwystąpienie Nz listy, zaczynając od Ntego wystąpienia.

Przykład

Rozważ listę danych wejściowych

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

Najpierw usuwamy każde wystąpienie 1:

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

Następnie co drugie wystąpienie 2:

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

Następnie co trzecie wystąpienie 3:

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

Liczby 4i 5nie pojawiają się na wejściu, więc można je pominąć. Następnie usuwamy co szóste wystąpienie 6:

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

Występuje tylko jedno wystąpienie 7, więc można je również pominąć. Zatem prawidłowe wyjście to

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

Zasady i punktacja

Możesz napisać pełny program lub funkcję. Wygrywa najniższa liczba bajtów, a standardowe luki są niedozwolone.

Przypadki testowe

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

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka. Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz dołączyć wiele liczb do nagłówka, upewnij się, że faktyczny wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Pokaż fragment kodu

code-golf array-manipulation Zgarb
źródło

Odpowiedzi:

15

Galaretka , 10 8 bajtów

=;\S€%af

Dzięki @ Sp3000 za grę w golfa z 2 bajtów!

Wypróbuj online!

Jak to działa

=;\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
źródło
jak działa ten krok porównania? i są prefiksami [5,4,3,2,1] [[5], [5,4], [5,4,3], [5,4,3,2], [5,4, 3,2,1]] lub [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]?
kwintopia
@ Galaretka jest od lewej do prawej, więc jest pierwsza. =porównuje liczby całkowite. Na przykład [3,2,1]=;\porównuje się 3z elementem [3], 2z [3, 2]i 1z [3, 2, 1], dawania [1, [0, 1], [0, 0, 1]].
Dennis
Ach, brakowało mi, że porównuje listę z listą element po liście.
kwintopia
34

awk, 10 bajtów

Dane wejściowe są oczekiwane na STDIN, jedna liczba na linię.

++a[$1]%$1

Wyjaśnienie

Utrzymuje licznik dla każdej liczby w tablicy asocjacyjnej, drukuje tylko wtedy, gdy modulo wartości licznika nnie jest równe zero. Drukowanie jest niejawne. Długa wersja:

++a[$1]%$1{print $0}
Rainer P.
źródło
19

Pyth, 18 15 14 10 9 bajtów

f%/aYTTTQ

Myślę, że to pierwszy kod, który napisałem, który ma pięć kolejnych odwołań do zmiennych w dziewięciu bajtach.

Chciałbym, żeby rozwiązanie do manipulacji tablicą ( u.DG%HgxHGH{QQ14 bajtów) nie było tak długie.

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.

Wypróbuj tutaj .

lirtosiast
źródło
9

Python, 57 bajtów

lambda l:[n for i,n in enumerate(l)if l[:i+1].count(n)%n]
xnor
źródło
8

Perl 6 , 28 bajtów

{$_=$;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
}

Stosowanie:

# 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

Dokładnie sprawdź, czy wyrzucane są właściwe elementy

# 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
źródło
7

Poważnie, 22 17 bajtów

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

Hex Dump:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Wypróbuj online

Wyjaśnienie:

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
kwintopia
źródło
10
Ten język ...
Nico
6

JavaScript ES6, 34 bajty

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

Okazało się, że jest taki sam jak algorytm Perla Brada.

Edycja: Zapisano 2 bajty dzięki @ edc65.

Neil
źródło
Dobry! zapisz 2 bajty usuwając nawiasy wewnętrznea=>a.filter(v=>f[v]=-~f[v]%v,f=[])
edc65
5

Mathematica, 40 38 36 bajtów

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

Jest to nienazwana funkcja przyjmująca i zwracająca a List. Definiuje nazwaną funkcję fpodczas wykonywania (aby śledzić liczby), ale dba o wcześniejsze zresetowanie odpowiednich definicji f.

Wyjaśnienie

Sposób działania funkcji (lub definicji funkcji) w Mathematica jest naprawdę potężny. Podobnie jak w przypadku Haskell (na przykład) funkcje nie mogą być przeciążone i zdefiniowane tylko dla niektórych typów, ale także dla poszczególnych wartości (lub w rzeczywistości dowolnych wzorów argumentów). Ale jest nawet mocniejszy niż Haskell, ponieważ a) wartości te można zdefiniować jako skutki uboczne podczas przepływu kontrolnego ib) wartości można również w dowolnym momencie przedefiniować. Oznacza to, że funkcje są w rzeczywistości dość potężnymi tabelami odnośników (które mogą opcjonalnie obliczyć szukaną wartość zamiast po prostu ją przechowywać).

Jeśli usuniemy golfitude z kodu, wyglądałoby to trochę tak:

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

Najpierw zapętlamy dane wejściowe i definiujemy f[x] = xdla wszystkich xna liście. fzostaną ostatecznie wykorzystane do śledzenia, jak często każda liczba pojawia się już na liście. Dlaczego nie liczymy 0? Pętla nad listą to Map. f[x] = yZwraca wyrażenie y(oprócz przechowywania definicji funkcji). Ustawiając f[x]na x, mapa będzie oceniać samą listę danych wejściowych. To oszczędza dwa bajty, ponieważ wtedy nie musimy listponownie podawać tego wprost Select. Rozpoczęcie od xzamiast w 0ogóle nie wpływa na obliczenia, ponieważ jesteśmy tylko zainteresowani Mod[f[x], x].

(Zwykle możemy po prostu użyć czegoś w rodzaju f[_] = 0definicji rezerwowej, aby tego uniknąć Map, ale nie wiemy, czy nasza funkcja była wcześniej używana, co pozostawiłoby pewne wcześniejsze zdefiniowane wartości, które mogłyby popsuć nasze liczenie.)

Następnie Selectfiltruje listę, zachowując tylko te elementy, w których przekazano funkcję bez nazwy, gdy pojawia się drugi argument True. Ta funkcja najpierw zwiększa wartość f[x](gdzie xjest bieżącym elementem listy), aby policzyć wystąpienia, a następnie pobiera wynikowy moduł modulo x. Chcemy odrzucić wszystkie elementy, w których to daje 0.

Martin Ender
źródło
5

CJam, 17 bajtów

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

Po prostu pobij ... J? Nie jestem pewien, jakie są moje oczekiwania w związku z tym wyzwaniem. Zauważ, że ""CJam reprezentuje pustą tablicę.

Wypróbuj online | Zestaw testowy (ostatni przypadek jest za długi dla bezpośredniego łącza)

Wyjaśnienie

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
źródło
4

JavaScript ES6, 55 bajtów

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

Wyjaśnienie

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
źródło
3

J, 18 bajtów

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

Stosowanie:

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

Dość prosta metoda. Liczymy wystąpienia liczby do niej i wybieramy liczbę tylko wtedy, gdy liczba dzieli liczbę.

Więcej wyjaśnień pojawi się później.

Wypróbuj online tutaj.

randomra
źródło
2

PowerShell, 56 bajtów

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

Używa podobnej sztuczki pomocniczej jak odpowiedź Rainera P , którą opracowałem niezależnie, ale najwyraźniej dostałem FGITW.

Pobiera dane wejściowe jako tablicę z param($a). Następnie tworzymy naszą tablicę pomocniczą $bjako tablicę wypełnioną zerami za pomocą operatora przecinka w połączeniu z przeciążonym operatorem mnożenia. Tworzy $bto być równa @(0,0,0...0)z $b.lengthrówną maksymalnej liczbie w $a.
(Quick wtyczka do mojego „Zaprezentuj swój język” odpowiedź gdzie opiszę to szczegółowo)

Następny jest nasz wynik. Pętlimy każdy element naszej tablicy wejściowej, $a|%{...}a każda pętla sprawdza ifinstrukcję. Warunkowe wstępne zwiększenie wartości w naszej tablicy pomocniczej, która odpowiada bieżącemu elementowi, a następnie sprawdza, czy jest to wielokrotność bieżącego elementu z operatorem modulo. Jeśli jest wielokrotnością, %będzie równa 0falsey, więc ifnie wykonuje się. W przeciwnym razie wyprowadzamy bieżący element.

Wykorzystuje niejawne rzutowanie typów, aby zaoszczędzić na formatowaniu wyjściowym. Jeśli funkcja lub program zwraca wiele elementów, a wyniki są zapisywane w zmiennej, PowerShell dynamicznie utworzy tę zmienną jako tablicę. Przykład:

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
źródło
1

R, 110 98 99 92 bajtów

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

Edytuj kompletne przepisywanie naprawia błąd w przypadku testowym 2/3 Edytuj 2 Zapisz 7 bajtów dzięki @ Alex-A

mnel
źródło
1
92 bajty: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 bajtów

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

Używa bieżącej wersji (10.2.1) języka / kompilatora.

Wypróbuj online!

Wyjaśnienie

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
źródło
1

R, 63 bajty

f=function(z){n=seq(z);for(i in n)z[which(z==i)[n*i]]=0;z[z>0]}
lambruscoAcido
źródło
1

C #, 224 bajty

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

Ten kod używa rekurencji. Z usinginstrukcjami, które mają 224 bajty (160 dla samego kodu metody).

Wypróbuj 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);
}
Dmitrij Stiepanow
źródło
Powinieneś być w stanie zapisać kilka znaków usuwając instrukcję Kontynuuj. Coś jak (niesprawdzone)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;
Peter Taylor
@ Peter-Taylor, masz rację, dzięki. Ponadto musiałem dodać kod, aby naprawić błąd.
Dmitrij Stiepanow
Jeśli importowane System.Linqnastępnie !l.Any()jest krótszy niż l.Count<1, który jest krótszy niż l.Count==0.
Peter Taylor
@ peter-taylor dzięki, ja też wymienić w != 0 && w !=1z w > 1.
Dmitrij Stiepanow
tablice też powinny być dobre i byłyby nieco krótsze int [] R (int [] l, int n = 1)
obszarpany
0

C # - 177 bajtów

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

Bez golfa

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
źródło
4
Sądzę, że musiałbyś policzyć instrukcje użycia, w takim przypadku miałoby to 241 bajtów.
LegionMammal978
0

Mathematica, 63 bajty

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

Całkiem interesujące dla golfa! Zignoruj ​​pojawiające się od czasu do czasu wiadomości.

LegionMammal978
źródło
0

Rubin, 120 bajtów

->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
źródło
0

TI-BASIC, 47 bajtów

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

Wykorzystuje to fakt, że na nowym kalkulatorze L₁jest inicjowany i czyszczony. Zauważ, że próba wyświetlenia pustej listy w TI-BASIC powoduje błąd.

lirtosiast
źródło
0

APL, 16 znaków

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

Po angielsku:

  • ,\⍵: wektor prefiksów wektora aż do n-tego elementu argumentu
  • +/¨⍵=: na wektor przedrostka, policz, ile jest równych n-temu samemu elementowi
  • ×⍵|: znaki modów (czyli: 0, jeśli pozostała część podziału to 0, w przeciwnym razie 1)
  • ⍵/⍨: argumentu zachowuje tylko element, w którym mod wynosi 0
lstefano
źródło
0

Rakieta 179 bajtów

(λ(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))))

Nie golfowany:

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

Testowanie: 

(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])

Wynik:

'()
'(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
źródło