La tâche

Dans ce défi, votre entrée est une liste non vide d’entiers positifs, donnée dans le format natif de votre langue. Votre sortie est cette même liste, dans le même format, avec certains éléments supprimés. Vous devez supprimer chaque occurrence de 1, une occurrence sur deux 2, une occurrence sur trois 3, etc. En général, pour chaque entier positif N, vous devez supprimer chaque Noccurrence de Nde la liste, en commençant par la Noccurrence.

Exemple

Considérons la liste d'entrée

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

Tout d'abord, nous supprimons chaque occurrence de 1:

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

Puis chaque seconde occurrence de 2:

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

Puis à chaque troisième occurrence de 3:

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

Les nombres 4et 5ne figurent pas dans l'entrée, ils peuvent donc être ignorés. Ensuite, nous supprimons chaque sixième occurrence de 6:

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

Il n'y a qu'une seule occurrence de 7, donc on peut aussi l'ignorer. Ainsi, la sortie correcte est

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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus faible gagne et les failles standard sont interdites.

Cas de test

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

Classement

Voici un extrait de pile permettant de générer un classement régulier et un aperçu des gagnants par langue. Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête, assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

var QUESTION_ID=70091,OVERRIDE_USER=32014;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Expand snippet

code-golf array-manipulation

— Zgarb
source

15

Gelée , 10 à 8 octets

=;\S€%af

Merci à @ Sp3000 pour avoir joué 2 octets!

Essayez-le en ligne!

Comment ça marche

=;\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
source

Comment fonctionne cette étape de comparaison? et sont les préfixes 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

@quintopia Jelly est de gauche à droite, c'est donc le premier. =compare les entiers. Par exemple, [3,2,1]=;\compare 3avec l'élément de [3], 2avec ceux de [3, 2]et 1avec ceux de [3, 2, 1], donner [1, [0, 1], [0, 0, 1]].

— Dennis

Ah, il me manquait qu'il comparait une liste à une liste élément par liste.

— Quintopia

34

awk, 10 octets

Une entrée est attendue sur STDIN, un numéro par ligne.

++a[$1]%$1

Explication

Conserve un compteur pour chaque nombre dans un tableau associatif, ne s'imprime que si la valeur du compteur modulo nn'est pas zéro. L'impression est implicite. Version longue:

++a[$1]%$1{print $0}

— Rainer P.
source

19

Pyth, 18 15 14 10 9 octets

f%/aYTTTQ

Je pense que c'est le premier code que j'ai écrit qui comporte cinq références de variable consécutives sur neuf octets.

Je souhaite que la solution de manipulation de tableau ( u.DG%HgxHGH{QQ, 14 octets) ne soit pas si longue.

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.

L'essayer ici .

— lirtosiast
source

9

Python, 57 octets

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

— Xnor
source

8

Perl 6 , 28 octets

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

Usage:

# 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

Vérifiez que les éléments corrects sont jetés

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

7

Sérieusement, 22 17 octets

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

Décharge Hex:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Essayez-le en ligne

Explication:

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
source

10

Cette langue ...

— Nico

6

JavaScript ES6, 34 octets

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

S'avère être le même que l'algorithme Perl de Brad.

Edit: 2 octets enregistrés grâce à @ edc65.

— Neil
source

Bien! économiser 2 octets en supprimant les parenthèses intérieuresa=>a.filter(v=>f[v]=-~f[v]%v,f=[])

— edc65

5

Mathematica, 40 38 36 octets

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

C'est une fonction sans nom qui prend et retourne un List. Il définit une fonction nommée florsqu’il est exécuté (pour garder une trace des nombres), mais s’occupe de réinitialiser les définitions pertinentes def .

Explication

Le fonctionnement des fonctions (ou des définitions de fonctions) dans Mathematica est vraiment puissant. Comme dans Haskell (par exemple), les fonctions ne peuvent pas uniquement être surchargées et définies pour certains types, mais également pour des valeurs individuelles (ou des modèles d'arguments arbitraires). Mais il est encore plus puissant que Haskell en ce que a) ces valeurs peuvent être définies comme des effets secondaires lors du contrôle de flux et b) que les valeurs peuvent également être redéfinies à tout moment. Cela signifie que les fonctions sont en fait des tables de recherche assez puissantes (qui peuvent éventuellement calculer la valeur recherchée au lieu de la stocker).

Si nous supprimons la golfitude du code, cela ressemblerait un peu à ceci:

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

Nous commençons donc par parcourir l’entrée et définir f[x] = xpour tous les éléments xde la liste. fsera finalement utilisé pour garder une trace de la fréquence à laquelle chaque numéro est déjà apparu dans la liste. Pourquoi ne compte-t-on pas 0? La boucle sur la liste est un Map. L'expression f[x] = yretourne y(en plus de stocker la définition de la fonction). Donc, en définissant f[x]sur x, la carte sera évaluée par la liste de saisie elle-même. Cela économise deux octets, car nous n'avons pas besoin de fournir listexplicitement à nouveau à Select. Commencer par xau lieu de 0n'affecte pas le calcul du tout puisque nous ne nous intéressons jamais qu'à Mod[f[x], x].

(Normalement, nous pourrions simplement utiliser quelque chose comme f[_] = 0une définition de secours pour éviter laMap , mais nous ne savons pas si notre fonction a déjà été utilisée, ce qui laisserait certaines valeurs précédentes définies qui gêneraient notre comptage.)

Ensuite, Selectfiltre la liste en ne conservant que les éléments pour lesquels la fonction non nommée passée en tant que deuxième argument a été générée True. Cette fonction incrémente d’ abord la valeur de f[x](où xest l’élément de la liste en cours), afin de compter les occurrences, puis prend le compte résultant modulo x. Nous voulons supprimer tous les éléments où cela donne 0.

— Martin Ender
source

5

CJam, 17 octets

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

Juste battre ... J? Je ne sais pas vraiment quelles sont mes attentes pour ce défi, vraiment. Notez que ""CJam représente un tableau vide.

Essayez-le en ligne | Suite de tests (le dernier cas est trop long pour le permalien)

Explication

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
source

4

JavaScript ES6, 55 octets

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

Explication

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
source

3

J, 18 octets

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

Usage:

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

Méthode assez simple. Nous comptons les occurrences d’un nombre jusqu’à ce nombre et ne sélectionnons ce nombre que si ce nombre divise le nombre.

Plus d'explication vient plus tard.

Essayez-le en ligne ici.

— randomra
source

2

PowerShell, 56 octets

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

Utilise une astuce similaire à celle de Rainer P , que j'ai développée indépendamment mais que j'ai apparemment eu FGITW'd.

Prend l'entrée comme un tableau avec param($a). Nous créons ensuite notre tableau d'assistance $bsous la forme d'un tableau peuplé-avec-zéros à l'aide de l'opérateur de virgule associé à l'opérateur de multiplication surchargé. Cela crée $bpour être égal à @(0,0,0...0)avec $b.lengthégal au nombre maximal dans $a.
_{(Prise rapide pour ma réponse "Présentez votre langue" où je décris cela en détail)}

Suivant est notre sortie. Nous parcourons chaque élément de notre tableau d'entrée $a|%{...}et chaque boucle vérifie une ifdéclaration. Le conditionnel pré-incrémente la valeur de notre tableau d'assistance qui correspond à l'élément actuel, puis vérifie s'il s'agit d'un multiple de l'élément actuel avec l'opérateur modulo. Si c'est un multiple, la %volonté égale 0Falsey, donc ifelle ne s'exécute pas. Sinon, nous produisons l'élément en cours.

Profite de la conversion de type implicite pour économiser sur le formatage de la sortie. Si une fonction ou un programme renvoie plusieurs éléments et que vous enregistrez les résultats dans une variable, PowerShell créera cette variable de manière dynamique sous la forme d'un tableau. Exemple:

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
source

1

R, 110 98 99 92 octets

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

Édition complète des correctifs de réécriture bug avec scénario de test 2/3 Édition 2 Économisez 7 octets grâce à @ Alex-A

— couloir
source

1

92 octets: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 octets

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

Ceci utilise la version actuelle (10.2.1) du langage / compilateur.

Essayez-le en ligne!

Explication

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
source

1

R, 63 octets

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

— LambruscoAcido
source

1

C #, 224 octets

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

Ce code utilise la récursivité. Avec des usinginstructions de 224 octets (160 pour le code de méthode lui-même).

Essayez-le en ligne.

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
source

Vous devriez pouvoir enregistrer quelques caractères en supprimant l'instruction continue. Quelque chose comme (non testé)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;

— Peter Taylor

@ Peter-Taylor, vous avez raison, merci. En outre, nous avons dû ajouter du code pour résoudre un bogue.

— Dmitry Stepanov

Si vous avez importé, System.Linqalors !l.Any()est plus court que l.Count<1, ce qui est plus court que l.Count==0.

— Peter Taylor

@ peter-taylor merci, j'ai aussi remplacé w != 0 && w !=1par w > 1.

— Dmitry Stepanov

les tableaux devraient être bons aussi et ils seraient un peu plus courts int [] R (int [] l, int n = 1)

— raggy

0

C # - 177 octets

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
source

4

Je crois que vous devrez compter les instructions using, auquel cas ce serait une longueur de 241 octets.

— LegionMammal978

0

Mathematica, 63 octets

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

Très intéressant de jouer au golf! Ignorer le message occasionnel qui apparaît.

— LegionMammal978
source

0

Ruby, 120 octets

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

0

TI-BASIC, 47 octets

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

Ceci utilise le fait que, sur une nouvelle calculatrice, L₁est initialisée et effacée. Notez que le fait d’afficher une liste vide dans TI-BASIC renvoie une erreur.

— lirtosiast
source

0

APL, 16 caractères

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

En anglais:

,\⍵: vecteur des préfixes de vecteurs jusqu'au nième élément de l'argument
+/¨⍵=: par vecteur de préfixe, compter combien sont égaux au n-ième élément lui-même
×⍵|: signes du mod (c'est-à-dire: 0 si le reste de la division est 0, sinon 1)
⍵/⍨: de l'argument ne conserve que l'élément où le mod est 0

— lefefano
source

0

Raquette 179 octets

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

Essai:

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

Sortie:

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

Enlevez chaque N-N N

La tâche

Exemple

Règles et notation

Cas de test

Classement

Gelée , 10 à 8 octets

Comment ça marche

awk, 10 octets

Explication

Pyth, 18 15 14 10 9 octets

Python, 57 octets

Perl 6 , 28 octets

Sérieusement, 22 17 octets

JavaScript ES6, 34 octets

Mathematica, 40 38 36 octets

Explication

CJam, 17 octets

Explication

JavaScript ES6, 55 octets

Explication

J, 18 octets

PowerShell, 56 octets

R, 110 98 99 92 octets

MATL , 20 octets

Explication

R, 63 octets

C #, 224 octets

C # - 177 octets

Mathematica, 63 octets

Ruby, 120 octets

TI-BASIC, 47 octets

APL, 16 caractères

Raquette 179 octets