Can this be done Recursively?

So me and my friend tried to code this little game when we were children called LOVERS.. Wherein you write down the name of 2 persons,Whole name without the middle name,and count the number of L's,O's,V's,E's,R's,and S's in the name, add it together and put beside the letters.

Sample:

name 1: Hello

name 2: Care

L: 2

O: 1

V: 0

E: 2

R: 1

S: 0

afterwards you will add them in pairs.

Sample:

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

here's how it goes...first you add the values of the first 2 letters...LO then OV then VE and so on and so forth. until you get one final answer in this case 32....the 32 signifies the percentage in which the 2 people is Compatible with each other.

i know its quite stupid. haha but we just tried to program it for fun. we are 2nd year IT Students here in the philppines. anyway we were wondering if there's a way to do the calculation RECURSIVELY and if there's a way to reduce the number of Arrays used.

Here's our code:

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]++;
   开发者_JAVA百科             }
                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;
    }
}

as you can see we used 4 arrays for the 4 layers of calculation and we used a looping statement for the calculation.

So can this be done RECURSIVELY? and How can we reduce the number of arrays used?

this can help us greatly in learning how to do proper Recursive functions since we are currently learning Data Structures. hope you guys can help me. thanks

---

Yes, of course you can code it recursively.

First of all, your sum-fn. Instead of going through the string byte for byte, you can pass the string to the same function over and over again, just removing one character each time. That character will be added to your result-number. Your final-check will be that the string is empty, then you return null. Evaluation will go back up the recursion, potentially adding 1 (or 0 otherwise) for each character in the string.

For clearer, more readable code you should use enums instead of byte-arrays for storing your ints.

Also, instead of static functions, make it a class in which you can access the attributes.

For the summation of the 6 chars, each level does the same operation on it. So each function call should do that addition and return the result being called in the function again. Your final-check is that only the first integer value positive. If all the other values are 0 the first one holds your sum.

---

Yes, you can do it recursively:

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;
}

Calling L(5) gives you the answer.

---

Actually the problem here is one instance of a much more general class of problems/algorithms which are incidentally quite important in some fields nobody would believe from this example ;)

Basically you can regard your triangle above as a matrix. Ie the second number in the L row (the 3) would be (0,1), 3rd value in the E row would be (3,2). If you look at it you see that every value except the start values depend on exactly two other nodes, which makes this a 2-point stencil. There are some extremely intriguing algorithms out there for this kind of problem - eg a cache oblivious, parallel algorithm for higher-order stencils (LBMHD uses 13-points or something).

Anyways that stuff is completely out of your league I fear (don't ask me about details either~) - there are even more or less recent papers about this ;)

PS: And my personal small implementation. Can't get much simpler and has the typical structure of a simple recursive program. You call it with getVal(0, 5); or more generally getVal(0, startVals.length - 1). Just think about it as working backwards from the solution to the start. We want to know what the right field in the first row has. To get this we need to know two the values of two other fields which we have to compute first in the same manner. This is done until we get to a field where we already know the result - ie our start values.

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);
}