Question

所以我和我的朋友在我们被称为LOVERS的孩子时试图编写这个小游戏。其中你写下两个人的名字，没有中间名的全名，并在名字中计算L's，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＆gt; 5> 9
E：2> 3> 4
R：1> 1
S：0


这是怎么回事......首先你添加前2个字母的值......然后是OV然后是VE，依此类推。直到你在这种情况下得到一个最终答案32 .... 32表示两个人相互兼容的百分比。
我知道它非常愚蠢。哈哈，但我们只是想把它编程好玩。我们是philppines的第二年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

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

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

这可以递归吗？

3 个答案: