java - 这可以递归地完成吗？

Question

所以我和我的 friend 在我们还是 child 的时候就尝试编写这个小游戏，叫做 LOVERS.. 其中写下2个人的名字，全名，不含中间名，并数出名字中L、O、V、E、R、S的个数，相加后放在字母旁边。

示例:
姓名1:你好
名称2:关怀

长:2
奥:1
V:0
E: 2
R: 1
S: 0

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

示例:
长: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


事情是这样的...首先添加前 2 个字母的值...LO 然后 OV 然后 VE 等等。直到你在这种情况下得到一个最终答案 32....32 表示两个人彼此兼容的百分比。
我知道这很愚蠢。哈哈，但我们只是为了好玩而尝试编程。我们是菲律宾的信息技术二年级学生。无论如何，我们想知道是否有一种方法可以递归地进行计算，以及是否有一种方法可以减少使用的数组数量。
这是我们的代码:

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，则第一个值保存您的总和。