La tarea

En este desafío, su entrada es una lista no vacía de enteros positivos, dada en el formato nativo de su idioma. Su salida es esa misma lista, en el mismo formato, con algunos elementos eliminados. Deberá eliminar cada aparición de 1, cada segunda aparición de 2, cada tercera aparición 3, y así sucesivamente. En general, por cada entero positivo N, deberá eliminar cada Naparición de Nla lista, comenzando por la Naparición.

Ejemplo

Considere la lista de entrada

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

Primero, eliminamos cada aparición de 1:

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

Luego, cada segundo caso de 2:

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

Luego, cada tercer caso de 3:

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

Los números 4y 5no aparecen en la entrada, por lo que se pueden omitir. A continuación, eliminamos cada sexta aparición de 6:

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

Solo hay una aparición de 7, por lo que también se puede omitir. Por lo tanto, la salida correcta es

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

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma. Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado, asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

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
fuente

15

Jalea , 10 8 bytes

=;\S€%af

¡Gracias a @ Sp3000 por jugar golf en 2 bytes!

Pruébalo en línea!

Cómo 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
fuente

¿Cómo funciona ese paso de comparación? y son los prefijos de [5,4,3,2,1] [[5], [5,4], [5,4,3], [5,4,3,2], [5,4, 3,2,1]] o [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]?

— quintopia

@quintopia Jelly es de izquierda a derecha, por lo que es el primero. =compara enteros. Por ejemplo, se [3,2,1]=;\compara 3con el elemento de [3], 2con los de [3, 2]y 1con los de [3, 2, 1]dar [1, [0, 1], [0, 0, 1]].

— Dennis

Ah, me faltaba que comparara una lista con una lista elemento por lista.

— quintopia

34

awk, 10 bytes

Se espera la entrada en STDIN, un número por línea.

++a[$1]%$1

Explicación

Mantiene un contador para cada número en una matriz asociativa, imprime solo si el módulo del valor del contador nno es cero. La impresión es implícita. Versión larga:

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

— Rainer P.
fuente

19

Pyth, 18 15 14 10 9 bytes

f%/aYTTTQ

Creo que este es el primer código que he escrito que tiene cinco referencias variables consecutivas en nueve bytes.

Desearía que la solución de manipulación de matriz ( u.DG%HgxHGH{QQ14 bytes) no fuera tan larga.

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.

Probarlo aquí .

— lirtosiast
fuente

9

Python, 57 bytes

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

— xnor
fuente

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 que los elementos correctos estén siendo desechados

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

7

En serio, 22 17 bytes

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

Hex Dump:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Pruébalo en línea

Explicación:

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

— quintapia
fuente

10

Este lenguaje ...

— Nico

6

JavaScript ES6, 34 bytes

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

Resultó ser lo mismo que el algoritmo Perl de Brad.

Editar: Guardado 2 bytes gracias a @ edc65.

— Neil
fuente

¡Bueno! guardar 2 bytes eliminando los paréntesis internosa=>a.filter(v=>f[v]=-~f[v]%v,f=[])

— edc65

5

Mathematica, 40 38 36 bytes

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

Esta es una función sin nombre que toma y devuelve a List. Define una función con nombre fcuando se ejecuta (para realizar un seguimiento de los números), pero se encarga de restablecer las definiciones relevantes de fantemano.

Explicación

La forma en que funcionan las funciones (o definiciones de funciones) en Mathematica es realmente poderosa. Como en Haskell (por ejemplo), las funciones no solo se pueden sobrecargar y definir para ciertos tipos, sino también para valores individuales (o patrones arbitrarios de argumentos, en realidad). Pero es aún más poderoso que Haskell en que a) estos valores pueden definirse como efectos secundarios durante el flujo de control yb) los valores también pueden redefinirse en cualquier momento. Eso significa que las funciones son en realidad tablas de búsqueda bastante potentes (que opcionalmente pueden calcular el valor buscado en lugar de simplemente almacenarlo).

Si eliminamos la golfitude del código, se vería un poco así:

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

Entonces, primero, recorremos la entrada y definimos f[x] = x, para todos xen la lista. ffinalmente se usará para realizar un seguimiento de la frecuencia con la que cada número ya ha aparecido en la lista. ¿Por qué no contamos desde 0? El ciclo sobre la lista es a Map. La expresión f[x] = yregresa y(además de almacenar la definición de la función). Por lo tanto, al establecer f[x]en x, el mapa evaluará la lista de entrada en sí. Eso ahorra dos bytes porque entonces no necesitamos proporcionar listnuevamente explícitamente Select. Comenzar en xlugar de 0no afecta el cálculo en absoluto, ya que solo nos interesa Mod[f[x], x].

(Normalmente podríamos simplemente usar algo f[_] = 0como una definición alternativa para evitar el Map, pero no sabemos si nuestra función se ha usado antes, lo que dejaría algunos valores previos definidos que interferirían con nuestro conteo).

Luego Selectfiltra la lista manteniendo solo aquellos elementos donde la función sin nombre pasó a medida que el segundo argumento produce True. Esa función primero incrementa el valor de f[x](donde xestá el elemento de la lista actual), para contar las ocurrencias, y luego toma el módulo de conteo resultante x. Queremos descartar todos los elementos donde esto rinda 0.

— Martin Ender
fuente

5

CJam, 17 bytes

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

Solo venció ... J? No estoy seguro de cuáles son mis expectativas para este desafío, de verdad. Tenga en cuenta que ""es la representación de CJam de una matriz vacía.

Pruébalo en línea | Conjunto de pruebas (el último caso es demasiado largo para el enlace permanente)

Explicación

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
fuente

4

JavaScript ES6, 55 bytes

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

Explicación

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
fuente

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 sencillo. Contamos las ocurrencias de un número hasta él y seleccionamos el número solo si el número divide el recuento.

Más explicación viene más tarde.

Pruébelo en línea aquí.

— randomra
fuente

2

PowerShell, 56 bytes

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

Utiliza un truco de matriz de ayuda similar al la respuesta de Rainer P , que desarrollé independientemente pero aparentemente obtuve FGITW'd.

Toma la entrada como una matriz con param($a). Luego creamos nuestra matriz auxiliar $bcomo una matriz poblada con ceros utilizando el operador de coma junto con el operador de multiplicación sobrecargado. Esto crea $bpara que sea igual @(0,0,0...0)a $b.lengthigual al número máximo en $a.
_{(Enchufe rápido para mi respuesta "Muestra tu idioma" donde describo esto en detalle)}

El siguiente es nuestro resultado. Realizamos un ciclo sobre cada elemento de nuestra matriz de entrada $a|%{...}y cada ciclo verifica una ifdeclaración. El condicional incrementa previamente el valor en nuestra matriz auxiliar que corresponde con el elemento actual, luego verifica si es un múltiplo del elemento actual con el operador de módulo. Si es un múltiplo, la %voluntad es igual a 0falsey, entonces elif que no se ejecuta. De lo contrario, sacamos el elemento actual.

Aprovecha la conversión de texto implícita para ahorrar en el formato de salida. Si una función o programa devuelve varios elementos y guarda los resultados en una variable, PowerShell creará dinámicamente esa variable como una matriz. Ejemplo:

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
fuente

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 la reescritura completa corrige el error con el caso de prueba 2/3 Edite 2 Ahorre 7 bytes gracias a @ Alex-A

— mnel
fuente

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)

Esto usa la versión actual (10.2.1) del lenguaje / compilador.

Pruébalo en línea!

Explicación

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
fuente

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
fuente

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 la recursividad. Con usingdeclaraciones de 224 bytes (160 para el código del método en sí).

Pruébalo en línea.

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
fuente

Debería poder guardar algunos caracteres eliminando la declaración de continuación. Algo como (no probado)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;

— Peter Taylor

@ Peter-Taylor, tienes razón, gracias. Además, tuve que agregar un código para corregir un error.

— Dmitry Stepanov

Si ha importado, System.Linqentonces !l.Any()es más corto que l.Count<1, que es más corto que l.Count==0.

— Peter Taylor

@ Peter-Taylor gracias, también lo reemplacé w != 0 && w !=1con w > 1.

— Dmitry Stepanov

las matrices también deberían ser buenas y serían un poco más cortas int [] R (int [] l, int n = 1)

— desigual el

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

Sin golf

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
fuente

44

Creo que tendría que contar las declaraciones de uso, en cuyo caso esto tendría una longitud de 241 bytes.

— LegionMammal978

0

Mathematica, 63 bytes

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

Muy interesante para el golf! Ignora el mensaje ocasional que aparece.

— LegionMammal978
fuente

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
fuente

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₁

Esto utiliza el hecho de que, en una calculadora nueva, L₁se inicializa y borra. Tenga en cuenta que intentar mostrar una lista vacía en TI-BASIC arroja un error.

— lirtosiast
fuente

0

APL, 16 caracteres

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

En inglés:

,\⍵: vector del vector prefijos hasta el enésimo elemento del argumento
+/¨⍵=: por vector de prefijo, cuente cuántos son iguales al elemento n-ésimo
×⍵|: signos de los mods (es decir: 0 si el resto de la división es 0, 1 de lo contrario)
⍵/⍨: del argumento mantenga solo el elemento donde el mod es 0

— lstefano
fuente

0

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

Sin golf:

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

Pruebas:

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

Salida:

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

Eliminar cada N-ésima N

La tarea

Ejemplo

Reglas y puntaje

Casos de prueba

Tabla de clasificación

Jalea , 10 8 bytes

Cómo funciona

awk, 10 bytes

Explicación

Pyth, 18 15 14 10 9 bytes

Python, 57 bytes

Perl 6 , 28 bytes

En serio, 22 17 bytes

JavaScript ES6, 34 bytes

Mathematica, 40 38 36 bytes

Explicación

CJam, 17 bytes

Explicación

JavaScript ES6, 55 bytes

Explicación

J, 18 bytes

PowerShell, 56 bytes

R, 110 98 99 92 Bytes

MATL , 20 bytes

Explicación

R, 63 bytes

C #, 224 bytes

C # - 177 bytes

Mathematica, 63 bytes

Ruby, 120 bytes

TI-BASIC, 47 bytes

APL, 16 caracteres

Raqueta 179 bytes