Thread: AddEmUp

add the elements in a array and return the sum. Its supposed to be a recursive method

Are you sure above the recursive requirement? That's not a normal requirement for processing arrays.

For ease of testing the code, use a hardcoded array to get the logic of the method worked out, then copy the working method into the main program. You can define an array with numbers in it by:

int[] anArray = new int[] {2, 3, 4, 5, 6}; // define an array of int for testing

The Scanner input requirement just makes it hard to test the method and get it working.

Where is the subArray() method defined? I can't find it in my API doc.

If there isn't one, how will a poor student figure out how to create a sub array?

Ok, to do recursion you need at least 2 methods. 1 method to begin the recursion, and 1 method to do the recursion. The 1st method will simply call the 2nd method with the starting case. The 2nd method will continuity call itself and send itself different data until an exit case is met.

Ok, so we know to stop when we reach the end of our array. But, we dont know for sure when the end of the array is met. So, like you coded, we need to send the length of the array. BUT, we also need access to the Array so we can get the numbers, which we currently dont have due to scope. So there are two options. 1, make the array static and declare it outside your main but construct it inside your main. 2, send it with the method. Regardless of your choice, it makes it sort of pointless to send it the amountofNumbers variable since we can get that from the array.

So, I'll show you the code for the 2nd since that is probably the easiest because of your setup.

public static int runProcess(int[] arr)
{
     //Call our recursive method and send it the array and our starting case, 0
     return addElements(arr,0);
}
public static int addElements(int[] arr, int count)
{
     //Get the number in the position in our array
     int tempNum = arr[count];
     //Check to see if the current number is the last number in the array. arr.length-1 is used 
     //because the array starts at 0
     if(count==arr.length-1)
     {
          //This is the last element, return it the previous addElements call
          return tempNum;
     }
     //Add our number and call the next addElements method. Remember to increase count by 1 
     //so we progress through the array.
     return tempNum + addElements(arr,count++);
}

I havent tested the code, but it should work.

So, what is happening here? Lets use Norm's array to explain since it is not that big.

Here is our array: int[] anArray = new int[] {2, 3, 4, 5, 6};

With our call to runProcess(anArray); we start the recursion. This method will call addElement. addElement will determine tempNum = 2 (our first number). The current count = 0, this is not equal to 4 (arr.length-1) so it ignores the if statement. Now we return our number (2) added to a call to addElement and we send it arr and 1.
**Remember, the first addElement is still running until it gets the results from our new addElement call in order to add the numbers and return the value to runProcess.**
So our addElement runs with its new parameters. TempNum = 3. Count = 1. Ignore the if statement. Return 3 + addElement(arr,2).
addElement(arr,2) runs with its new parameters. TempNum = 4. Count = 2. Ignore the if statement. Return 4 + addElement(arr,3).
addElement(arr,3) runs with its new parameters. TempNum = 5. Count = 3. Ignore the if statement. Return 5 + addElement(arr,4).
addelement(arr,4) runs with its new parameters. TempNum = 6. Count = 4. Hey, 4 does equal 4, so we use the if statement. We return 6. But where to? Well, we return it to our previous addElement call, addElement(arr,3).
So, back to addElement(arr,3). Now we can return our value. So, we return 5 + 6. And we return it to our previous addElement call.
So, back to addElement(arr,2). Now we can return our value. So, we return 4 + 11. And we return it to our previous addElement call.
So, back to addElement(arr,1). Now we can return our value. So, we return 3 + 15. And we return it to our previous addElement call.
So, back to addElement(arr,0). Now we can return our value. So, we return 2 + 18. But, this is our original addElement call, so we return it to runProcess.
runProcess now returns 20 to our main, which is the correct answer.


Recursion is something that is very difficult to wrap your mind around when you first use it.That is why I tried to provide you with exactly what is happening. If you have any questions, ask and I'll see what I can answer.

I'll have a look at work. It may be because you named the Array "Array" (because thats a reserved word I think), but I'll have a look.

Also, remove your call to addElements(Array, 0) from your main. We make that call in runProcess.

And also please put your code in code tags to keep formatting. Left adjusted code is hard to read.

Here is what it should be:

import java.util.*;
 
public class Test
{
 
    public static void main(String[] args)
    {
		System.out.println("Hello User");
		System.out.println("How many numbers would you like to enter?");
		Scanner input=new Scanner(System.in);
		int amountofNumbers= input.nextInt();
		if(amountofNumbers>1)
		{
			System.out.println("Very Well then. "+amountofNumbers+" numbers it will be.");
			Scanner keyboard=new Scanner(System.in);
			System.out.println("Enter "+amountofNumbers+" numbers");
			int[] Array =new int [amountofNumbers];
			for(int index=0; index<amountofNumbers; index++)
			{
				Array[index]=keyboard.nextInt();
			}
			System.out.println(runProcess( Array));
		}
		else
		{
			System.out.print("I need atleast one number in the list! come on help me out here.");
		}
 
	}
	public static int runProcess(int[]Array)
	{
		return addElements(Array,0);
	}
	public static int addElements(int[]Array, int count)
	{
		int tempNum=Array[count];
		if(count==Array.length-1)
		{
			return tempNum;
		}
			return tempNum+addElements(Array, count+1);
	}
}

ok thx ill try that

it worked thx alot man