Discussion :

[CoDuSu]

Salut, je dois créer une boucle infinie qui sort le nom d'un joueur toutes les 10 secondes. Plus un joueur a de points, plus son nom doit sortir souvent (mais pas plus d'un joueur toutes les 10 secondes). En prenant en compte que la liste de joueurs peut contenir aussi bien 3 joueurs que des milliers de joueurs.

Voila mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public class Joueur {
	String name;
	int points;
 
	public Joueur(String name, int points) {
		super();
		this.name = name;
		this.points = points;
	}
 
	public String getName() {
		return name;
	}
 
	public int getPoints() {
		return points;
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
	public static void main(String[] args) {
 
		Joueur joueur1 = new Joueur("joueur1", 550);
		Joueur joueur2 = new Joueur("joueur2", 70);
		Joueur joueur3 = new Joueur("joueur3", 37);
		Joueur joueur4 = new Joueur("joueur4", 7000);
		Joueur joueur5 = new Joueur("joueur5", 1200);
		LinkedList<Joueur> joueursList = new LinkedList<Joueur>(Arrays.asList(joueur1, joueur2, joueur3, joueur4, joueur5));
 
 
		Thread thread = new Thread() {
			public void run() {
				while (true) {
					for (Joueur joueur : joueursList) {
						try {
							Thread.sleep(10000);
							System.out.println(joueur.getName() + ": " +joueur.getPoints() + "pts");
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			}
		};
		thread.start();
	}

Très bien, ça sort bel et bien le nom d'un joueur toutes les 10 secondes mais ça fait 2 heures que je cherche un moyen pour que ça sorte plus souvent ceux qui ont le plus de points (en l'occurence par exemple ce cador de joueur4 grace a ses 7000pts doit sortir exactement 100 fois plus souvent que joueur2 qui a 70pts). Comment feriez vous?

Merci d'avance au champion qui saura m'aider

edit: les joueurs ne doivent pas être affiché au hasard selon un pourcentage de chance mais dans l'ordre le plus representatif possible même sur un court echantillon (par exemple ici avec seulement 5 joueurs, au bout d'une vingtaine de sysout chaque joueur doit voir qu'il a été d'avantage affiché qu'un joueur avec significativement moins de points que lui sans que le hasard ne laisse place a quelconque doute). Ou un autre exemple, si un joueur regarde disons 5 affichages il ne doit y avoir aucune chance pour qu'un joueur avec moins de points que lui soit affiché 2 fois alors que lui ne l'a été qu'une seule fois sur ces 5 échantillon. Logiquement on ne devrait donc pas pas se servir de Random()

Le programme doit afficher les joueurs de la manière la plus variée possible et non pas afficher par exemple 50 fois d'affilé le joueur qui a le plus de points puis 20 fois d'affilé le second joueur qui a le plus de points, etc ...

Le but final est qu'un utilisateur ait besoin de lire le moins de lignes possibles dans la console avant de comprendre que + un joueur a de points + le nom de ce joueur est affiché

[Drowan]

J'ai deux solutions en tête :

1: Tu définis un espace numérique par joueur :
- Joueur1 de 1 à 549
- Joueur2 de 550 à 619 (+70)
- Joueur3 de 620 à 657 (+37)
- Etc ....
- JoueurX de xxx à borneMax

Puis tu tires un nombre au hasard entre 0 et ta borne max. Et en fonction du nombre, tu regardes dans quelle plage numérique le nombre se situe, et tu affiches le joueur correspondant.
Par exemple si tu tires 584, tu es dans la plage du joueur 2 et tu affiche donc "joueur2"


2: Créer un tableau contenant le nom des joueurs autant de fois qu'elles ont de points. (On aura donc 70 éléments "joueur2" et 7000 éléments "joueur4")
Puis lors de l'affichage, on prend un élément au hasard dans le tableau. (Ainsi on a 100 fois plus de chance de voir "joueur4" que "joueur2")
L'avantage est que tu modifier les probabilités au fur et à mesure que les scores évoluent. Si le joueur 3 gagne un point, on rajoute un élément "joueur3" dans le tableau.
Par contre en fonction du système de points, tu risques de te retrouver avec un tableau gigantesque (peut-être que ça peut impacter les performances, je sais pas)

[thelvin]

Afficher chaque joueur autant de fois qu'il a de points ?

... Nous ne pouvons pas deviner ce que ça veut dire dans ta tête, "afficher souvent". Là ton code affiche tous les joueurs en boucle. Il n'y a pas de "souvent" qui tienne.

[CoDuSu]

@Drowan ta première solution est aussi la première qui m'est venue en tête. C'est rassurant Mais j'ai oublié de préciser que les joueurs ne doivent pas sortir au hasard mais dans un ordre representatif même sur un court echantillon (par exemple ici avec seulement 5 joueurs, au bout d'une vingtaine de sysout chaque joueur doit voir qu'il a été d'avantage affiché qu'un joueur avec significativement moins de points que lui sans que le hasard laisse place a quelconque doute). Par exemple ici si le joueur 4 regarde disons 5 affichages il ne doit y avoir aucune chance pour qu'un joueur avec moins de points que lui soit affiché 2 fois alors que lui ne l'a été qu'une seule fois sur ces 5 échantillon. Logiquement on ne devrait donc pas pas se servir de Random(). Ducoup aucune de tes 2 solutions ne convient

@thelvin J'ai ajouté quelques lignes a la fin de mon post derrière "edit:" pour qu'il y ait moins de confusions possibles. J'éspère ne rien avoir oublié cette fois.

[thelvin]

De une, ce sont des maths, pas de la programmation Java. Ce serait assez logique que tu commences par trouver quel genre de construction séquentielle pourrait donner les résultats que tu donnes, et une fois que tu nous l'a décrite précisément, on pourra discuter de comment la programmer en Java.

De deux, c'est impossible. S'il y a deux joueurs A et B et que A a plus de points que B. Et qu'on prend un échantillon de 1 nom. Deux cas possibles :

- C'est B qui est sorti. Mais dans ce cas, avec notre échantillon de 1 nom, on observe que B est sorti 1 fois et A zéro fois, donc B plus que A. Ce qu'on ne veut pas accepter.
- C'est A qui est sorti, parce que B ne sort jamais. Mais dans ce cas, le nom de B n'est jamais utilisé, et on veut pas l'accepter.

Conclusion : tes contraintes sont contradictoires.

[CoDuSu]

- C'est A qui est sorti, parce que B ne sort jamais. Mais dans ce cas, le nom de B n'est jamais utilisé, et on veut pas l'accepter.

On peut évidement tout a fait accepter ça. Je n'ai jamais dit le contraire. "dans l'ordre le plus representatif possible même sur un court echantillon" ne veut pas dire "dans un ordre representatif en toute circonstance" ni même "dans un ordre representatif".

Et c'est bel et bien de la programmation Java. Selon la solution choisie je suppose qu'il peut y avoir un grand écart entre les ressources utilisées. Et il serait aussi peut être bon d'utilisé une ou plusieurs classe que je ne connais pas forcement.

[Drowan]

Par mathématique, thelvin entend algorithmique. Regarde les première solutions que je t'ai proposées, elles n'ont rien à voir avec du Java.
Il faut d'abord résoudre la question de quelle est la procédure que tu veux mettre en place, quelle est la logique.
Et ensuite viendra le Java avec la question "Comment on implémente cette logique".

---

Dans un premier il faudrait mettre plus au clair quelle est la sortie attendue, je trouve que pour l'instant c'est assez flou.


Ce que je comprends c'est :

1. Au premier passage de boucle seul le meilleur joueur peut-être affiché, sinon on enfreint la règle.
2. Au deuxième tour on peut afficher
   
   1. à nouveau le premier
   2. deuxième
   3. les deux
3. - Au troisième tour, on peut
   
   1. afficher le premier
   2. afficher le deuxième si il n'a pas été affiché avant
   3. afficher à nouveau le deuxième si le premier est déjà affiché 2 fois
   4. afficher le troisième si le deuxième a été affiché au moins une fois
   5. afficher plusieurs de ces cas s'il ne se contredise pas
4. - etc...

C'est ça ?