Discussion :

[hug33k]

Bonjour,

Alors voila mon "problème".

Je compte faire un petit jeu (pour l'instant sans interface graphique). Je vous épargne les détails. Ce que je souhaites faire c'est :

• Créer toutes les possibilités de codes à 10 chiffres (0,1,2,3,4,5,6,7,8 et 9) (en utilisant une seule fois chaque chiffre par code)
• Attribuer à chacun des code possible un identifiant (du genre "1", "2", …)
• Géréner un nombre
• En fonction du nombre de codes, attribuer le code correspondant à une variable
• Retrouver ce code

Alors ,quelques petites questions :

• Je sais que, de mémoire, pour connaître le nombre de possibilités possibles, il faut faire (pour mon cas) : 1*2*3*4*5*6*7*8*9*10=3 628 800! C'est juste?
• Serais-je obligé de créer les codes un par un?

Ce que je souhaiterais faire ensuite, c'est créer les variables n1, n2, n3, n4, n5, n6, n7, n8, n9 et n10 qui correspondent, dans l'ordre, au premier chiffre du code, au second, ...
Encore une fois, y aurait-il un moyen de simplifier l'écriture de tout cela en Java?

Merci!

[kolodz]

Bonjour,

J'ai réalisé une implémentation personnelle de votre problème.
J'en ai modifié les spécifications :
Je ne génère pas les 3 628 800 possibilités.
Tout simplement parce que cela représente une taille mémoire énorme.
Même stocker dans un tableau de byte chaque séquence prend 10 octets.
Ce qui fait pas moins de 36 288 000 octets en tout, ce qui fait en gros 34Mo.
Et qu'au niveau calcule, c'est assez long.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
import java.util.Random;
 
 
public class Code {
	private long id =-1; 
	private byte[] n = {-1, -1, -1, -1, -1,
						-1, -1, -1, -1, -1};
	public byte[]getN(){
		return n;
	}
	public static void main(String[] args) {
		Code myCode= new Code(15);
		Code myCode2= new Code(15);
		Code myCode3= new Code(16);
		System.out.println(myCode.equals(myCode2));
		System.out.println(myCode.equals(myCode3));
		System.out.println(myCode+" -- "+myCode2+" -- "+myCode3);
		//Génération de l'intégralité des Code
 		// Algo de génération Non optimisé et nombre de code à généré énorme.
		// Prends plusieurs minutes pour 125560
		Code[] mesCodes = new Code[3628800];
		int index =0;
		int id=-1;
		while(index<3628800){
			id++;
			Code newOne =new Code(id);
			if(!isIn(newOne,mesCodes,index)){
				mesCodes[index]=newOne;
				index++;
			}
			System.out.println("code found : "+index+" current id : "+id);
		}
	}
	private static boolean isIn(Code newOne, Code[] mesCodes, int index) {
		if(index>0){
			for (int i = 0; i < index; i++) {
				if(mesCodes[i].equals(newOne)){
					return true;
				}
			}
		}
		return false;
	}
	public Code(long id) {
		this.id=id;
		int value;
		Random key = new Random();
		key.setSeed(id);
		for (int i = 0; i < n.length; i++) {
			while(this.n[i]==-1){
				value  =key.nextInt(10);
				if(!this.isTaken(value)){
					this.n[i]=(byte)value;
				}
			}
		}
	}
	public boolean isTaken(int value){
		if( n[0]==value || n[1]==value || n[2]==value || n[3]==value || n[4]==value
			|| n[5]==value || n[6]==value || n[7]==value || n[8]==value || n[9]==value){
			return true;
		}
		return false;
	}
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(n[0]);
		sb.append(n[1]);
		sb.append(n[2]);
		sb.append(n[3]);
		sb.append(n[4]);
		sb.append(n[5]);
		sb.append(n[6]);
		sb.append(n[7]);
		sb.append(n[8]);
		sb.append(n[9]);
		return sb.toString();
	}
	@Override
	public boolean equals(Object other) {
		if(other instanceof Code){
			Code otherCode =(Code) other;
			for (int i = 0; i < this.n.length; i++) {
				if(this.n[i]!=otherCode.getN()[i]){
					return false;
				}
			}
			return true;
		}
		return false;
	}
}

Ce code est orienté vers une génération aléatoire. Il serai aussi possible d'imaginé une formule de conversion. Mais cela serai moins stylé.

Cordialement,
Patrick Kolodziejczyk.

[hug33k]

Merci bien!

Je crois que je vais diminuer la quantité de codes!

Et encore une fois, merci!