我想编写一个带有“整数”和“字符串数组列表”的函数，然后返回所有可能的组合。
考虑到所有字符串都是不同的
这是一个例子：
ArrayList<Strings> strings={a,b,c}
int n= strings.size();
k= 1;
String sol="";
while(k!=n+1){
sol+=function(strings,k);//<== this is the problem
k++;
}
String[] solution= sol.split(" ");
及之后删除重复的元素：
//Solution expected:={a,b,c,ab,bc,ac,abc} //the elements should not be repeated
答案 0 :(得分：0)
现在，这是获取字符串排列的有趣转折，说起来容易做起来难。即便如此，如果您实际上有一种方法可以相对简单地完成操作，该方法可以根据每个排列的最小/最大长度值为您提供所需的排列，并且我相信 StackOverflow 就有很多code examples。
通常，排列是在诸如"abc"之类的简单字符串上完成的，而不是在诸如{'a', 'b', 'c'}或{"a", "b", "c"}之类的单个字符/字符串集合中包含的元素上进行的。为了有效地获取所需的排列，您需要将ArrayList元素转换为字符串，以使{"a", "b", "c"}变为"abc"。除非集合中的每个元素实际上都包含多个字符串字符，否则继续集合中的事情毫无意义，因此将集合转换为字符串是有意义的。
首先，您需要一个可以进行字符串排列的方法，我敢肯定，StackOverflow中有很多方法可以解决。无论如何，我将为您提供置换方法的摘要，该方法允许您提供String，提供每个置换的所需字符长度，并删除（或不删除）重复项。该方法只接受一个字符串，以保持该方法的灵活性。但是，它确实返回String的ArrayList，您当然可以通过对代码进行一些修改来将其更改为返回所需的任何内容。如果确实要更改代码，请记住该方法是递归的：
/**
* This method will generate all possible permutations of the supplied input
* string and return all those permutations within an String
* ArrayList.<br><br>
*
* @param inputString (String) The string to acquire permutations
* from.<br>
*
* @param length (Integer) The desired min/max string length of
* returned permutations. In other words, if you only
* want all permutations consisting of 3 characters
* then supply the number 3. If you want all possible
* permutations to be returned then supply the number
* 0.<br>
*
* @param removeDuplicates (Boolean) Supply boolean true to ensure there will
* be no duplicate permutations within the returned ArrayList. Supply false if
* duplicates are desired. You can get duplicate permutations if there are
* duplicate characters within the supplied input string, for example:<pre>
*
* "aabbcc"
*
* can return these permutations:
*
* a, a, b, b, c, c 1 Character Permutations. See the Duplicates?
*
* aa, ab, ac, aa, ab, ac, 2 Character Permutations
* ba, bb, bc, ba, bb, bc, See the Duplicates?
* ca, cb, cc, ca, cb, cc
*
* aab, aac, aba, abb, abc, 3 Character Permutations
* aca, acb, acc, aab, aac, See the Duplicates?
* aba, abb, abc, aca, acb,
* acc, baa, bab, bac, bba,
* bbc, bca, bcb, bcc, baa,
* bab, bac, bba, bbc, bca,
* bcb, bcc, caa, cab, cac,
* cba, cbb, cbc, cca, ccb,
* caa, cab, cac, cba, cbb,
* cbc, cca, ccb
*
* However if boolean true is supplied to remove duplicates the results would
* be:
*
* a, b, c 1 Character Max Permutations. No Duplicates.
*
* aa, ab, ac, ba, bb, bc, 2 Character Max Permutations
* ca, cb, cc No Duplicates
*
* aab, aac, aba, abb, abc, 3 Character Max Permutations
* aca, acb, acc, baa, bab, No Duplicates
* bac, bba, bbc, bca, bcb,
* bcc, caa, cab, cac, cba,
* cbb, cbc, cca, ccb</pre>
*
*
* @param recursiveResult (String) FOR INTERNAL RECURSIVE USE ONLY! DO NOT
* SUPPLY A ARGUMENT HERE!<br>
*
* @return (String ArrayList)
*/
public ArrayList<String> getPermutations(String inputString, final int length,
boolean removeDuplicates, String... recursiveResult) {
String currentResult = "";
if (recursiveResult.length > 0) {
currentResult = recursiveResult[0];
}
//Convert the inputString to a ArrayList of characters...
ArrayList<Character> possibleChars = new ArrayList<>(inputString.length());
for (int i = 0; i < inputString.length(); i++) {
possibleChars.add(inputString.charAt(i));
}
ArrayList<String> result = new ArrayList<>(possibleChars.size());
for (char append : possibleChars) {
String permutation = currentResult + append; //create a new string with an additional character
if (permutation.length() == length || length == 0) {
result.add(permutation); //add the permutation to the result
}
if (possibleChars.size() > 0) {
//make a new list with the appendable characters
ArrayList<Character> possibleCharsUpdated = (ArrayList) possibleChars.clone();
//from that list, exclude the character we just appended
possibleCharsUpdated.remove(new Character(append));
//Convert the new character ArrayList to a String
//of characters for the recursion...
String passToRecursion = "";
for (int i = 0; i < possibleCharsUpdated.size(); i++) {
passToRecursion += possibleCharsUpdated.get(i);
}
//merge the result of a recursive call of this method and the result we already had
result.addAll(getPermutations(passToRecursion, length, true, permutation));
}
}
// Remove duplicates if desired...
// LinkedHashSet doesn't allow for Duplicates
// and automatically removes them.
if (removeDuplicates) {
ArrayList<String> tmpArray = new ArrayList<>(new LinkedHashSet<>(result));
result.clear();
result.addAll(tmpArray);
tmpArray.clear();
}
return result;
}
现在要从提供的内容中获得想要的结果，它会像这样：
// Create String ArrayList
ArrayList<String> strings = new ArrayList<>();
strings.add("a"); strings.add("b"); strings.add("c");
// Convert ArrayList to a simple string
String stringToPermutate = String.join("", strings);
// Hold the number of elements within the strings ArrayList
int n = strings.size();
// Counter for while loop condition which will
// ultimately determine the Permutation Character
// Length for each iteration within the WHILE loop.
int k = 1;
// Prepare to build a result string that will hold
// the result from each call to the getPermutations
// method (which by the way is a recursive method).
StringBuilder sol = new StringBuilder();
while (k <= n) {
// Call method to permutate our simple string based
// on the Permutation Character Length stipulated by k
ArrayList<String> permutations = getPermutations(stringToPermutate, k, true);
// Convert ArrayList to a comma (, ) delimited string
String listToString = String.join(", ", permutations);
// Ternary used here instead of IF/ELSE
sol.append(sol.toString().equals("") ? listToString : ", " + listToString);
// Increment counter
k++;
}
// Split the contents of sol into a string Array
String[] solution = sol.toString().split(", ");
// Print solution String Array to Console window.
System.out.println(Arrays.toString(solution));
这是您应该在控制台窗口中显示的最终结果：
[a, b, c, ab, ac, ba, bc, ca, cb, abc, acb, bac, bca, cab, cba]