We Keep Coding

checking multiplication table arrays

My code keeps returning false what am I doing wrong? This is the feedback I am getting.
checkTable() should only return false when it finds an incorrect entry.
Failed: java.lang.AssertionError: checkTable() should return false when entry at index 0 is not equal to 0.
/**
* This method checks if an array of ints contains a correctly calculated
* multiplication table.<br/>
* Precondition: multTable IS NOT null. (PRECONDITIONS SPECIFY RESPONSIBILITIES
* ON A METHOD'S CALLER; YOU SHOULD ASSUME THIS IS TRUE.)
*
* #param constant
* Value used to check the multiplication table.
* #param multTable
* Table to be checked.
* #return True if every entry in the array stores the value of {#code constant}
* * the index for that entry; or false if at least one entry is
* incorrect.
*/
public static boolean checkTable(int constant, int[] multTable) {
int i=0;
for(i=0;i<multTable.length;i++){
int mult = constant*i;
if(mult==multTable[i]) {
return true;
}
}
return false;
}

Right now you are immediately returning true if only one entry in the Array is valid:
if(mult==multTable[i]) {
return true;
}
It needs to be the other way around:
for(i=0;i<multTable.length;i++){
int mult = constant*i;
if(mult!=multTable[i]) {
return false;
}
}
return true;

Just step through the code, line by line. Let's say the constant is '5', and the input is new int[] {0, 15, 38}; which is clearly not a multiplication table.
int i = 0;: i now exists. The value of i is now 0.
for (int i = 0; i < multTable.length; i++) { we're going to loop 3 times. We enter the loop with the first value (0).
int mult = constant * i;: mult now exists. The value of mult is 0 (because 5*0 is 0).
if (mult == multTable[i]) return true;: mult is 0; the first item in our example multTable input is 0. Therefore the if triggers and the entire method returns, with value true. The remaining elements aren't checked at all.
The fix is obviously NOT to return when the first element is correct. When you hit a 'mistake' you know immediately that the answer to the question "Is this a valid multiplication table" is false. But when you hit a correct entry that doesn't mean you know the answer. You'd have to keep going.
This smells of homework so I'll let you do the honours of figuring out what that means and how you can fix your code.
NB: This is how you solve problems with code: You reason through it. You check what the code actually does (using a debugger, or if that's a bridge too far to learn for now, add a lot of System.out.println statements). The point where your code doesn't match what you thought it should do is the point where you figured out the bug.

Java Recursive Method how does it work?

I'm relatively new to Java programming and I've just started learning recursion, but I can't seem to figure out how this method works in my head.
private static int mystery(int w) {
{
if (w < 0) return 0;
int x = mystery (w-2);
return w - x;
}
}
Whenever a variable like 100 is put in, it outputs 50. When 200 is input, it outputs 100. When 2 is input, it outputs 2. When 25 is input, 13 is output. I'm not sure how this method works, and I'm trying to wrap my head around it.
The way I currently view it, if you put in 100, it'll bypass the first return statement since it is greater than 0.
when it gets to the second line, it'll do 100-2, which brings in 98, then goes to the third line and does 100 - 98 = 2. Which is then returned to the original call.
I know I'm messing up on the second line of the method where the mystery (w-2) is. I assume it would bring back the result of w-2 to the beginning of the method again, and it would continue to do the method over and over again until w is smaller than 0, which should output 0 again regardless of the answer. But that's not what happens, and I don't know why.
Can anyone explain what is going on here?

What you are missing is that on the second line it doesn't just do w - 2, but calls itself with w - 2. It doesn't go further until the call returns. And the second call calls itself if w isn't < 0 and so on until you reach value lower than 0 and then return. The execution will go like this, if you visualize it:
mystery(10)
> skip first line
> x = mystery(8)
> skip first line
> x = mystery(6)
> skip first line
> x = mystery(4)
> skip first line
> x = mystery(2)
> skip first line
> x = mystery(0)
> skip first line
> x = mystery(-2)
> return 0
> return 0 - 0 (0)
> return 2 - 0 (2)
> return 4 - 2 (2)
> return 6 - 2 (4)
> return 8 - 4 (4)
> return 10 - 4 (6)
With example of w = 10. I hope you understand it better now.

private static int mystery(int w) {
{
if (w < 0) return 0;
int x = mystery (w-2);
return w - x;
}
}
Let's imagine that we call mystery(3). What happens? w<0) is false, so we don't return 0. In the next line, we call some function called mystery using the value 3-2=1 as its argument.
Despite the fact that this function we've called happens to be the same one we've just called, it's still an ordinary function call, and it returns a value. It does this by calling the function called mystery, this time using the value -1 as the argument. And this time w<0 is true, so we just return 0. Now we're back in the second call to mystery, and we've set x = 0. So that call returns w - 0 = 1. That puts us back in the first call, and now x = 1, so we return w-x = 3-1 = 2.
You might want to take a few minutes and work through this using w=4 and see what you get - this will help you understand how the recursive calls work.
After you've done this, I suggest you add a print statement or two in the function to tell you where you are and what's happening, and that'll also help - but do it on paper first.

The two given answers are excellent. Both focus on the way how to get a grasp of what recursion is. The problem with recursion is, that it is so unnatural to one who do not know what recursion is, or do not know someone who does. It's like a snake eating itself again and again.
The best way to understand recursion is to write down the calls to a recursive method, by noying the current state when it's called, and after the call write the result back. You stack up the calls and that's also the way to not used recursion at all.
So do not try too hard to understand recursion at first but first focus on the program flow. If you have seen enough recursions, it will come to you.

0.%d range between 0-100 is the same as 100-1000

I have the command:
string.format("movel(p[0.%d,- 0.%d, 0.%d, -0.5121, -3.08, 0.0005])"+ "\n", averageX1, averageY1, averageY2 )
Where average value can change from 0 to 700. When the value is
averageX1 = 344
averageY1 = 222
averageY2 = 150
The command becomes:
movel(p[0.344,- 0.222, 0150, -0.5121, -3.08, 0.0005])
When one of the average becomes lower then 100:
averageX1 = 80
The command becomes
movel(p[0.**80**,- 0.222, 0150, -0.5121, -3.08, 0.0005])
I want it to become :
movel(p[0.**080**,- 0.222, 0150, -0.5121, -3.08, 0.0005]
How can I change this so it will have the value that can be from 0 tot 100.
ps. It is the "0" that must be in front of the "8".
kind regards
pascal

Change 0.%d to 0.%03d. Also see here.

Index out of bounds exception in homework

I'm trying to do a homework assignment. I have to use dynamic programming to display whether the next person to move is in a win/loss state. I don't need help with the actual problem, I need help with an index out of bounds exception I'm getting that baffles me. I'm only going to paste part of my code here, because I only need the for loops looked at. I also don't want anyone in my class seeing all my code and copying it. If you need more data please let me know. So here is the code:
if(primeArray[x] == true){
for(int i = 1; i <= x; i++){
if(primeArray[i]== true){
newRowNumber = x - i;
}
if(dynaProgram[newRowNumber][columnNumber] < minimum){
minimum = dynaProgram[newRowNumber][columnNumber];
}
}
}
//COMPOSITE CASE FOR X!
else{
for(int k = 1; k <= x; k++){
if((primeArray[k] == false)){
newRowNumber = x - k;
}
if(dynaProgram[newRowNumber][columnNumber] < minimum){
minimum = dynaProgram[newRowNumber][columnNumber];
}
}
For some reason the if(primeArray[i] == true runs correctly, but I'm getting index out of bounds exception on if(primeArray[k] == false. The only difference between these two is the use of the variable k over i in the for loop.(the for loops are identical) I haven't used either variables anywhere else in my code. I have no idea why this occurs for one but not the other. In both cases, x remains the same number.
I am also getting an index out of bounds exception on the second minimum = dynaProgram[newRowNumber][columnNumber], while the first doesn't encounter an error. I know it's probably a stupid error, but I can't figure it out. If I change the 'k' for loop to k < x the index of out bounds exception in the if(primeArray[k] == false line goes away, but then it isn't correct. (The error on the second minimum = dynaProgram[newRowNumber][columnNumber] doesn't go away however.)
All this code is in a nested for loop which iterates through the rows and columns in the table to fill them in. If I remove the above code and just put dynaProgram[rowNumber][columnNumber] = 1 I don't have an issue, so I don't believe that is the problem.

When accessing an array of length 5 (for example)
int[] fred = new int[5];
the first element will be fred[0] and the last will be fred[4]
So when doing something like:
if(primeArray[i]== true){
Make sure that i is less than the array length. Using a value of i equal to the array length will throw an exception.

Solving maze using stacks

I been working on this code for a while and can't seem to get it to work. I have started over multiple times. I am not sure if my logic is off or if I could be doing something better. Any suggestion in the right direction or new ideas to try would be helpful. I understand that a maze could be solved recursively but for this part of the assignment I need to use a stack.
I created two stacks. One for the path the other for spots I already searched. Ideally I would check to see if the searched path contains the next spot in a direction. If it does it checks another direction.
Sample maze
0 1 0 1 0
0 0 0 1 0
0 1 0 0 0
0 1 0 1 1
0 1 0 0 0
My algorithm seems to get stuck between 2,3 and 2,4. Never explores 1,4 or 0,4. I see it keep bouncing between 2,3 and 2,4 in an infinite loop. So it seems my searched.contains() is not functioning properly. Any suggestion to fix my searched stack? Ideally, when I run my code. I want it to check East, South, west then North has already been searched or not. If all points have been checked it will pop the last position from my path stack using current= path.pop inside the while loop and repeat.
Position is a custom class. I have considered adding a previous position variable to the constructor in the position class but seems to not to be needed if I can get my path stack to work. If I am wrong on this please let me know.
public static Position [] stackSearch(char [] [] maze){
//todo: your path finding algorithm here using the stack to manage search list
//your algorithm should modify maze to mark positions on the path, and also
//return array of Position objects coressponding to path, or null if no path found
ArrayDeque <Position> path = new ArrayDeque<Position>();
ArrayDeque <Position> searched = new ArrayDeque<Position>();
//creates position object
Position start = new Position(0,0,'0');
Position current;
Position north,south, east, west;
int i = 0; int j = 0;
//push (0,0) onto stack
path.push(start);
searched.push(start);
while(!path.isEmpty()){
current=path.pop();
i=current.i;
j=current.j;
if(i==maze.length-1 && j==maze.length-1 && maze[i][j]=='0'){
Position[] trail= new Position [path.size()];
while(!path.isEmpty()){
for(int k=0; k<path.size();k++){
trail[k]=path.pop();
}
return trail;
}
}
System.out.println(i +"," +j);
//check east.
east= new Position(i,j+1,'0');
south= new Position(i+1,j,'0');
west= new Position(i,j-1,'0');
north= new Position(i-1,j,'0');
if (j+1 >= 0 && j+1 < maze.length && maze[i][j+1] == '0' && searched.contains(east)==false)
{
searched.push(east);
path.push(current);
path.push(east);
}
//check south, add its position to the list.
else if (i+1 >= 0 && i+1 < maze.length && maze[i+1][j] == '0' && searched.contains(south)==false)
{
searched.push(south);
path.push(current);
path.push(south);
}
//check west.
else if (j-1 >= 0 && j-1 < maze.length && maze[i][j-1] == '0' && searched.contains(west)==false)
{
searched.push(west);
path.push(current);
path.push(west);
}
//check north
else if (i-1 >= 0 && i-1 < maze.length && maze[i-1][j] == '0' && searched.contains(north)==false)
{
searched.push(north);
path.push(current);
path.push(north);
}
}
return null;
}

I would guess that the problem lies, not in the code you posted, but rather in the Position class. If you have not overridden hashcode() and equals() in the Position class, the contains() comparison here will be looking for object equality.
So when you ask if searched.contains(east), having just created east as a new object, it will return false, even though east's coordinates perfectly match what is already in your search.
See this answer for more.

A common solution to solving a maze is BFS, which is both optimal and complete [it always find a solution if there is one, and also it finds the shortest one].
Using a stack, is actually simulating a DFS, which is not optimal.
About the specific problem, where contains() doesn't do its job, it will be hard to know what the problem is without the source for the class Position, but a possible reason is you did not override equals(), so the default equals() is still checking for identity, and not equality - which is obviously not true.