Entferne jedes N-te N

41

Die Aufgabe

Bei dieser Herausforderung handelt es sich bei Ihrer Eingabe um eine nicht leere Liste positiver Ganzzahlen, die im systemeigenen Format Ihrer Sprache angegeben wird. Ihre Ausgabe ist dieselbe Liste im selben Format, wobei einige Elemente entfernt wurden. Sie müssen jedes Vorkommen 1, jedes zweite Vorkommen 2, jedes dritte Vorkommen 3usw. entfernen . Im Allgemeinen müssen Sie für jede positive ganze Zahl Njedes NVorkommen von Naus der Liste entfernen , beginnend mit dem Nachten Vorkommen.

Beispiel

Betrachten Sie die Eingabeliste

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

Zunächst entfernen wir jedes Vorkommen von 1:

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

Dann jedes zweite Vorkommen von 2:

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

Dann jedes dritte Vorkommen von 3:

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

Die Zahlen 4und 5kommen in der Eingabe nicht vor, sodass sie übersprungen werden können. Als nächstes entfernen wir jedes sechste Vorkommen von 6:

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

Es gibt nur ein Vorkommen von 7, sodass auch dieses übersprungen werden kann. Somit ist die korrekte Ausgabe

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

Regeln und Wertung

Sie können entweder ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Testfälle

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

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren. Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten, stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Code-Snippet anzeigen

code-golf  array-manipulation 
— Zgarb
quelle

Antworten:

15

Jelly , 10 8 Bytes

=;\S€%af

Vielen Dank an @ Sp3000 für das Golfen mit 2 Bytes!

Probieren Sie es online!

Wie es funktioniert

=;\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
quelle
Wie funktioniert dieser Vergleichsschritt? und sind die Präfixe von [5,4,3,2,1] [[5], [5,4], [5,4,3], [5,4,3,2], [5,4, 3,2,1]] oder [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]?
— Quintopia
@quintopia Jelly ist von links nach rechts, also ist es das erste. =vergleicht ganze Zahlen. [3,2,1]=;\Vergleicht zum Beispiel 3mit dem Element des Gebens [3], 2mit dem des Gebens [3, 2]und 1mit dem des [3, 2, 1]Gebens [1, [0, 1], [0, 0, 1]].
— Dennis
Ah, es fehlte mir, dass eine Liste mit einer Liste Element-für-Liste verglichen wurde.
— Quintopia
34

awk, 10 bytes

Die Eingabe erfolgt über STDIN, eine Nummer pro Zeile.

++a[$1]%$1

Erläuterung

Behält einen Zähler für jede Zahl in einem assoziativen Array bei und druckt nur, wenn der Zählerwert modulo nnicht Null ist. Drucken ist implizit. Lange Version:

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

Pyth, 18 15 14 10 9 Bytes

f%/aYTTTQ

Ich denke, dies ist der erste Code, den ich geschrieben habe und der fünf aufeinander folgende Variablenreferenzen in neun Bytes enthält.

Ich wünschte, die Array-Manipulationslösung ( u.DG%HgxHGH{QQ14 Byte) wäre nicht so lang.

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.

Probieren Sie es hier aus .

— Lirtosiast
quelle
9

Python, 57 Bytes

lambda l:[n for i,n in enumerate(l)if l[:i+1].count(n)%n]
— xnor
quelle
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
}

Verwendungszweck:

# 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

Stellen Sie sicher, dass die richtigen Elemente weggeworfen werden

# 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
quelle
7

Im Ernst, 22 17 Bytes

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

Hex Dump:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Probieren Sie es online

Erläuterung:

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
— Quintopie
quelle
10
Diese Sprache ...
— Nico
6

JavaScript ES6, 34 Byte

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

Es stellte sich heraus, dass es sich um den Perl-Algorithmus von Brad handelt.

Bearbeiten: 2 Bytes dank @ edc65 gespeichert.

— Neil
quelle
Gut! Speichern Sie 2 Bytes, indem Sie die inneren Klammern entfernena=>a.filter(v=>f[v]=-~f[v]%v,f=[])
— edc65
5

Mathematica, 40 38 36 Bytes

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

Dies ist eine unbenannte Funktion, die a annimmt und zurückgibt List. Es definiert eine benannte Funktion, fwenn sie ausgeführt wird (um die Zahlen im Auge zu behalten), kümmert sich jedoch darum, die relevanten Definitionen von fvorher zurückzusetzen.

Erläuterung

Die Funktionsweise (oder Funktionsdefinitionen) in Mathematica ist sehr leistungsfähig. Wie in Haskell (zum Beispiel) können Funktionen nicht nur für bestimmte Typen, sondern auch für einzelne Werte (oder tatsächlich für beliebige Argumentmuster) überladen und definiert werden. Es ist jedoch noch leistungsfähiger als Haskell, da a) diese Werte als Nebenwirkungen während des Kontrollflusses definiert werden können und b) die Werte jederzeit neu definiert werden können. Das bedeutet, dass Funktionen eigentlich ziemlich leistungsfähige Nachschlagetabellen sind (die optional den nachgeschlagenen Wert berechnen können, anstatt ihn nur zu speichern).

Wenn wir die Golfitude aus dem Code entfernen, würde es ungefähr so ​​aussehen:

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

Zuerst durchlaufen wir die Eingabe und definieren f[x] = xfür alle xin der Liste. fwird letztendlich verwendet, um zu verfolgen, wie oft jede Nummer bereits in der Liste enthalten ist. Warum zählen wir nicht ab 0? Die Schleife über der Liste ist a Map. Der Ausdruck gibt f[x] = yzurück y(zusätzlich zum Speichern der Funktionsdefinition). Wenn Sie also auf setzen f[x], xwird die Karte als Eingabeliste ausgewertet. Das spart zwei Bytes, da wir dann nicht listnochmal explizit dafür sorgen müssen Select. Ausgehend von xanstatt 0wirkt sich überhaupt nicht auf die Berechnung aus, da wir immer nur daran interessiert sind Mod[f[x], x].

(Normalerweise könnten wir einfach so etwas wie f[_] = 0eine Fallback-Definition verwenden, um das zu vermeiden Map, aber wir wissen nicht, ob unsere Funktion zuvor verwendet wurde, wodurch einige vorherige Werte definiert würden, die unsere Zählung beeinträchtigen würden.)

Dann Selectfiltert die Liste nur diejenigen Elemente zu halten , wo der unbenannte Funktion als das zweite Argument Ausbeuten geführt True. Diese Funktion erhöht zuerst den Wert von f[x](wobei xdas aktuelle Listenelement ist), um die Vorkommen zu zählen, und nimmt dann das resultierende Zählmodul auf x. Wir wollen alle Elemente verwerfen, bei denen dies ergibt 0.

— Martin Ender
quelle
5

CJam, 17 Bytes

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

Schlagen Sie einfach ... J? Ich bin mir nicht sicher, was ich von dieser Herausforderung wirklich erwarte. Beachten Sie, dass ""CJam ein leeres Array darstellt.

Versuchen Sie es online | Testsuite (der letzte Fall ist zu lang für den Permalink)

Erläuterung

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
quelle
4

JavaScript ES6, 55 Byte

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

Erläuterung

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
quelle
3

J, 18 Bytes

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

Verwendungszweck:

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

Ziemlich unkomplizierte Methode. Wir zählen die Vorkommen einer Zahl bis dahin und wählen die Zahl nur dann aus, wenn die Zahl die Anzahl teilt.

Weitere Erklärungen folgen später.

Probieren Sie es hier online aus.

— randomra
quelle
2

PowerShell, 56 Byte

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

Verwendet einen ähnlichen Helfer-Array-Trick wie Rainer Ps Antwort , die ich unabhängig entwickelt habe, aber anscheinend mit FGITW erhalten habe.

Nimmt Eingaben als Array mit param($a). Anschließend erstellen wir unser Hilfsarray $bals mit Nullen gefülltes Array, indem wir den Kommaoperator in Verbindung mit dem überladenen Multiplikationsoperator verwenden. Dies schafft $bgleich @(0,0,0...0)mit $b.lengthder maximalen Anzahl in gleich zu sein $a.
(Quick Plug für meine Antwort "Showcase your language" , wo ich dies im Detail beschreibe)

Als nächstes kommt unsere Ausgabe. Wir durchlaufen jedes Element unseres Eingabearrays $a|%{...}und jede Schleife überprüft eine ifAnweisung. Die Bedingung erhöht den Wert in unserem Hilfsarray, der dem aktuellen Element entspricht, vorab und überprüft dann mit dem Modulo-Operator, ob es sich um ein Vielfaches des aktuellen Elements handelt. Wenn es ein Vielfaches ist, ist der %Wille gleich, 0was falsch ist, so dass der Wille ifnicht ausgeführt wird. Ansonsten geben wir das aktuelle Element aus.

Nutzt die implizite Typumwandlung, um bei der Ausgabeformatierung zu sparen. Wenn eine Funktion oder ein Programm mehrere Elemente zurückgibt und Sie die Ergebnisse in einer Variablen speichern, erstellt PowerShell diese Variable dynamisch als Array. Beispiel:

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

Vollständige Korrekturen für das Neuschreiben mit Testfall 2/3 bearbeiten. 2 bearbeiten. 7 Bytes sparen dank @ Alex-A

— mnel
quelle
1
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)

Dies verwendet die aktuelle Version (10.2.1) der Sprache / des Compilers.

Probieren Sie es online!

Erläuterung

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
quelle
1

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

Dieser Code verwendet eine Rekursion. Mit usingAnweisungen sind das 224 Bytes (160 für den Methodencode selbst).

Probieren Sie es online aus.

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
quelle
Sie sollten in der Lage sein, einige Zeichen zu speichern, indem Sie die continue-Anweisung entfernen. So etwas wie (ungetestet)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;
— Peter Taylor
@ Peter-Taylor, du hast recht, danke. Außerdem musste Code hinzugefügt werden, um einen Fehler zu beheben.
— Dmitry Stepanov
Wenn Sie importiert haben System.Linqdann !l.Any()kürzer als l.Count<1, die kürzer ist als l.Count==0.
— Peter Taylor
@ Peter-taylor danke, ich auch ersetzt w != 0 && w !=1mit w > 1.
— Dmitry Stepanov
Arrays sollten auch gut sein und sie würden ein bisschen kürzer sein 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
quelle
4
Ich glaube, Sie müssten die using-Anweisungen zählen, in diesem Fall wäre dies 241 Byte lang.
— LegionMammal978
0

Mathematica, 63 Bytes

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

Interessant zum Golfen! Ignorieren Sie die gelegentliche Meldung, die angezeigt wird.

— LegionMammal978
quelle
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
quelle
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₁

Dies nutzt die Tatsache, dass auf einem neuen Rechner L₁initialisiert und gelöscht wird. Beachten Sie, dass der Versuch, eine leere Liste in TI-BASIC anzuzeigen, einen Fehler auslöst.

— Lirtosiast
quelle
0

APL, 16 Zeichen

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

Auf Englisch:

  • ,\⍵: vector des Vektors steht vor dem n-ten Element des Arguments
  • +/¨⍵=: Zähle pro Präfixvektor, wie viele gleich dem n-ten Element selbst sind
  • ×⍵|: Zeichen der Mods (das heißt: 0, wenn der Rest der Division 0 ist, sonst 1)
  • ⍵/⍨: des Arguments behalte nur das Element bei, in dem der Mod 0 ist
— lstefano
quelle
0

Schläger 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
          ))))

Testen: 

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

Ausgabe:

'()
'(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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.