java - 这可以递归完成吗？

Question

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

样本:
姓名1:你好
名称 2:护理

长度:2
○:1
电压:0
电子:2
回复: 1
: 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
: 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，则第一个值保存您的总和。