Calcul des points : la faille

Je vois pas pourquoi un gars qui a 9 scores avec d'autres joueurs et derierre il y a 90 scores différents il gagne 8000 points de plus qu'un gars avec qui a egalement le score de 9 autres joueurs mais que derierre les autres sont regroupés oO

Il peut y avoir des trucs tout con genre :

1.32.99
1.32.99
1.32.99
1.36.57
1.37.28
1.38.95
1.41.53
2.04.89

Et

6
6
6
5
5
5
4
4

Je vois pas pourquoi le 1er cas gagnerait 8 fois plus Oo

Shark je parle de ces cas là:

Cas avec 10 scores différents :
1. => 996pts
2. => 896pts
3. => 796pts
4. => 696pts
5. => 596pts
6. => 496pts
7. => 396pts
8. => 296pts
9. => 196pts
10. => 96pts

Cas avec 10 égalités :
1. => 286pts

33Tails :

Je vois pas pourquoi un gars qui a 9 scores avec d'autres joueurs et derierre il y a 90 scores différents il gagne 8000 points de plus qu'un gars avec qui a egalement le score de 9 autres joueurs mais que derierre les autres sont regroupés oO

Je suppose que c'est parce que dans le cas où il y a plein de \"tas d'égalités\" il s'agirait de records avec un petit nombre de scores possibles et donc ce serait plus facile d'atteindre le score max' ou de grapiller des places (en théorie). Dans ton exemple, tu vois de suite, tu as pris un exemple avec des temps où c'est compliqué de faire des égalités avec des temps non premiers. Je suppose que niconoe et Arcade préfèrent récompenser prioritairement les premiers sur les records où les scores sont mieux répartis.
Mais là on a de grosses différences dans le cas d'un grand nombre de posts. Dans ton exemple les écarts sont déjà moins prononcés :

1er cas :
1. => 617pts
4. => 497pts
5. => 397pts
6. => 297pts
7. => 197pts
8. => 97pts

2ème cas :
1. => 347pts
1. => 347pts
1. => 347pts
4. => 227pts
4. => 227pts
4. => 227pts
7. => 107pts
7. => 107pts

Pour Karoo, il y a toujours moyen de moins réduire les points pour les cas d'égalités (et ça influerait également pour le cas de 33Tails aussi) si tout le monde est d'accord sur ce point. :p

Moi, je trouve qu'être 1er devant 9 personne, c'est pas du tout comparable à etre 1er AVEC 9 personne, c'est pour ça que l'écart me semble justifié

int rang = 0;
int cpt = 0;
array int tab; // tableau des scores ordonnés
pour i de 0 à n faire  //n = nb post
| si i >= 1 alors
| | si nbPointRecord du précédent = nbPointRecord du suivant alors
| | | cpt=cpt+1;
| | sinon
| | | rang = rang + cpt + 1;
| | | cpt = 0;
| | fsi
| sinon
| | rang = rang + 1;
| fsi
| tab[i]['rang'] = rang;
fpour
retourne tab


//tab est ordonné dans le sens où c'est le classement mais sans les rangs encore
//cpt peut être utilisé pour savoir combien d'égalité on a je pense

Mais non mais dans les deux cas on était 1er avec 9 personnes ;)
c'est juste les personnes derierre qui influait sur ton nombre de poins, c'est ça que je trouvais bizarre ;)

M'enfin moi ça va, merci shark :p

Oui c'est vrai que ça m'a fait tilter aussi ça, pour moi battre 90 personnes, qu'elles soient égalités ou non, ça reste la performance d'avoir battu 90 personnes, donc ont devrait avoir le même nombre de points.

Mais si faut de nouveau tout changer et que c'est trop casse tête, c'est pas encore trop grave, parce que déjà c'est assez rare comme cas, et puis je trouve le reste de la formule vraiment parfaite O_O

J'ai discuté avec karoo sur msn pour les égalités, il avait mal compris un truc, donc c'est parfait aussi.

reste plus qu'a black ou moi-même de voir où caler les variables dont on a besoin...
Tu peux me faire une piqure de rappel black ?
Avec formule et variables ?

Arcade :

Oui c'est vrai que ça m'a fait tilter aussi ça, pour moi battre 90 personnes, qu'elles soient égalités ou non, ça reste la performance d'avoir battu 90 personnes, donc ont devrait avoir le même nombre de points.

C'était en fait la première nouvelle approche que j'avais faite. :p (début de la page 30)

En reformulant pour avoir une unique boucle on aurait :

BlackShark :

k = n;    // n est le nombre de posts
m=n+1;    
// m sert à garder en mémoire la place du joueur qui suit au classement le joueur dont on souhaite calculer les PointsRecords
pm=(exp^(-(n-1)/100)+1)*50-100;
//pm représente le nombre de PointsRecords que gagnerait un n+1ème pour n posts, cette valeur permettra de calculer le nombre de PointsRecords des autres joueurs.
While (k>0)
if (position du joueur k différent de 1)
|||{PointsRecords du joueur k = pm+100*(n+1-\"Position du joueur k\");}
else
|||{if (m=1) {PointsRecords du joueur k = prp;}
||| else {prp = pm+100*(n+1-m)+(10*(m+8));
||||||||||PointsRecords du joueur k =prp;}}
m=position du joueur k
k=k-1
EndWhile

L'idée de l'algorithme :
Avec cet algorithme on calculerait d'abord le nombre de PointsRecords gagné par un éventuel n+1ème parmi n posts (\"pm\"), cette valeur permettra de calculer les PointsRecords des n joueurs. On calcule ensuite les PointsRecords du joueur n, puis du joueur n-1 etc... en fonction de la valeur de \"pm\" et de la position du joueur. Dès qu'on rencontre pour la première fois un joueur en 1ère position on calcule le nombre de points records pour les premiers (\"prp\") en fonction de la valeur de \"pm\" et du nombre d'égalité en première place (plus il y a d'égalités à la première place, plus on minimise le nombre de PointsRecords aux premiers). On attribue à ce joueur : \"prp\" PointsRecords, ainsi qu'aux autres joueurs qui seront également premiers.

Quelques exemples numériques :

Cas avec 1 score :
1. => 100pts

Cas avec 10 scores différents :
1. => 996pts
2. => 896pts
3. => 796pts
4. => 696pts
[...]
10. 96pts

Cas avec 10 égalités :
1. 286pts

Cas avec 100 scores différents :
1. => 9 969pts
2. => 9 869pts
3. => 9 769pts
[...]
100. => 69pts

Cas avec 100 égalités :
1. => 1 159pts

Cas avec 10 égalités puis 90 scores différents :
1. => 9 159pts
[...]
1. => 9 159pts
11. => 8 969pts
[...]
100. => 69pts

Cas avec 20 égalités puis 80 scores différents :
1. => 8 259pts
[...]
1. => 8 259pts
21. => 7 969pts
[...]
100. => 69pts

Cas avec 10 égalités, puis 10 égalités, puis 10 égalités... :
1. => 9 159pts
[...]
1. => 9 159pts
11. => 8 969pts
[...]
11. => 8 969pts
21. => 7 969pts
[...]
21. => 7 969pts
31. => 6 969pts
[...]
31. => 6 969pts
41. => 5 969pts
[...]
41. => 5 969pts
51. => 4 969pts
[...]
51. => 4 969pts
61. => 3 969pts
[...]
61. => 3 969pts
71. => 2 969pts
[...]
71. => 2 969pts
81. => 1 969pts
[...]
81. => 1 969pts
91. => 969pts
[...]
91. => 969pts

Cas avec 20 scores différents, puis 10 égalités, puis 50 scores différents, puis 10 égalités, puis 10 scores différents :
1. => 9 969pts
[...]
20. => 8 069pts
21. => 7 969pts
[...]
21. => 7 969pts
31. => 6 969pts
[...]
80. => 2 069pts
81. => 1 969pts
[...]
81. => 1 969pts
91. => 969pts
[...]
100. => 69pts

niconoe :

reste plus qu'a black ou moi-même de voir où caler les variables dont on a besoin...
Tu peux me faire une piqure de rappel black ?
Avec formule et variables ?

Le soucis c'est que votre algorithme calcule les rangs du premier au dernier, alors que je calcule les PointsRecords du dernier au premier. Soit on réarrange l'algorithme pour tout faire du dernier au premier, soit je réfléchis comment faire les calculs du premier au dernier (je suppose que ce serait mieux pour vous lol).

Bon bah tes derniers exemples, je pense qu'il n'y a vraiment plus rien à dire. C'est parfait !

Un algorithme possible pour le dernier exemple que j'ai donné :

int rang = 0;
int cpt = 0;
bool ptsprem = 0;
array int tab; // tableau des scores ordonnés
int pts_d = exp^(-(n-1)/100)+1)*50 - 100; // Il faudrait mettre la partie entière
pour i de 0 à n faire //n = nb post
| si i >= 1 alors
| | si score du précédent = score du suivant alors
| | | cpt=cpt+1;
| | sinon
| | | rang = rang + cpt + 1;
| | | cpt = 0;
| | fsi
| sinon
| | rang = rang + 1;
| fsi
| tab[i]['rang'] = rang;
| si \"rang différent de 1\" alors
| | | si ptsprem=0 alors
| | | | | pour k de 1 à i-1 faire
| | | | | | | tab[k]['ptRecords']=pts_d+100*(n+1-rang)+(10*(rang+8));
| | | | | | | ptsprem=1;
| | | | | fpour
| | | | | tab[i]['ptRecords']=pts_d+100*(n+1-rang);
| | | sinon
| | | | | tab[i]['ptRecords']=pts_d+100*(n+1-rang);
| | | fsi
| fsi
fpour
retourne tab


On aurait deux nouvelles variables :
pts_d : représente les PointsRecords d'un éventuel n+1ème pour n posts. Il permettra le calcul des PointsRecords des n joueurs. (A noter que ce nombre est négatif)
ptsprem : valeur booléenne pour savoir si on a calculé (1) ou non (0) les pointsRecords des premiers. Dès qu'on a un joueur non premier (ex: 5ème) et qu'on n'a toujours pas calculé les PointsRecords dès premiers, on calcule les  pointsRecords des premiers (ex: joueur 1 à 4), puis on calcul les PointsRecords du joueurs en question (ex: le 5ème). Sinon on a déjà calculé les points des premiers et on peut calculer les PointsRecords du joueur en question.

Vous avez bien avancée :p
Je viens de trouver une formule avec une approche totalement différente des précédentes formules proposées sur ce forum.
Si ça vous interesse... (les pts sont directement calculés, pas besoin de boucle, ni d'avoir le score du précédent).

n=nb de joueur sur le record
p= place du joueur
f(n,p)=100*(n-p+1)*0,9^((p-1)/2)*k^1,7
Puis  E(f) -->partie entière
avec k= (somme des places/somme théorique des places)
somme théorique des places=1+2+3+4+,,,+n = ((n+1)*n)/2


Précision:
la formule est en partie basée sur les égalités,
certes vous allez dire: oui, mais s'il y a des égalités au milieu,
A ce problème, je repond : oui, il y a des égalités au milieu mais elles sont beaucoup plus rares et il y en a rarement 3 à la suite (contrairement aux 1ère place)
Or justement ce système réduit de façon infime (les égalités en milieu de tableau) et sanctionne plus facilement les égalités (scores max)

10 joueurs
1 1000
2 853
3 720
4 597
5 486
6 384
7 291
8 207
9 131
10 62

exemple 10 joueurs (5 première place)
1 ( 680 )
1 ( 680 )
1 ( 680 )
1 ( 680 )
1 ( 680 )
6 ( 261 )
7 ( 198 )
8 ( 141 )
9 ( 89 )
9 ( 89 )

k=44/55 ->k^1,7=0,68

exemple 10 joueurs (beaucoup d'égalité au milieu et fin de tableau)
1 ( 850 )
1 ( 850 )
3 ( 612 )
3 ( 612 )
5 ( 413 )
5 ( 413 )
7 ( 247 )
7 ( 247 )
9 ( 111 )
9 ( 111 )


passons aux scores en général: 100*(n-p+1)*0,9^((p-1)/2)*k^1,7
pour 5 joueurs
1 500
2 379
3 240
4 170
5 81
                         
pour 5 joueurs avec 4 égalités à la suite
1 209
1 209
1 209
1 209
1 33

10 joueurs
1 1000
2 853
3 720
4 597
5 486
6 384
7 291
8 207
9 131
10 62


pour 50 joueurs
1 5000
2 4648
3 4320
4 4012
5 3726
6 2457
7 3207
8 2973
9 2755
10 2551
20 1139
30 455
40 140
50 7

pour 46 joueurs avec  45personnes à la première place
1 74
1 74
,,,
46 0
les 1er gagnent peu->normal 45 joueurs ont fait le score max quand même (soit 98% des joueurs)
le dernier gagne peu, mais il faut savoir que 45 joueurs ont fait le score max (donc c'est facilement à portée de main ET il n'a pas du tout forcé), donc c'est évident qu'il gagne quasiment rien voire rien dans ce cas.
De plus il gagne quand même 10 pts vgr pour avoir posté le record + d'autres s'il le prouve.

j'aime beaucoup ta formule serialbuscontroleur, les différents valeures sont très justes je trouve =D

Ne pas gagner de points en postant un record n'est pas acceptable ;) C'est un principe de VGR.

bon j'avoue ne pas avoir lu les 3 dernières pages mais bon arcade je peux te dire qu'il suffit de rajouter \"+100\" à la fin d'une formule ou autre chose de ce style et puis personne ne pourra jamais avoir 0 point ^^

Why not pour la formule de sérial avec un +10 à la fin...

Je préfère quand même la formule de blackshark, et je pense que je vais réaliser des tests sur une partie fictive du site avec cette formule et cet algo...

Mais pas ce soir :( trop fatigué par les grève du RER B...

niconoe :

Why not pour la formule de sérial avec un +10 à la fin...

Je préfère quand même la formule de blackshark, et je pense que je vais réaliser des tests sur une partie fictive du site avec cette formule et cet algo...

Mais pas ce soir :( trop fatigué par les grève du RER B...

-->+10 à la fin, il n'y a pas de problème
   
-->la formule de BlackShark gére bien les égalités, mais il y a le reste.Plusieurs problème apparaissent:
*ça formule donne beaucoup de pts aux derniers
ex:91/100 (avec des égalités en plus )-->700 pts
*l'écart est le même entre le 1er et le 2ème  ; le 49ème et le 50ème ou le 99ème et le 100ème.
*boucle while+le score n'est pas directement calculé

(extrait du message de BlackShark :L'idée de l'algorithme :
Avec cet algorithme on calculerait d'abord le nombre de PointsRecords gagné par un éventuel n+1ème parmi n posts (\"pm\"), cette valeur permettra de calculer les PointsRecords des n joueurs. On calcule ensuite les PointsRecords du joueur n, puis du joueur n-1 etc... en fonction de la valeur de \"pm\" et de la position du joueur. Dès qu'on rencontre pour la première fois un joueur en 1ère position on calcule le nombre de points records pour les premiers (\"prp\") en fonction de la valeur de \"pm\" et du nombre d'égalité en première place (plus il y a d'égalités à la première place, plus on minimise le nombre de PointsRecords aux premiers). On attribue à ce joueur : \"prp\" PointsRecords, ainsi qu'aux autres joueurs qui seront également premiers.)
       
Autant son ancienne formule était bien (malheureusement un paramètre était à calculé), autant là: je préfére presque l'actuelle (après c'est un avis).

serial le soucis avec ton calcul c'est que le problème de wii sport n'est pas résolu.

A savoir que si le gars fait 299 au bowling au lieu de 300, il perd une quantité incroyable de points, à cause d'une petite quille.

Sauf que ça Arcade, c'est pas gérable, sauf si on fait comme cyberscore : on calcul l'écart entre le 1er et le 2ème et ainsi de suite, et on se sert de cet écart pour calculer les points...

Bha sur les tests de blackshark c'est bon pourtant