可以递归完成吗？

如何解决可以递归完成吗？

| 所以我和我的朋友在我们还是lovERS的时候就尝试编写这个小游戏。 在其中记下2个人的名字，全名，不包括中间名，并计算L \，O \，V \，E \，R \和S \的数量的名称中，将其添加在一起并放在字母旁边。 样品： 名称1：您好 名称2：护理    L：2 O：1 V：0 E：2 R：1 S：0    之后，您将成对添加它们。 样品： L：2> 3> 4> 7> 15> 32 O：1> 1> 3> 8> 17 V：0> 2> 5> 9 E：2> 3> 4 R：1> 1 S：0       这是怎么回事...首先添加前两个字母的值... LO，然后是OV，然后是VE，依此类推。直到在这种情况下获得最终答案32 .... 32表示两个人彼此兼容的百分比。    我知道它很愚蠢。哈哈，但我们只是尝试对其进行编程以使其有趣。我们是菲律宾的2年级IT专业学生。无论如何，我们想知道是否有一种方法可以递归进行计算，以及是否有一种方法可以减少使用的数组数量。    这是我们的代码：         

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个数组，在计算中使用了循环语句。 那么这可以紧急地完成吗？以及如何减少使用的数组数量？ 由于我们当前正在学习数据结构，因此这可以极大地帮助我们学习如何执行适当的递归函数。希望你们能帮助我。谢谢     

解决方法

        是的，您当然可以对其进行递归编码。 首先，您的总和-fn。您可以一次又一次地将字符串传递给相同的函数，而不必每次都逐个字节地传递字符串，只需每次删除一个字符即可。该字符将添加到您的结果编号中。您的最终检查将是字符串为空，然后返回null。评估将返回递归，可能会为字符串中的每个字符加1（否则为0）。 为了更清晰，更易读的代码，您应该使用枚举而不是字节数组来存储int。 另外，使它成为可访问属性的类，而不是静态函数。 对于6个字符的总和，每个级别对其执行相同的操作。因此，每个函数调用都应进行加法运算，然后再次返回在函数中被调用的结果。您的最终检查结果是只有第一个整数值为正。如果所有其他值均为0，则第一个保持您的总和。     ,        是的，您可以递归执行：

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)

即可得到答案。     ,        实际上，这里的问题是更为常见的问题/算法的一个实例，在某些领域中，偶然发生的问题很重要，没人会从这个例子中相信这一点；） 基本上，您可以将上方的三角形视为矩阵。也就是说，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);
}