Java 这可以递归地完成吗？

所以我和我的朋友在我们还是被称为情人的孩子的时候尝试编写这个小游戏。。 其中你写下两个人的名字，全名不带中间名，数一数名字中的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表示这两个人彼此兼容的百分比。
我知道这很愚蠢。哈哈，但我们只是为了好玩才编的。我们是菲律宾的二年级IT学生。无论如何，我们想知道是否有一种方法可以递归地进行计算，是否有一种方法可以减少使用的数组数量。
这是我们的代码：

import java.util.*；
公共阶级爱好者{
静态扫描仪控制台=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
字符串名称1=“”；
字符串名称2=“”；
char love[]={'L'，'O'，'V'，'E'，'R'，'S'}；
int[]lovers=新int[6]；
int[]temp=新int[6]；
int[]temp2=新int[6]；
布尔完成=真；
虽然（完成）{
name1=getName（）；
name2=getName（）；
temp=getLetterCount（名称1）；
temp2=getLetterCount（name2）；
情人=情人（临时工、临时工2、爱情）；
System.out.println（“”）；
int[]firstLayer=新的int[5]；
int[]第二层=新int[4]；
int[]第三层=新int[3]；
int[]第四层=新int[2]；
第一层=总和（情人）；
第二层=总和（第一层）；
第三层=总和（第二层）；
第四层=总和（第三层）；
int输出=fourthLayer[0]+fourthLayer[1]；
如果（输出>100）{
输出=100；
}
System.out.println（“结果为：+output+“%”）；
System.out.println（“您想再试一次吗？是/否：”）；
字符再次=“”；
如果（再次=='n'）
{
完成=错误；
}
否则完成=正确；
}
}
公共静态int[]和（int[]y）{
int[]x=新的int[y.length-1]；
对于（int-ctr=1；ctrYes），当然可以递归编码

首先是求和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);
}

嗯…我现在会试着编辑代码..并发布修订版..我希望我明白你的意思..实际上我在做递归函数时有点困惑…无论如何，谢谢你给我提示…如果你想知道递归和优化代码的技巧，为什么不做两个问题呢？这对每个人来说都会容易得多。什么？只创建两个问题关于……你能解释一下吗？我对递归不熟悉，所以请耐心听我说。好的。在递归中，你有一个基本情况和一个递归步骤。基本情况是递归的尾部：这里，它是字母的第一个值。递归步骤包括调用自己，直到到达基本情况（这里是0）。
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);
}