Encontrei esse problema enquanto trabalhava em outro desafio que estou fazendo para este site. Nesse desafio, utilizo " Mario Kart 8 Scoring ". A quantidade de pontos que o jogador em k é colocado é representada por esta matriz de 1 índice: [15,12,10,9,8,7,6,5,4,3,2,1]. Então, o 1º lugar recebe 15 pontos, o 2º lugar recebe 12 pontos, etc.

É fácil atribuir pontos como este, no entanto, a parte complicada vem com a maneira como eu manejo os empates. O que faço é dar a cada jogador que amarra a média dos pontos dados para cada local de amarração. Por exemplo, se apenas o 1º e o 2º empataram, ambos os jogadores recebem (15 + 12) / 2 = 13,5 pontos. (Nota: você pode arredondar para o int mais próximo, então 13 ou 14 também são aceitáveis.) Em seguida, o 3º - 12º lugar obtém a quantidade normal de pontos para sua posição.

Desafio

Dadas 12 pontuações inteiras não negativas que são classificadas de forma decrescente, produz o número de pontos que cada jogador recebe. Você também pode pegar a lista de pontos [15,12,10,9, ...] como entrada. Observe que o número de pontos que cada jogador recebe não depende dos valores reais das pontuações, mas como eles se comparam às outras pontuações.

Casos de teste

• [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]
  • explicação: (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 ]
  • explicação: (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]
  • explicação: (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 ]
  • explicação: (9 + 8 + 7) / 3 = 8, (5 + 4) / 2 = 4,5, (2 + 1) / 2 = 1,5

Relacionado: Classifique uma lista de pontuações com "pular"

JavaScript (ES6), 57 bytes

É introduzido na sintaxe de curry (p)(s), onde p é a lista de pontos es é a lista de pontuações.

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

Casos de teste

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 tem um built-in para isso. Leva uma lista de punguentos e snúcleos como entrada.

ave

Experimente online!

Exemplo:

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"

Experimente online!

Inclui 17 bytes para codificar os valores dos pontos.

MATL , 12 10 bytes

2 bytes de desconto graças a @geokavel !

7#uti2XQw)

As entradas são um vetor de coluna ( ;como separador) de pontuações inteiras e um vetor de coluna com os pontos. A saída contém os resultados separados por novas linhas.

Experimente online! Ou verifique todos os casos de teste .

Explicação

       % 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ˆ

Experimente online!

Explicação

γ              # 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;}

Experimente online!

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

Experimente online!

J, 15 bytes

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

Experimente online!

Leva a lista de pontuações ( 1 2 ... 12 15) como argumento à direita e os valores a serem pontuados como argumento à esquerda. Se não for uma entrada lógica, adicione 1 byte para um~ passivo inverta a ordem em que as entradas são obtidas.

Pode haver algumas coisas no golfe, que incluem

• Meu uso do boxe
• A tampa no final

Explicação

Vou dividir isso em algumas funções.

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

• avg_and_dupe pega a média de uma lista e a duplica quantas vezes o comprimento da lista
• score pontua uma entrada (argumento da esquerda), dada uma lista de pontuações (argumento da direita).

avg_and_dupe

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

Isso funciona tão bem porque é tratado como dois garfos . Se você ainda está coçando a cabeça (eu sei que estava no começo), pergunte e eu posso fornecer uma explicação mais aprofundada sobre o porquê disso funciona.

Ponto

[: ; <@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

Se ainda estiver confuso, também posso adicionar uma explicação para /.-key, mas acho que a página da wiki explica muito bem.

Python 2 , 66 bytes

-8 bytes graças a Leaky Nun.

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

Experimente online!

Gelatina , 11 bytes

ṁ⁴Œg¤Æmṁ$€F

Experimente online!

-3 bytes graças ao fireflame por observar os novos recursos do 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]

Experimente online!

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]

Experimente online!

Python 3 , 72 bytes

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

Experimente online!

Próton , 62 bytes

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

Experimente online!

Próton , 63 bytes

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

Experimente online!

Dyalog APL, 14 bytes

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

Toma a lista de pontuações como argumento à esquerda e a lista de pontos como argumento à direita. Adicione 2 bytes para envolvê-lo() se chamado diretamente e não como uma função nomeada.

{...}⌸ agrupa o argumento da direita pela tecla no argumento da esquerda e aplica a função entre chaves a cada grupo (operador de chave).

⊂≢⍴+/÷≢ é um garfo onde:

+/÷≢ é a média de pontos do grupo (soma dividida pelo registro)

≢⍴ remodelar o registro (replicar a média para corresponder ao número de itens no grupo)

⊂ caixas o resultado (isto é para neutralizar a mistura do resultado que o operador principal aplica)

∊ é alistar e nivelar o resultado do operador principal (que é um vetor aninhado de vetores) em uma lista simples.

TryAPL online

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

É difícil importar groupByeon , por isso, tive que fazer o meu próprio.

A função média será reduzida em breve.

Precisando da assinatura provavelmente poderia ser evitado com sinalizadores de compilador.