web-dev-qa-db-fra.com

Une façon intelligente de générer une permutation et une combinaison de chaîne

String database[] = {'a', 'b', 'c'};

Je voudrais générer la séquence de chaînes suivante, basée sur database.

a
b
c
aa
ab
ac
ba
bb
bc
ca
cb
cc
aaa
...

Je ne peux que penser à une jolie solution "factice".

public class JavaApplication21 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        char[] database = {'a', 'b', 'c'};

        String query = "a";
        StringBuilder query_sb = new StringBuilder(query);
        for (int a = 0; a < database.length; a++) {
            query_sb.setCharAt(0, database[a]);
            query = query_sb.toString();                    
            System.out.println(query);            
        }

        query = "aa";
        query_sb = new StringBuilder(query);
        for (int a = 0; a < database.length; a++) {
            query_sb.setCharAt(0, database[a]);    
            for (int b = 0; b < database.length; b++) {    
                query_sb.setCharAt(1, database[b]);    
                query = query_sb.toString();                    
                System.out.println(query);
            }
        }

        query = "aaa";
        query_sb = new StringBuilder(query);
        for (int a = 0; a < database.length; a++) {
            query_sb.setCharAt(0, database[a]);    
            for (int b = 0; b < database.length; b++) {    
                query_sb.setCharAt(1, database[b]);    
                for (int c = 0; c < database.length; c++) {                    
                    query_sb.setCharAt(2, database[c]);                        
                    query = query_sb.toString();                    
                    System.out.println(query);
                }
            }
        }
    }
}

La solution est assez stupide. Il n’est pas évolutif en ce sens que

  1. Et si j'augmente la taille de database?
  2. Que se passe-t-il si la longueur de ma chaîne d'impression ciblée finale doit être N?

Existe-t-il un code intelligent capable de générer une permutation évolutive et une chaîne de combinaison de manière vraiment intelligente?

javaalgorithmcombinationspermutation
14
Cheok Yan Cheng

Vous devriez vérifier cette réponse: Obtenir toutes les permutations possibles d'une chaîne ou d'une combinaison incluant des caractères répétés en Java

Pour obtenir ce code:

public static String[] getAllLists(String[] elements, int lengthOfList)
{

    //lists of length 1 are just the original elements
    if(lengthOfList == 1) return elements; 
    else {
        //initialize our returned list with the number of elements calculated above
        String[] allLists = new String[(int)Math.pow(elements.length, lengthOfList)];

        //the recursion--get all lists of length 3, length 2, all the way up to 1
        String[] allSublists = getAllLists(elements, lengthOfList - 1);

        //append the sublists to each element
        int arrayIndex = 0;

        for(int i = 0; i < elements.length; i++){
            for(int j = 0; j < allSublists.length; j++){
                //add the newly appended combination to the list
                allLists[arrayIndex] = elements[i] + allSublists[j];
                arrayIndex++;
            }
        }
        return allLists;
    }
}

public static void main(String[] args){
    String[] database = {"a","b","c"};
    for(int i=1; i<=database.length; i++){
        String[] result = getAllLists(database, i);
        for(int j=0; j<result.length; j++){
            System.out.println(result[j]);
        }
    }
}

Bien que la mémoire puisse encore être améliorée, cette solution générant d’abord toutes les solutions de mémoire (la matrice) avant de pouvoir l’imprimer. Mais l'idée est la même, qui consiste à utiliser un algorithme récursif.

16
justhalf

Cela sent comme compter en binaire:

  • 001 
  • 010 
  • 011 
  • 100 
  • 101 
  • ...

Mon premier réflexe serait d’utiliser un compteur binaire comme "bitmap" de caractères pour générer les valeurs possibles. Cependant, il existe plusieurs réponses intéressantes à des questions connexes suggérant d'utiliser la récursivité. Voir

3
dj_segfault

Implémentation Java de votre générateur de permutation: -

public class Permutations {


    public static void permGen(char[] s,int i,int k,char[] buff) {
        if(i<k) {
            for(int j=0;j<s.length;j++) {

                buff[i] = s[j];
                permGen(s,i+1,k,buff);
            }
        }       
        else {

         System.out.println(String.valueOf(buff)); 

        }

    }

    public static void main(String[] args) {
        char[] database = {'a', 'b', 'c'};
        char[] buff = new char[database.length];
        int k = database.length;
        for(int i=1;i<=k;i++) {
            permGen(database,0,i,buff);
        }

}

}
2
Vikram Bhat

je suis tombé sur cette question comme l'une des questions de l'entrevue. Voici la solution que j'ai mise en œuvre pour résoudre ce problème en utilisant la récursivité.

public class PasswordCracker {

private List<String> doComputations(String inputString) {

    List<String> totalList =  new ArrayList<String>();
    for (int i = 1; i <= inputString.length(); i++) {

        totalList.addAll(getCombinationsPerLength(inputString, i));
    }
    return totalList;

}

private ArrayList<String> getCombinationsPerLength(
        String inputString, int i) {

    ArrayList<String> combinations = new ArrayList<String>();

    if (i == 1) {

        char [] charArray = inputString.toCharArray();
        for (int j = 0; j < charArray.length; j++) {
            combinations.add(((Character)charArray[j]).toString());
        }
        return combinations;
    }
    for (int j = 0; j < inputString.length(); j++) {

        ArrayList<String> combs = getCombinationsPerLength(inputString, i-1);
        for (String string : combs) {
            combinations.add(inputString.charAt(j) + string);
        }
    }

    return combinations;
}
public static void main(String args[]) {

    String testString = "abc";
    PasswordCracker crackerTest = new PasswordCracker();
    System.out.println(crackerTest.doComputations(testString));

}
}
0
DeepInJava

Pour ceux qui recherchent des options non récursives, voici un exemple de permutation numérique (peut facilement être adapté à char. numberOfAgents est le nombre de colonnes et l'ensemble des nombres est compris entre 0 et numberOfActions:

    int numberOfAgents=5;
    int numberOfActions = 8;
    byte[][]combinations = new byte[(int)Math.pow(numberOfActions,numberOfAgents)][numberOfAgents];

    // do each column separately
    for (byte j = 0; j < numberOfAgents; j++) {
        // for this column, repeat each option in the set 'reps' times
        int reps = (int) Math.pow(numberOfActions, j);

        // for each column, repeat the whole set of options until we reach the end
        int counter=0;
        while(counter<combinations.length) {
            // for each option
            for (byte i = 0; i < numberOfActions; i++) {
                // save each option 'reps' times
                for (int k = 0; k < reps; k++)
                    combinations[counter + i * reps + k][j] = i;
            }
            // increase counter by 'reps' times amount of actions
            counter+=reps*numberOfActions;
        }
    }

    // print
    for(byte[] setOfActions : combinations) {
        for (byte b : setOfActions)
            System.out.print(b);
        System.out.println();
    }
0
BlueMoon93

Ok, donc la meilleure solution aux permutations est la récursivité. Supposons que vous ayez n lettres différentes dans la chaîne. Cela produirait n sous-problèmes, un pour chaque ensemble de permutations commençant par chaque lettre unique. Créez une méthode permutationsWithPrefix(String thePrefix, String theString) qui résoudra ces problèmes individuels. Créez une autre méthode listPermutations(String theString) une implémentation serait quelque chose comme 

void permutationsWithPrefix(String thePrefix, String theString) {
   if ( !theString.length ) println(thePrefix + theString);
   for(int i = 0; i < theString.length; i ++ ) {
      char c = theString.charAt(i);
      String workingOn = theString.subString(0, i) + theString.subString(i+1);   
      permutationsWithPrefix(prefix + c, workingOn);
   }
} 

void listPermutations(String theString) {
   permutationsWithPrefix("", theString);
}
0
Jesse Nelson
// IF YOU NEED REPEATITION USE ARRAYLIST INSTEAD OF SET!!

import Java.util.*;
public class Permutation {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("ENTER A STRING");
        Set<String> se=find(in.nextLine());
        System.out.println((se));
    }
    public static Set<String> find(String s)
    {
        Set<String> ss=new HashSet<String>();
        if(s==null)
        {
            return null;
        }
        if(s.length()==0)
        {
            ss.add("");
        }
        else
        {
            char c=s.charAt(0);
            String st=s.substring(1);
            Set<String> qq=find(st);
            for(String str:qq)
            {
                for(int i=0;i<=str.length();i++)
                {
                    ss.add(comb(str,c,i));
                }
            }
        }
        return ss;

    }
    public static String comb(String s,char c,int i)
    {
        String start=s.substring(0,i);
        String end=s.substring(i);
        return start+c+end;
    }

}


// IF YOU NEED REPEATITION USE ARRAYLIST INSTEAD OF SET!!
0
Rathina Moorthy Nataraj