这可以递归完成吗？

Question

所以我和我的朋友在我们还是孩子的时候就尝试编写这个叫做 LOVERS 的小游戏。 其中写下2个人的名字，全名不加中间名，数名字中L、O、V、E、R、S的个数，加起来放在字母旁边。

示例：
名称 1：你好
名称 2：护理

左：2
O: 1
五：0
E：2
回复：1
S: 0

之后，您将成对添加它们。

示例：
左：2 > 3 > 4 > 7 > 15 > 32
O: 1 > 1 > 3 > 8 > 17
五：0 > 2 > 5 > 9
E: 2 > 3 > 4
R: 1 > 1
S: 0


事情是这样的……首先你添加前 2 个字母的值……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 层计算，并使用循环语句进行计算。

那么这可以递归地完成吗？以及如何减少使用的数组数量？

这可以极大地帮助我们学习如何执行正确的递归函数，因为我们目前正在学习数据结构。希望你们能帮助我。谢谢

Answer 1

是的，当然你可以递归编码。

首先，你的 sum-fn。您可以一遍又一遍地将字符串传递给同一个函数，而不是逐个字节地遍历字符串，每次只需删除一个字符。该字符将被添加到您的结果编号中。您的最终检查将是该字符串为空，然后您返回 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);
}