Toutes les combinaisons possibles d'un tableau

J'ai un tableau de chaîne de

{"ted", "williams", "golden", "voice", "radio"}

et je veux toutes les combinaisons possibles de ces mots-clés dans le formulaire suivant:

{"ted",
 "williams",
 "golden", 
 "voice", 
 "radio",
 "ted williams", 
 "ted golden", 
 "ted voice", 
 "ted radio", 
 "williams golden",
 "williams voice", 
 "williams radio", 
 "golden voice", 
 "golden radio", 
 "voice radio",
 "ted williams golden", 
 "ted williams voice", 
 "ted williams radio", 
 .... }

J'ai été comme ça pendant des heures sans résultat efficace (effet secondaire de programmation de haut niveau ??).

Je sais que la solution devrait être évident, mais je suis coincé, honnêtement ! Solutions en Java/C# sont acceptés.

MODIFIER:

  1. C'est pas des devoirs à faire à
  2. "ted williams" et "ted williams" sont considérés de la même manière, si je veux "ted williams" seulement

EDIT 2: après avoir examiné le lien dans la réponse, il s'avère que la Goyave, les utilisateurs peuvent avoir l'ensemble des parties de la méthode dans com.google.commun.collecter.Jeux de

source d'informationauteur FearUs

  1. 15

    EDIT: Comme FearUs souligné, une meilleure solution est d'utiliser la Goyave est Les ensembles.powerset(Set).

    EDIT 2: mise à Jour des liens.

    Rapide et sale de la traduction de cette solution:

    public static void main(String[] args) {

    List<List<String>> powerSet = new LinkedList<List<String>>();

    for (int i = 1; i <= args.length; i++)
        powerSet.addAll(combination(Arrays.asList(args), i));

    System.out.println(powerSet);
}

public static <T> List<List<T>> combination(List<T> values, int size) {

    if (0 == size) {
        return Collections.singletonList(Collections.<T> emptyList());
    }

    if (values.isEmpty()) {
        return Collections.emptyList();
    }

    List<List<T>> combination = new LinkedList<List<T>>();

    T actual = values.iterator().next();

    List<T> subSet = new LinkedList<T>(values);
    subSet.remove(actual);

    List<List<T>> subSetCombination = combination(subSet, size - 1);

    for (List<T> set : subSetCombination) {
        List<T> newSet = new LinkedList<T>(set);
        newSet.add(0, actual);
        combination.add(newSet);
    }

    combination.addAll(combination(subSet, size));

    return combination;
}

    Test:

    $ java PowerSet ted williams golden
[[ted], [williams], [golden], [ted, williams], [ted, golden], [williams, golden], [ted, williams, golden]]
$
  2. 4

    J'ai juste été confronté à ce problème et n'était pas vraiment heureux avec les StackExchange réponses postées, donc voici ma réponse. Cela renvoie toutes les combinaisons à partir d'un tableau de Port objets. Je laisse au lecteur le soin de s'adapter à ce que la classe que vous utilisez (ou générique).

    Cette version n'utilise pas la récursivité.

    public static Port[][] combinations ( Port[] ports ) {

    List<Port[]> combinationList = new ArrayList<Port[]>();
    //Start i at 1, so that we do not include the empty set in the results
    for ( long i = 1; i < Math.pow(2, ports.length); i++ ) {
        List<Port> portList = new ArrayList<Port>();
        for ( int j = 0; j < ports.length; j++ ) {
            if ( (i & (long) Math.pow(2, j)) > 0 ) {
                //Include j in set
                portList.add(ports[j]);
            }
        }
        combinationList.add(portList.toArray(new Port[0]));
    }
    return combinationList.toArray(new Port[0][0]);
}
  3. 3

    Voici un indice:

    All-Subsets(X) = {union for all y in X: All-Subsets(X-y)} union {X}
  4. 1
    package rnd;

import java.util.ArrayList;

public class Rnd {
    public static void main(String args[]) {
        String a[] = {"ted", "williams", "golden", "voice", "radio"};
        ArrayList<String> result =new ArrayList<>();
        for(int i =0 ;i< a.length; i++){
            String s = "";
            for(int j =i ; j < a.length; j++){
                s += a[j] + " " ;
                result.add(s);
            }
        }
    }
}
  5. 1

    Mon optimisé solution est basée sur la solution fournie par Matthieu McPeak. Cette version permet d'éviter d'inutiles tableau des copies.

    public static <T> T[][] combinations(T[] a) {

    int len = a.length;
    if (len > 31)
        throw new IllegalArgumentException();

    int numCombinations = (1 << len) - 1;

    @SuppressWarnings("unchecked")
    T[][] combinations = (T[][]) java.lang.reflect.Array.newInstance(a.getClass(), numCombinations);

    //Start i at 1, so that we do not include the empty set in the results
    for (int i = 1; i <= numCombinations; i++) {

        @SuppressWarnings("unchecked")
        T[] combination = (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(),
                Integer.bitCount(i));

        for (int j = 0, ofs = 0; j < len; j++)
            if ((i & (1 << j)) > 0)
                combination[ofs++] = a[j];

        combinations[i - 1] = combination;
    }

    return combinations;
}
  6. 0

    Je sais que cette question est ancienne, mais je n'ai pas trouver une réponse qui répond à mes besoins. Donc, en utilisant l'idée de l'énergie, et a ordonné de permutations de la goyave, de la bibliothèque, im en mesure d'obtenir un tableau de toutes les combinaisons d'éléments à l'intérieur de mon tableau original.

    Ce que je voulais, c'était ceci:

    Si j'ai un tableau avec trois chaînes de 

    ArrayList<String> tagsArray = new ArrayList<>(Array.asList("foo","bar","cas"));

    Je veux avoir toutes les combinaisons possibles des éléments à l'intérieur d'un tableau:

    {"foo","bar","cas","foobar","foocas","barfoo","barcas","casfoo","casbar","foobarcas","casbarfoo","barcasfoo" . . . . . }

    Donc, pour arriver à ce résultat j'ai mis en place le code suivant, à l'aide de google goyave lib:

      import static com.google.common.collect.Collections2.orderedPermutations;
  import static java.util.Arrays.asList;

  public void createTags(){

    Set<String> tags =  new HashSet<>();
    tags.addAll(tagsArray);
    Set<Set<String>> tagsSets = Sets.powerSet(tags);

    for (Set<String> sets : tagsSets) {
        List<String> myList = new ArrayList<>();
        myList.addAll(sets);
        if (!myList.isEmpty()) {
            for (List<String> perm : orderedPermutations(myList)) {
                System.out.println(perm);
                String myTag = Joiner.on("").join(perm);
                tagsForQuery.add(myTag);
            }
        }
    }

    for (String hashtag : tagsForQuery) {
        System.out.println(hashtag);
    }
}

    J'espère que cela aide quelqu'un, ce n'était pas pour les devoirs à faire, mais pour une application android.