這可以遞歸地完成嗎？

Question

因此，我和我的朋友試圖編碼這個小遊戲時，我們是一個叫LOVERS .. 其中你寫下2人的名字，沒有中間名的全名，並計算L，O，V的數量， E，R和S的名字，加在一起放在字母旁邊。

樣品：
名稱1：你好
名稱2：護理

L：2
○：1
五：0
E：2
R：1個
S：0

之後您將成對添加它們。

樣品：
L：2> 3> 4> 7> 15> 32
○：1> 1> 3> 8> 17
五：0> 2> 5> 9
E： 2> 3> 4
R：1> 1個
S：0


這裏是怎麼一回事呢？首先你添加的第2個字母的數值... LO然後OV然後VE等等等。直到你在這種情況下得到一個最終答案32 ... 32表示兩個人相互之間相容的百分比。
我知道它很愚蠢。哈哈，但我們只是試圖編寫它的樂趣。我們是philppines的第二年IT學生。無論如何，我們想知道是否有辦法進行RECURSIVELY計算，以及是否有辦法減少使用的陣列數量。
這裏是我們的代碼：

import java.util.*; 

public class LOVERS { 


    static Scanner console = new Scanner(System.in); 

    public static void main(String[] args) { 
     String name1=""; 
     String name2=""; 
     char love[] = {'L','O','V','E','R','S'}; 
     int[] lovers = new int[6]; 
     int[] temp= new int[6]; 
     int[] temp2= new int[6]; 
     boolean done = true; 
while(done){ 
     name1 = getName(); 
     name2 = getName(); 
     temp = getLetterCount(name1); 
     temp2 = getLetterCount(name2); 
     lovers = sumOfLetters(temp,temp2,love); 
     System.out.println(""); 

     int[] firstLayer = new int[5]; 
     int[] secondLayer = new int[4]; 
     int[] thirdLayer = new int[3]; 
     int[] fourthLayer = new int[2]; 

     firstLayer = sums(lovers); 
     secondLayer = sums(firstLayer); 
     thirdLayer = sums(secondLayer); 
     fourthLayer = sums(thirdLayer); 
     int output = fourthLayer[0]+fourthLayer[1]; 
     if(output>100){ 
      output=100; 
     } 

     System.out.println("Result is : "+ output +"%"); 
     System.out.println("Do you want to try again? Y/N :"); 
     char again = ' '; 
     if(again == 'n') 
     { 
      done = false; 
     } 
     else done = true; 
} 



    } 

    public static int[] sums (int[] y){ 
     int[] x = new int[y.length-1]; 
     for(int ctr=1;ctr<y.length;ctr++){ 
      x[ctr-1]=y[ctr-1]+y[ctr]; 
     } 
     return x; 
    } 

    public static String getName(){ 
     String n=""; 
     System.out.println("Enter name: "); 
     n = console.nextLine(); 
     n = n.toUpperCase(); 
     return n; 
    } 

    public static int[] sumOfLetters(int[] temp, int[] temp2, char[] love){ 
     int[] lovers = new int[6]; 
     for(int ctr=0;ctr<6;ctr++){ 
      lovers[ctr]=temp[ctr]+temp2[ctr]; 
      System.out.println(love[ctr]+" - "+lovers[ctr]); 
      } 
     return lovers; 
    } 

    public static int[] getLetterCount(String n){ 
     int[] temp = new int[6]; 
     for(int x=0;x<n.length();x++){ 
       if(n.charAt(x)=='L'){ 
        temp[0]++; 
       } 
       else if(n.charAt(x)=='O'){ 
        temp[1]++; 
       } 
       else if(n.charAt(x)=='V'){ 
        temp[2]++; 
       } 
       else if(n.charAt(x)=='E'){ 
        temp[3]++; 
       } 
       else if(n.charAt(x)=='R'){ 
        temp[4]++; 
       } 
       else if(n.charAt(x)=='S'){ 
        temp[5]++; 
       } 
      } 
     return temp; 
    } 
} 

，你可以看到我們用4個陣列的4層計算，我們使用循環語句進行計算。

所以這可以做到RECURSIVELY？以及我們如何減少使用的數組數量？

這可以幫助我們很好地學習如何做適當的遞歸函數，因爲我們正在學習數據結構。希望你們能幫助我。謝謝

Answer 1

是的，當然你可以遞歸編碼。

首先，你的總和。您可以一次又一次地將字符串傳遞給同一個函數，而不是每次都刪除一個字符。該字符將被添加到您的結果編號中。您的最終檢查將是字符串爲空，然後返回null。評估將返回遞歸，可能會爲字符串中的每個字符加1（否則爲0）。

爲了更清晰，更易讀的代碼，您應該使用枚舉而不是字節數組來存儲您的整數。

此外，而不是靜態函數，使它成爲您可以訪問屬性的類。

對於6個字符的總和，每個級別對它進行相同的操作。因此，每個函數調用都應該添加並返回函數中再次調用的結果。您的最終檢查是隻有第一個整數值爲正值。如果所有其他值都爲0，則第一個值爲您的總和。

Answer 2

是的，你可以遞歸做到這一點：

public static int L(int i) { 
    return (i == 0) ? LVAL : L(i - 1) + O(i - 1); 
} 
public static int O(int i) { 
    return (i == 0) ? OVAL : O(i - 1) + V(i - 1); 
} 
public static int V(int i) { 
    return (i == 0) ? VVAL : V(i - 1) + E(i - 1); 
} 
public static int E(int i) { 
    return (i == 0) ? EVAL : E(i - 1) + R(i - 1); 
} 
public static int R(int i) { 
    return (i == 0) ? RVAL : R(i - 1) + SVAL; 
} 

調用L(5)給你答案。

Answer 3

其實這裏的問題是一個更普遍的一類問題/算法，它是偶然在一些領域沒有人會相信從這個例子很重要的一個實例;）

基本上，你可以把你的三角形上方爲矩陣。即L行（3）中的第二個數字是（0,1），E行中的第三個數值是（3,2）。如果你看看它，你會發現除開始值以外的每個值都依賴於其他兩個節點，這使得它成爲一個2點模板。對於這種問題，有一些非常有趣的算法 - 例如高階模板（LBMHD使用13點或其他）的緩存不經意並行算法。

反正這些東西完全是出於你的聯賽我害怕（不要問我有關詳細信息，來〜） - 甚至有關於這個或多或少最近的論文;）

PS：我的個人小的實現。不能簡單得多，並且具有簡單遞歸程序的典型結構 。你用getVal（0，5）調用它;或者更一般的getVal（0，startVals.length - 1）。試想一下，從解決方案開始向後工作。我們想知道第一行的正確字段是什麼。爲了得到這個，我們需要知道兩個其他兩個領域的值，我們必須先以相同的方式來計算。這樣做直到我們到達一個我們已經知道結果的領域 - 即我們的起始值。

private int[] startVals; // contains start values for all 6 letters. 
// for your example startVals[0] == 2; startVals[5] == 0 

public int getVal(int row, int col) { 
    if (col == 0) return startVals[row]; 
    return getVal(row, col-1) + getVal(row + 1, col - 1); 
}