尋找一個單詞在java中可以排列的方式的數量

Question

我正在用java編寫一個程序，它將計算一個單詞可以被排列/重新排列的方式的數量。

例如，單詞「HAPPY」可以用60種方式重新排列。

我的過程是找到字的長度的階乘，然後由存在於字不同的字母的出現的階乘的乘法劃分它。（使用遞歸）。

這裏是我的代碼：

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 

public class Main 
{ 
    public static int factorial(int fact) 
    { 
     if(fact == 0) 
      return 1; 
     else if(fact == 0) 
      return 1; 
     return(fact * (factorial(fact - 1))); 

    } 
    public static void main(String args[]) throws IOException 
    { 
     String word; 
     int result; 
     int cases,lengthOfWord; 
     int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z; 
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
    cases = Integer.parseInt(br.readLine()); 
    for(int iteration =1;iteration <= cases; iteration++) 
    { 
     word = br.readLine(); 
     lengthOfWord = word.length(); 
     a = lengthOfWord - word.replace("A", "").length(); 
     b = lengthOfWord - word.replace("B", "").length(); 
     c = lengthOfWord - word.replace("C", "").length(); 
     d = lengthOfWord - word.replace("D", "").length(); 
     e = lengthOfWord - word.replace("E", "").length(); 
     f = lengthOfWord - word.replace("F", "").length(); 
     g = lengthOfWord - word.replace("G", "").length(); 
     h = lengthOfWord - word.replace("H", "").length(); 
     i = lengthOfWord - word.replace("I", "").length(); 
     j = lengthOfWord - word.replace("J", "").length(); 
     k = lengthOfWord - word.replace("K", "").length(); 
     l = lengthOfWord - word.replace("L", "").length(); 
     m = lengthOfWord - word.replace("M", "").length(); 
     n = lengthOfWord - word.replace("N", "").length(); 
     o = lengthOfWord - word.replace("O", "").length(); 
     p = lengthOfWord - word.replace("P", "").length(); 
     q = lengthOfWord - word.replace("Q", "").length(); 
     r = lengthOfWord - word.replace("R", "").length(); 
     s = lengthOfWord - word.replace("S", "").length(); 
     t = lengthOfWord - word.replace("T", "").length(); 
     u = lengthOfWord - word.replace("U", "").length(); 
     v = lengthOfWord - word.replace("V", "").length(); 
     w = lengthOfWord - word.replace("W", "").length(); 
     x = lengthOfWord - word.replace("X", "").length(); 
     y = lengthOfWord - word.replace("Y", "").length(); 
     z = lengthOfWord - word.replace("Z", "").length(); 
     result = factorial(lengthOfWord)/(factorial(a)*factorial(b)*factorial(c)*factorial(d)*factorial(e)*factorial(f)*factorial(g)*factorial(h)*factorial(i)*factorial(j)*factorial(k)*factorial(l)*factorial(m)*factorial(n)*factorial(o)*factorial(p)*factorial(q)*factorial(r)*factorial(s)*factorial(t)*factorial(u)*factorial(v)*factorial(w)*factorial(x)*factorial(y)*factorial(z)); 
     System.out.printf("Data set %d: %d\n",iteration,result); 
    } 
} 
} 

但我認爲這是非常冗長，效率不高。

我該如何使這個程序更短，更高效？

我也想知道解決這個程序的其他方法。

請協助。謝謝。

Answer 1

你可以保持字母統計長度爲26的數組。另外，字符串替換以檢查字符計數過於複雜。只需循環瀏覽字符並計算它們即可。 letters[word.charAt(j) - 'A']構造是欺騙性的，使A的計數出現在索引0處，B處在索引1處等。使用循環將各個階乘乘以一起。並把這個詞轉換爲大寫。最後，總是聲明變量儘可能接近它們實際使用的位置。 （最後一個就是一般的好習慣。）

全部放在一起：

public static void main(String args[]) throws IOException 
{ 
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
    int cases = Integer.parseInt(br.readLine()); 
    for(int i = 0; i < cases; i++) 
    { 
     int letters = new int[26]; 
     String word = br.readLine().toUpperCase(); 
     int lengthOfWord = word.length(); 
     for (int j = 0; j < lengthOfWord; j++) 
     { 
      letters[word.charAt(j) - 'A']++; 
     } 
     int factorialProduct = 1; 
     for (int j = 0; j < letters.length; j++) 
     { 
      factorialProduct *= factorial(letters[j]); 
     } 
     int result = factorial(lengthOfWord)/factorialProduct; 
     System.out.printf("Data set %d: %d\n",iteration,result); 
    } 
} 

Answer 2

您不使用字母循環的範圍之內，也沒有在一起，所以你可以只使用一個變量

String word; 
int result; 
int cases; 
int lengthOfWord; 
for(int iteration = 1;iteration <= cases; iteration++) { 
    word = br.readLine(); 
    lengthOfWord = word.length(); 
    result = factorial(lengthOfWord); 
    for (int i = 0; i < letters.length; i++) { 
     int divisor = lengthOfWord - word.replace(((char)((int)'A' + i)).toString(), "").length(); 
     result /= divisor; 
    } 
System.out.printf("Data set %d: %d\n", iteration, result);