Question

我想知道是否有人能给我们一些关于我的排列需要什么的提示。

我有一个字符串＆＃34; ABC＆＃34;。我想保留＆＃34; ABC＆＃34;的顺序但是在它周围插入各种其他字符。例如，角色＆＃34; X＆＃34;。

以下是一个例子：

鉴于＆＃34; ABC＆＃34;和大小n = 5，生成每个大小为List<string>的{{1}}，保守序列遍布

因此插入A B C X X A X B C X A X B X C A X X B C X A B C X X A B X C X A X B C X X A B C非常简单。我想将其扩展到任何n=2 .....

n和"ABC"

n=8

所以，这段代码为2-X问题提供了＆＃34; X＆＃34; s的索引....

A B C X X X X X

...

X X A X B X C X

...

X X X X X A B C

那么如何扩展这一点以便给定任何int n = 5; for (int i=0; i<n; i++ ){ for (int j=i+1; j<n; j++ ) { System.out.println(i + "- " +j); } }，if将产生基于n的输出，而不是与n和i相关联的输出... ？没有答案，只是暗示如何扩展这一点。我不知道将会有多少X，也不知道字符串输入的长度 - 直到用户给出这些X.

非常感谢， NDG。

Answer 1

生成所有组合的一种方法是依靠递归方法，只要您没有String预期的大小StringBuilder，就可以调用自身public static void main(String[] args) { // Permutes to get all possible Strings of size 5 System.out.println(permute(5)); } public static List<String> permute(int n) { List<String> result = new ArrayList<>(); // Initialize the SringBuilder with ABC and the target size permute(n, result, 0, new StringBuilder(n).append("ABC")); return result; } public static void permute(int n, List<String> result, int start, StringBuilder builder) { if (builder.length() == n) { // The String is complete so we add it to the combination list result.add(builder.toString()); return; } // Iterate from start to the length (included) of StringBuilder for (int j = start; j <= builder.length(); j++) { // Insert X at the position j builder.insert(j, 'X'); // Continue adding X but starting from next index permute(n, result, j + 1, builder); // Remove X at the position j builder.deleteCharAt(j); } } 1}}。递归允许隐式执行动态数量的嵌套循环，这似乎是您当前的问题。

[XXABC, XAXBC, XABXC, XABCX, AXXBC, AXBXC, AXBCX, ABXXC, ABXCX, ABCXX]

<强>输出：

<?xml version="1.0" encoding="UTF-8"?>
<diff>
<paths>
<path
   props="none"
   kind="file"
   item="modified">SDLC\Reports\Phase1 Analysis\report_phase1_code.xls</path>
</paths>
</diff>

Answer 2

这是一个python脚本，它将为您提供获取结果的算法。您可以根据自己使用的语言进行调整。

#!/usr/bin/env python

def comb(n, m, s):
   global a
   r = reversed(range(n))
   for i in r:
      if m > 1:
         comb(i, m-1,s + str(i))
      else:
         b = a[:]
         p = s + str(i)

         for j in range(len(p)):
             b[int(p[j])] = letters[j]
         print(''.join(reversed(b)))


letters = 'ABC'
a = list('X' * 8);
comb(8, 3, '')

#ABCXXXXX
#ABXCXXXX
#ABXXCXXX
#ABXXXCXX
#ABXXXXCX
#ABXXXXXC
#AXBCXXXX
#AXBXCXXX
#AXBXXCXX
#...

Answer 3

那么你必须将C迭代到B右边的每个位置。接下来你将B向右移动并再次向右移动C到每个点。然后你必须为A可以采取的每个职位做到这一点。

ABCXX

ABXCX

ABXXC

AXBCX

AXBXC

AXXBC

XABCX

Answer 4

如果您已经知道字符串的泛型排列的实现，并且您不介意性能问题，那么您可以通过

快速解决此问题

查找android:grantUriPermissions
根据适当的条件筛选列表。

这是我在Java 8 +中的通用置换方法的版本

"ABCXX"

以下是我如何过滤排列以满足您的要求。

public static List<String> permutation(String s) {

    /*
     * # Given
     * 1) permutation("A") = ["A"]
     * 2) permutation("AB") = ["AB", "BA"]
     * 3) permutation("AB") + "C" = ["AB", "BA"] + "C" = ["ABC", "BAC"]
     * 
     * # Assumption
     * - let s = any String
     * - permutation(s) = a union list of permutation(s - x) + x for each letter x in s
     * 
     * # Examples
     * - permutation("ABC") = permutation("AB") + C U permutation("BC") + A U permutation("AC") + B
     *                = ["AB","BA"] + C U ["BC", "CB"] + A U ["AC", "CA"] + B
     *                = ["ABC","BAC"] U ["BCA","CBA"] U ["ACB", "CAB"]
     *                
     * - permutation("ABCD") = permutation("ABC") + D U permutation("BCD") + A U permutation("CDA") + B U permutation("ABD") + C
     * 
     * # Prove
     * - There does not exist an element in permutation of "ABCD" where the last position is not in ("A","B","C","D")
     * 
     */

    /********** Implement **********/

    if (s.length() == 1) {
        return Arrays.asList(s);
    } else {
        List<String> rs = new ArrayList<>();
        for (int i=0; i<s.length(); i++) {
            char x = s.charAt(i);
            String theRest = s.substring(0, i) + s.substring(i+1, s.length());
            // following line means union of [permutation(theRest) + x]
            rs.addAll(permutation(theRest).stream().map(e -> e + x).collect(Collectors.toList()));
        }
        return rs;
    }
    /********************************/
}

尽管性能优异，但这种方法的一个好处是易于理解，因此易于维护。如果你想要其他类型的模式，只需编辑过滤器逻辑。

固定序列排列

4 个答案: