Générer toutes les combinaisons possibles en Java
- Utiliser la récurrence pour générer toutes les combinaisons possibles en Java
- Utilisez Inclure-Exclure pour générer toutes les combinaisons possibles en Java
Ce tutoriel montre comment générer toutes les combinaisons possibles des éléments d’un tableau en Java.
Utiliser la récurrence pour générer toutes les combinaisons possibles en Java
Tout d’abord, nous créons un tableau vide qui stockera les sorties. L’idée est de fixer les éléments un par un puis d’utiliser la récurrence.
Enfin, lorsque le nombre d’éléments dans le tableau initial devient égal à la taille des combinaisons, alors nous imprimons le tableau initial. Essayons de l’implémenter en Java.
package delftstack;
import java.io.*;
public class Possible_Combinations {
static void CombinationPossible(int Input_Array[], int Empty_Array[], int Start_Element,
int End_Element, int Array_Index, int r) {
// Current combination is ready to be printed, print it
if (Array_Index == r) {
for (int x = 0; x < r; x++) {
System.out.print(Empty_Array[x] + " ");
}
System.out.println("");
return;
}
for (int y = Start_Element; y <= End_Element && End_Element - y + 1 >= r - Array_Index; y++) {
Empty_Array[Array_Index] = Input_Array[y];
CombinationPossible(Input_Array, Empty_Array, y + 1, End_Element, Array_Index + 1, r);
}
}
static void Print_Combination(int Input_Arrary[], int n, int r) {
int Empty_Array[] = new int[r];
CombinationPossible(Input_Arrary, Empty_Array, 0, n - 1, 0, r);
}
public static void main(String[] args) {
int Input_Array[] = {10, 30, 50, 70, 90, 100};
int r = 3;
int n = Input_Array.length;
Print_Combination(Input_Array, n, r);
}
}
Le code ci-dessus générera toutes les combinaisons possibles du tableau donné sous la forme de trois nombres. Voir la sortie :
10 30 50
10 30 70
10 30 90
10 30 100
10 50 70
10 50 90
10 50 100
10 70 90
10 70 100
10 90 100
30 50 70
30 50 90
30 50 100
30 70 90
30 70 100
30 90 100
50 70 90
50 70 100
50 90 100
70 90 100
Utilisez Inclure-Exclure pour générer toutes les combinaisons possibles en Java
De même, nous créons un tableau vide et utilisons le problème d’identité de Pascal pour générer toutes les combinaisons possibles d’un tableau.
Dans cette méthode, nous considérons les éléments du tableau donné et recupérons en utilisant les deux cas. Le premier cas est l’élément inclus dans la combinaison courante.
Le deuxième cas est que l’élément est exclu de la combinaison actuelle. Essayons d’implémenter cette méthode en Java.
package delftstack;
import java.io.*;
public class Possible_Combinations {
static void PossibleCombinations(
int Input_Array[], int n, int Length, int Array_Index, int Empty_Array[], int x) {
if (Array_Index == Length) {
for (int y = 0; y < Length; y++) System.out.print(Empty_Array[y] + " ");
System.out.println("");
return;
}
if (x >= n)
return;
Empty_Array[Array_Index] = Input_Array[x];
PossibleCombinations(Input_Array, n, Length, Array_Index + 1, Empty_Array, x + 1);
PossibleCombinations(Input_Array, n, Length, Array_Index, Empty_Array, x + 1);
}
static void Print_Combination(int Input_Array[], int n, int Length) {
int Empty_Array[] = new int[Length];
PossibleCombinations(Input_Array, n, Length, 0, Empty_Array, 0);
}
public static void main(String[] args) {
int Input_Array[] = {10, 30, 50, 70, 90, 100};
int Length = 3;
int n = Input_Array.length;
Print_Combination(Input_Array, n, Length);
}
}
Le code ci-dessus générera toutes les combinaisons possibles du tableau donné sous la forme de trois nombres. Voir la sortie :
10 30 50
10 30 70
10 30 90
10 30 100
10 50 70
10 50 90
10 50 100
10 70 90
10 70 100
10 90 100
30 50 70
30 50 90
30 50 100
30 70 90
30 70 100
30 90 100
50 70 90
50 70 100
50 90 100
70 90 100
Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.
LinkedIn Facebook