génération des combinaisons d'une loto

Version imprimable

18/08/2019, 21h11
enaouders

génération des combinaisons d'une loto

bonjour les amis, j'aimerai créer un programme d'optimisation de chance de gagner au loto selon certains paramètres en fonction des tirages précédents, pour cela je doit créer une base de donnée contenant toutes les combinaison possible en commençant par la première combinaison jusqu’à la dernière, comme vous le saviez tous pour générer toutes les combinaisons possibles on doit tenir compte des mêmes combi avec un ordre déférents par exemple:

1 2 3 4 5 ou 1 4 3 2 5 ou 5 4 3 2 1 sont les mêmes
est ce qu'il ya quelqu'un qui peux m'aider à éliminer ses combinaisons répétitifs, merci.

Salut,

Si on note {a, b, c, d, e} une combinaison, on peut considérer générer a, en faisant varier a de 1 à 49. Ensuite, pour compléter, il suffit de générer la combinaison {b, c, d, e}. Et on peut considérer que pour générer b, il suffit de le faire varier parmi tous les nombres de 1 à 49, sauf le a déjà choisi. Dans ce cas, bien sûr, on peut choisir un nombre inférieur à a, donc obtenir une configuration qu'on aura déjà généré pour un a précédent (par exemple, si on a {42,...}, b peut être 1, donc on aura {42, 1...} une configuration qui pourra correspondre à {1, 42...}, qu'on ne veut pas. Pour l'éviter, il suffit de parcourir les nombres qui suivent a, donc forcément >a, ou encore de a+1 à n inclus (c'est un indice pour l'algorithme). On voit bien se dégager un algorithme récursif relatif facile à mettre en place. Mais tu peux faire un algorithme itératif si te limites à ta problématique de 5 parmi 49, mais ça oblige à écrire beaucoup plus de code (5 boucles imbriquées).

Par ailleurs, tu te rends bien compte du nombre de combinaisons à générer (1906884), calculable par la méthode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public static long nombreCombinaisons(int n, int k) { if (n < 0 || k < 0 || k > n) throw new IllegalArgumentException(); if (k == 0) { return 1; } else { if (k >= n / 2) { k = n - k; } long r = 1; for (int i = 1, j=n-k+1; i <= k; i++,j++) { r *= j; r /= i; } return r; } }
et donc du temps que ça peut prendre éventuellement à écrire dans une base de données...

19/08/2019, 10h46
enaouders

merci bcp joel.drigo, au faite j'ai reussi par generer toutes les combinaison possible, ce qu'il faut c'est juste d'ajouter une condition tel que les indices i+1>i
ca a marché.
merci.

Par condition "i+1>i", tu veux parler de parcourir les numéros à partir du précédent choisi exclu pour choisir le suivant, je suppose.

Une possibilité de code, récursif, en 2 méthodes, pour optimiser :

Code:

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
public static void main(String[] args) {
		int n=49;
		int k=5; 
		combinaisons(n,k).stream().map(Arrays::toString).forEach(System.out::println);
	}
 
	/**
         * Détermine la liste des combinaisons de k nombres choisis parmi les nombres de 1 à n inclus.
         */
	public static Collection<int[]> combinaisons(int n, int k) {
		if ( n<0 || k<0 || k>n ) throw new IllegalArgumentException();
		List<int[]> list = new ArrayList<>(); // pour stocker toutes les combinaisons
		int[] array = new int[k]; // pour construire une combinaison (le tableau sera recyclé pour généré toutes les combinaisons et copié au moment du stockage dans list)
		combinaisons(list, array, 1, n, 0); // on lance la recherche des combinaisons à partir du premier numéro (1) et en commençant en position 0 dans la combinaison
		return list;
	}
 
	/**
         * @param list pour stocker toutes les combinaisons
         * @param array pour construire une combinaison
         * @param p le premier des nombres à choisir
         * @param n le dernier des nombres à choisir
         * @param j l'endroit dans le tableau où stocker le prochain nombre choisi
         */
	private static void combinaisons(List<int[]> list, int[] array, int p, int n, int j) { 
		if ( j<array.length ) { // on n'est en train de choisir un "numéro"
			for(int i=p; i<=n; i++) { // on parcourt les "numéros" suivants le précédent choisi
				array[j] = i; // on stocke dans la combinaison
				combinaisons(list, array, i+1, n, j+1); // on cherche la suite de la combinaison
			}
		}
		else { // on a une combinaison complète, on la stocke
			list.add(Arrays.copyOf(array, array.length));
		}
	}