Obtenir toutes les combinaisons possibles d'un tableau d'objets

Question

Je me suis arrêté brusquement dans le développement d'une application de la mienne.

J'ai besoin pour obtenir toutes les combinaisons possibles d'un tableau d'arguments, par exemple le tableau pourrait ressembler à ceci

[Integer, Boolean, String]

Le total des combinaisons possibles seraient alors 7 (2^X - 1, où X est la quantité d'arguments, une formule que moi et un ami avons trouvée en essayant de résoudre ce problème)

Voici une visualisation des combinaisons possibles.
[Integer, Boolean, String],
[Entier, Booléen],
[Integer, String],
[Entier],
[Boolean, String],
[booléen] et
[Chaîne ]

Comme vous pouvez le voir dans la visualisation la seule chose qui est nécessaire est que les entrées ont toujours le même ordre les unes par rapport aux autres (Integer doit toujours être avant Boolean et String, et Boolean doit toujours être avant String)

Ce que je demande est:
Comment puis-je trouver toutes les combinaisons possibles d'un tableau de chaînes où les combinaisons ne sont pas limitées à une longueur spécifique des entrées actuelles, mais se limitent à avoir le même ordre des entrées relatives à chaque autre?

Si quelqu'un pouvait me pousser dans la bonne direction, ce serait très apprécié. J'ai regardé quelques articles à propos de trouver toutes les valeurs possibles, mais je n'ai pas trouvé de poste qui m'aide.

Si plus d'informations sur le problème est nécessaire ne hésitez pas à demander

Answer 1

Permettez-moi de vous donner conseil:

Vérifiez la présentation binaire des nombres décimaux:

0 000 
1 001 
2 010 
3 011 
4 100 
5 101 
6 110 
7 111 

Maintenant, permet organiser vos combinaisons de cette façon:

[_, _, _] 
[_, _, S] 
[_, B, _] 
[_, B, S] 
[I, _, _] 
[I, _, S] 
[I, B, _] 
[I, B, S] 

La prochaine étape est pour vous d'implémenter le nombre N-bit

Answer 2

Vous êtes à la recherche d'un problème de combinaison. Si vous avez des arguments (1..N), vous voudriez avoir une séquence de combinaison en utilisant l'entrée (1..N). Une fois la combinaison récupérée, vous pouvez utiliser les valeurs (v1, v2, v3) comme index dans le tableau argumentList pour récupérer les combinaisons d'objets spécifiques. Utilisez le code suivant de geeksforgeeks comme référence et vous pouvez le construire par-dessus.

// Java program to print all combination of size r in an array of size n 
import java.io.*; 

class Permutation { 

    /* arr[] ---> Input Array 
    data[] ---> Temporary array to store current combination 
    start & end ---> Staring and Ending indexes in arr[] 
    index ---> Current index in data[] 
    r ---> Size of a combination to be printed */ 
    static void combinationUtil(int arr[], int data[], int start, 
           int end, int index, int r) 
    { 
     // Current combination is ready to be printed, print it 
     if (index == r) 
     { 
      for (int j=0; j<r; j++) 
       System.out.print(data[j]+" "); 
      System.out.println(""); 
      return; 
     } 

     // replace index with all possible elements. The condition 
     // "end-i+1 >= r-index" makes sure that including one element 
     // at index will make a combination with remaining elements 
     // at remaining positions 
     for (int i=start; i<=end && end-i+1 >= r-index; i++) 
     { 
      data[index] = arr[i]; 
      combinationUtil(arr, data, i+1, end, index+1, r); 
     } 
    } 

    // The main function that prints all combinations of size r 
    // in arr[] of size n. This function mainly uses combinationUtil() 
    static void printCombination(int arr[], int n, int r) 
    { 
     // A temporary array to store all combination one by one 
     int data[]=new int[r]; 

     // Print all combination using temprary array 'data[]' 
     combinationUtil(arr, data, 0, n-1, 0, r); 
    } 

    /*Driver function to check for above function*/ 
    public static void main (String[] args) { 
     int arr[] = {1, 2, 3, 4, 5}; 
     int r = 3; 
     int n = arr.length; 
     printCombination(arr, n, r); 
    } 
} 

Référence: http://www.geeksforgeeks.org/print-all-possible-combinations-of-r-elements-in-a-given-array-of-size-n/

Answer 3

essayer.

String[] array = {"Integer","Boolean","String"}; 
for (int i = 1, max = 1 << array.length; i < max; ++i) { 
    for (int j = 0, k = 1; j < array.length; ++j, k <<= 1) 
     if ((k & i) != 0) 
      System.out.print(array[j] + " "); 
    System.out.println(); 
} 

résultat

Integer 
Boolean 
Integer Boolean 
String 
Integer String 
Boolean String 
Integer Boolean String