组合算法（6选2）

Question

Following this question , I want to now code "6 choose 2" times "4 choose 2." By that I mean, lets say I have 6 characters "ABCDE F." The first time I choose any two characters to delete. The 2nd time I want to choose 2 different letters to delete and then I append the results of these two trials. Hence, I will receive 90("6 choose 2" times "4 choose 2") eight character strings. The characters in the pattern are from the same pattern {1,2,3,4,5, 6}. All the characters are unique and no repetition.

Here is what I have so far.

public String[] genDelPatterns(String design){
    char[] data = design.toCharArray();
    String[] deletionPatterns = new String[15];
    int x = 0;
    StringBuilder sb = new StringBuilder("");
    int index = 0;
    for(int i = 0; i < (6-1); i++){
        for(int j = i+1; j < 6; j++){
            for(int k= 0; k < 6; k++){
                if((k != j) && (k != i))
                    sb.append(String.valueOf(data[k]));
            }
            deletionPatterns[x++] = sb.toString();
            sb = new StringBuilder("");
        }
    }
    return deletionPatterns;
}
public String[] gen8String(String[] pattern1, String[] pattern2){
    String[] combinedPatterns = new String[225];
    int k = 0;
    for(int i = 0; i < 15; i++)
    {
        for(int j = 0; j < 15; j++)
            combinedPatterns[k++] = pattern1[i] + pattern2[j];
    }
    return combinedPatterns;
}

I will be calling the methods like this:

gen8String(genDelPatterns("143256"), genDelPatterns("254316"));

Currently, I am generating all the possible 8 letter strings. But I want to only generate the 8 character strings according to the aforementioned specifications. I am really stuck on how I can elegantly do this multiplication. The only way I can think of is to make another method that does "4 choose 2" and then combine the 2 string arrays. But this seems very roundabout.

EDIT: An example of an 8 character string would be something like "14322516", given the inputs I have already entered when calling gen8String , (143256,254316). Note that the first 4 characters are derived from 143256 with the 5 and 6 deleted. But since I deleted 5 and 6 in the first trail, I am no longer allowed to delete the same things in the 2nd pattern. Hence, I deleted the 3 and 4 from the 2nd pattern.

Answer 1

you have a chain of methods , each one called a variation itself. For so, my advice is to use a recursive method! to achieve your goal you have to have a little experience with this solution.

A simple example of a method that exploits the recursion:

public static long factorial(int n) { 
    if (n == 1) return 1; 
    return n * factorial(n-1); 
} 

I can also suggest you to pass objects (constructed to perfection) for the method parameter, if is too complex to pass simple variables

This is the heart of this solution in my opinion.

Answer 2

While what you tried to do is definitely working, it seems you are looking for other way to implement it. Here is the skeleton of what I would do given the small constrains.

// Very pseudo code
// FOR(x,y,z) := for(int x=y; x<z;x++)

string removeCharacter(string s, int banA, int banB){
     string ret = "";
     FOR(i,1,7){
         if(i != banA && i != banB){
              ret += s[i];
         }
     }
    return ret;
}

List<string> Generate(s1,s2){
    List<string> ret = new List<string>();
    FOR(i,1,7) FOR(j,i+1,7) FOR(m,1,7) FOR(n,m+1,7){
         if(m != i && m != j && n != i && n != j){
             string firstHalf  = removeCharacter(s1,i,j);
             string secondHalf = removeCharacter(s2,m,n);
             ret.Add(firstHalf + secondHalf);
         }
    }
    return ret;
}

This should generate all possible 8-characters string.

Answer 3

Here is the solution I came up with. Doesn't really take "mathematical" approach, I guess. But it does the job.

//generating a subset of 90 eight character strings (unique deletion patterns)
    public static String[] gen8String(String[] pattern1, String[] pattern2){
        String[] combinedSubset = new String[90]; //emty array for the subset of 90 strings
        String  combinedString = ""; //string holder for each combined string
        int index = 0; //used for combinedSubset array
        int present = 0; //used to check if all 6 characters are present

        for(int i = 0; i < 15; i++){

            for(int j = 0; j < 15; j++){
                combinedString = pattern1[i] + pattern2[j]; //combine both 4 letter strings into 8 char length string
                char[] parsedString = combinedString.toCharArray(); //parse into array

                //check if all 6 characters are present
                for(int k = 1; k <= 6; k++)
                {
                    if(new String(parsedString).contains(k+"")) {
                        present++;
                    }
                    else
                        break;
                    //if all 6 are present, then add it to combined subset
                    if(present == 6)
                        combinedSubset[index++] = combinedString;
                }
                present = 0;
            }
        }
        return combinedSubset;
    }