반복에서 Java의 배열 순열

Question

사이트에 비슷한 도움이되는 몇 가지 질문이 있지만이 문제를 해결할 수는 없으므로 반복되지 않기를 바랍니다.

이것은 숙제 지정으로 [A, B, C]의 문자 배열로되어 있으며 반복을 사용하여 모든 순열을 가져와야합니다 (반복 사용). 나는 일종의이 코드는 다음을 수행합니다

char[] c = {'A', 'B' , 'C'}; 

public void printAll(char[] c, int n, int k) { 
    if (k == n) { 
     System.out.print(c); 
     return; 
    } 
    else { 
     for (int j = 0; j<n; j++) { 
     for (int m = 0; m<n; m++) { 
      System.out.print(c[k]); 
      System.out.print(c[j]); 
      System.out.print(c[m] + "\r\n"); 
     } 
     } 
    }   
    printAll(c, n, k+1);  
} 

그러나,이 기능은 길이 3의 모든 순열을 인쇄하는 동안, 그것은 길이 2. 그들을 할 수 있도록 출력의 길이를 정의해야 매개 변수 N 내가 생각할 수있는 모든 것을 시도해 보았고 Google 검색 결과를 검토해 보았습니다. 오히려 간단한 문제인 것처럼 보이는 것을 해결할 수 없다는 이유로 나 자신이 더 심했습니다.

Answer 1

과 동일하지만 당신은 당신이 만든 것들을 추적해야한다는 것입니다 , 문자 세트 c 및 원하는 길이 n이 주어집니다.

기술적으로 반복되는 순열과 같은 것은 없습니다. 나는 길이가 n이고 길이가 c 인 모든 문자열을 원한다고 가정합니다.

(핵심 아이디어는 다음과 같습니다 반복으로 지정된 캐릭터 라인의 순열을 생성하기 위해 C# 버전을 여기

printAll(char[] c, int n, String start){ 
    if(start.length >= n){ 
    System.out.println(start) 
    }else{ 
    for(char x in c){ // not a valid syntax in Java 
     printAll(c, n, start+x); 
    } 
    } 
} 

Answer 2

방금 ​​아이디어가있었습니다. 숨겨진 캐릭터 (H 숨김) [A, B, C, H]를 추가 한 다음 고정 길이의 순열을 모두 수행하면 어떻게 할 것인지를 알 수 있습니다. 그런 다음 그것을 읽으면 숨겨진 캐릭터에 머물게됩니다. [B, A, H, C]는 (B, A)가됩니다.

흠는 단점은 만약 내가 제대로 이해 [B가, H, A, C가] [B, H, C, A]

Answer 3

됩니다 : 코드에서

to generate all strings of length N with letters from C 
-generate all strings of length N with letters from C 
    that start with the empty string. 

to generate all strings of length N with letters from C 
    that start with a string S 
-if the length of S is N 
    -print S 
-else for each c in C 
    -generate all strings of length N with letters from C that start with S+c 

:

당신은이 방법을 수행 할 수 있습니다 - 길이가 n이고 반복이있는 순열의 수는 n^n입니다.

string[] GetPermutationsWithRepetition(string s) 
     { 
      s.ThrowIfNullOrWhiteSpace("s"); 
      List<string> permutations = new List<string>(); 
      this.GetPermutationsWithRepetitionRecursive(s, "", 
       permutations); 
      return permutations.ToArray(); 
     } 
     void GetPermutationsWithRepetitionRecursive(string s, string permutation, List<string> permutations) 
     { 
      if(permutation.Length == s.Length) 
      { 
       permutations.Add(permutation); 
       return; 
      } 
      for(int i =0;i<s.Length;i++) 
      { 
       this.GetPermutationsWithRepetitionRecursive(s, permutation + s[i], permutations); 
      } 
     } 

아래는 대응 유닛 테스트입니다

[TestMethod] 
     public void PermutationsWithRepetitionTests() 
     { 
      string s = ""; 
      int[] output = { 1, 4, 27, 256, 3125 }; 
      for(int i = 1; i<=5;i++) 
      { 
       s += i; 
       var p = this.GetPermutationsWithRepetition(s); 
       Assert.AreEqual(output[i - 1], p.Length); 
      } 
     } 

Answer 4

난 반복과 순열이 자바 구현을 사용한다. A ~ (n, m) : n = 배열의 길이, m = k. m은 n보다 크거나 작을 수 있습니다.

public class Permutations { 


    static void permute(Object[] a, int k, PermuteCallback callback) { 
     int n = a.length; 

     int[] indexes = new int[k]; 
     int total = (int) Math.pow(n, k); 

     Object[] snapshot = new Object[k]; 
     while (total-- > 0) { 
      for (int i = 0; i < k; i++){ 
       snapshot[i] = a[indexes[i]]; 
      } 
      callback.handle(snapshot); 

      for (int i = 0; i < k; i++) { 
       if (indexes[i] >= n - 1) { 
        indexes[i] = 0; 
       } else { 
        indexes[i]++; 
        break; 
       } 
      } 
     } 
    } 

    public static interface PermuteCallback{ 
     public void handle(Object[] snapshot); 
    }; 

    public static void main(String[] args) { 
     Object[] chars = { 'a', 'b', 'c', 'd' }; 
     PermuteCallback callback = new PermuteCallback() { 

      @Override 
      public void handle(Object[] snapshot) { 
       for(int i = 0; i < snapshot.length; i ++){ 
        System.out.print(snapshot[i]); 
       } 
       System.out.println(); 
      } 
     }; 
     permute(chars, 8, callback); 
    } 

} 

예 출력

aaaaaaaa 
baaaaaaa 
caaaaaaa 
daaaaaaa 
abaaaaaa 
bbaaaaaa 
... 
bcdddddd 
ccdddddd 
dcdddddd 
addddddd 
bddddddd 
cddddddd 
dddddddd