Me encontré con este problema mientras trabajaba en otro desafío que estoy haciendo para este sitio. En ese desafío utilizo " Mario Kart 8 Scoring ". La cantidad de puntos que obtiene el jugador en el puesto número k está representada por esta matriz de 1 índice: [15,12,10,9,8,7,6,5,4,3,2,1]. Entonces, el primer lugar obtiene 15 puntos, el segundo lugar obtiene 12 puntos, etc.

Es bastante fácil asignar puntos como este, sin embargo, la parte difícil viene con cómo manejo los lazos. Lo que hago es dar a cada jugador empatador el promedio de los puntos dados para cada lugar de empate. Por ejemplo, si solo el 1 ° y el 2 ° empate, ambos jugadores obtienen (15 + 12) / 2 = 13.5 puntos. (Nota: se le permite redondear al int más cercano, por lo que 13 o 14 también son aceptables). Luego, del 3 ° al 12 ° lugar obtenga la cantidad normal de puntos para su posición.

Desafío

Dados 12 puntajes enteros no negativos que se ordenan de manera decreciente, genera el número de puntos que obtiene cada jugador. También puede tomar la lista de puntos [15,12,10,9, ...] como entrada. Tenga en cuenta que la cantidad de puntos que obtiene cada jugador no depende de los valores reales de los puntajes, sino de cómo se comparan con los otros puntajes.

Casos de prueba

• [21,21,15,14,12,9,6,5,4,3,2,1] => [ 14,14 , 10,9,8,7,6,5,4,3,2, 1]
• [20,15,15,15,10,9,8,7,6,5,4,3] => [15, 10,10,10 , 8,7,6,5,4,3,2, 1]
  • explicación: (12 + 10 + 9) / 3 = 10.3333
• [1,1,1,1,1,1,1,1,1,1,1,1] => [ 7,7,7,7,7,7,7,7,7,7,7, 7 ]
  • explicación: (15 + 12 + 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1) / 12 = 6.8333
• [20,20,20,20,10,10,10,9,8,7,6,5] => [ 12,12,12,12 , 7,7,7 , 5,4,3,2, 1]
  • explicación: (15 + 12 + 10 + 9) / 4 = 11.5, (8 + 7 + 6) / 3 = 7
• [100,99,98,95,95,95,94,93,93,92,91,91] => [15,12,10, 8,8,8 , 6, 5,5 , 3, 2, 2 ]
  • explicación: (9 + 8 + 7) / 3 = 8, (5 + 4) / 2 = 4.5, (2 + 1) / 2 = 1.5

Relacionado: Clasifique una lista de puntajes con "saltos"

JavaScript (ES6), 57 bytes

Toma información en la sintaxis de curry (p)(s), donde p es la lista de puntos y s es la lista de puntajes.

p=>s=>s.map(v=>s.reduce((t,x,i)=>x-v?t:t+p[n++,i],n=0)/n)

Casos de prueba

let f =

p=>s=>s.map(v=>s.reduce((t,x,i)=>x-v?t:t+p[n++,i],n=0)/n)

points = [15,12,10,9,8,7,6,5,4,3,2,1];

console.log(JSON.stringify(f(points)([21,21,15,14,12,9,6,5,4,3,2,1])))
console.log(JSON.stringify(f(points)([20,15,15,15,10,9,8,7,6,5,4,3])))
console.log(JSON.stringify(f(points)([1,1,1,1,1,1,1,1,1,1,1,1])))
console.log(JSON.stringify(f(points)([20,20,20,20,10,10,10,9,8,7,6,5])))
console.log(JSON.stringify(f(points)([100,99,98,95,95,95,94,93,93,92,91,91])))

R , 3 bytes

Aparentemente, R tiene una función incorporada para esto. Toma una lista de pungüentos y snúcleos como entrada.

ave

Pruébalo en línea!

Ejemplo:

p=c(15,12,10,9,8,7,6,5,4,3,2,1)

> ave(p,c(20,15,15,15,10,9,8,7,6,5,4,3))
 [1] 15.00000 10.33333 10.33333 10.33333  8.00000  7.00000  6.00000  5.00000  4.00000  3.00000  2.00000  1.00000
> ave(p,c(1,1,1,1,1,1,1,1,1,1,1,1))
 [1] 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333

Perl 5 , 109 +1 (-a) = 110 bytes

@p=(1..10,12,15);while(@F){$/=$,=0;do{$,++;$/+=pop@p}while($w=shift@F)==$F[0];push@r,(int.5+$//$,)x$,}say"@r"

Pruébalo en línea!

Incluye 17 bytes para codificar los valores de puntos.

MATL , 12 10 bytes

2 bytes de descuento gracias a @geokavel !

7#uti2XQw)

Las entradas son un vector de columna ( ;como separador) de puntuaciones enteras y un vector de columna con los puntos. La salida contiene los resultados separados por nuevas líneas.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

       % Implicitly take first input. 
       % STACK: [21;21;15;14;12;9;6;5;4;3;2;1]
7#u    % Unique consecutive integer labels
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11]
t      % Duplicate
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [1;1;2;3;4;5;6;7;8;9;10;11]
i      % Take second input
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [1;1;2;3;4;5;6;7;8;9;10;11], [15;12;10;9;8;7;6;5;4;3;2;1]
2XQ    % Average second argument as grouped by the first
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [13.5;10;9;8;7;6;5;4;3;2;1]
w      % Swap
       % STACK: [[13.5;10;9;8;7;6;5;4;3;2;1], [1;1;2;3;4;5;6;7;8;9;10;11]
)      % Reference indexing
       % STACK: [13.5;10;9;8;7;6;5;4;3;2;1]
       % Implicitly display

05AB1E , 12 bytes

γ€g£vygFyÅAˆ

Pruébalo en línea!

Explicación

γ              # group the scores into chunks of consecutive equal elements
 €g            # get the length of each chunk
   £           # split the points list into chunks of these sizes
    v          # for each chunk y in the points list
     ygF       # len(y) times do:
        yÅA    # get the arithmetic mean of y
           ˆ   # add to global list
               # implicitly output global list

C # (.NET Core) , 154 bytes

x=>s=>{for(int i=0;i<12;){int b=0,j=i,a=0,c=0;for(;j<12&&x[i]==x[j];j++,b++){a+=s[j];}a=(int)Math.Round(a/(b+.0));for(;c<b;c++){x[i+c]=a;}i+=b;}return x;}

Pruébalo en línea!

C # (.NET Core) + usando Linq, 170 + 23 bytes

x=>s=>x.GroupBy(z=>z).Select(y=>Enumerable.Repeat(Math.Round(s.Skip(Array.IndexOf(x,y.Key)).Take(y.Count()).Average()),y.Count())).Aggregate((a,b)=>a.Concat(b)).ToArray()

Pruébalo en línea!

J, 15 bytes

[:;<@(##+/%#)/.

Pruébalo en línea!

Toma la lista de puntuaciones ( 1 2 ... 12 15) como argumento de la derecha y los valores para puntuar como argumento de la izquierda. Si esto no es una entrada lógica, agregue 1 byte para un~ -pasivo invierta el orden en que se toman las entradas.

Puede haber algunas cosas para el golf, que incluyen

• Mi uso del boxeo
• La gorra al final

Explicación

Lo dividiré en un par de funciones.

avg_and_dupe =. # # +/ % #
score        =. [: ; <@avg_and_dupe/.

• avg_and_dupe toma el promedio de una lista y la duplica tantas veces como la longitud de la lista
• score puntúa una entrada (argumento izquierdo) dada una lista de puntajes (argumento derecho).

avg_and_dupe

# # +/ % #
#           Length
  #         Copy as many times as the left argument
    +/ % #  Average
    +/       Sum
       %     Divided by
         #   Length

Esto funciona muy bien porque se trata como dos tenedores . Si todavía te estás rascando la cabeza (sé que lo estaba al principio), pregunta y puedo darte una explicación más profunda de por qué esto funciona como lo hace.

Puntuación

[: ; <@avg_and_dupe/.
                   /.  Key: using the values given, partition the scores
     <@avg_and_dupe     For each partition:
       avg_and_dupe      Average and duplicate
     <                   Then box
   ;                   Raze the boxes into a single list

Si todavía es confuso, también puedo agregar una explicación para /.-key, pero creo que la página wiki lo explica bastante bien.

Python 2 , 66 bytes

-8 bytes gracias a Leaky Nun.

lambda s,p:[sum(p[s.index(i):][:s.count(i)])/s.count(i)for i in s]

Pruébalo en línea!

Jalea , 11 bytes

ṁ⁴Œg¤Æmṁ$€F

Pruébalo en línea!

-3 bytes gracias a fireflame por notar las nuevas características de Jelly: D

Python 3 , 67 bytes

lambda s,p:[sum(v for j,v in zip(s,p)if j==i)/s.count(i)for i in s]

Pruébalo en línea!

Python 2 , 108 70 bytes

lambda s,p:[1.*sum(v for j,v in zip(s,p)if j==i)/s.count(i)for i in s]

Pruébalo en línea!

Python 3 , 72 bytes

lambda s,p:[sum(p[s.index(i):12-s[::-1].index(i)])/s.count(i)for i in s]

Pruébalo en línea!

Protón , 62 bytes

(s,p)=>[sum(p[s.index(i)to][to s.count(i)])/s.count(i)for i:s]

Pruébalo en línea!

Protón , 63 bytes

(s,p)=>map(i=>sum(p[s.index(i)to][to s.count(i)])/s.count(i),s)

Pruébalo en línea!

Dyalog APL, 14 bytes

∊{(⊂≢⍴+/÷≢)⍵}⌸

Toma la lista de puntajes como argumento izquierdo y la lista de puntos como argumento derecho. Agregue 2 bytes para envolverlo ()si se llama directamente y no como una función con nombre.

{... }⌸agrupe el argumento derecho por la clave en el argumento izquierdo y aplique la función entre llaves a cada grupo (operador clave).

⊂≢⍴+/÷≢ es un tenedor donde:

+/÷≢ es el promedio de puntos por grupo (suma dividida por el recuento)

≢⍴ tally remodelar (replicar el promedio para que coincida con el número de elementos en el grupo)

⊂ recuadra el resultado (esto es para contrarrestar la mezcla del resultado que aplica el operador clave)

∊ se enlista y aplana el resultado del operador clave (que es un vector anidado de vectores) en una lista simple.

TryAPL en línea

Haskell, 152 bytes

f::[Int]->[Int]
f=concat.g(15:12:[10,9..1])[]
g[q]t _=[q:t]
g(q:r)t(x:z)|x>head z=(replicate(l(q:t))(sum(q:t)`div`l(q:t))):g r[]z|1<2=g 
r(q:t)z
l=length

Es un dolor importar groupBy yon tuve que hacer el mío.

La función de promedio se acortará en breve.

La necesidad de la firma probablemente podría evitarse con los indicadores del compilador.