Problem:
Where's Your Robot?

You have full control over a robot that walks around in a rectangular
field paved with square tiles like a chessboard. There are m
columns of tiles from west to east, and n rows of tiles from
south to north (1 <= m, n <= 100). Each tile is given a pair
of coordinates, such as (i, j), where 1 <= i <= m
and 1 <= j <= n.

Your robot is initially on the center of the tile at (1, 1), that is,
one at the southwest corner of the field, facing straight north. It
can move either forward or backward, or can change its facing
direction by ninety degrees at a time, according to a command you give
to it, which is one of the following.

FORWARD k

Go forward by k tiles to its facing direction (1 <= k < 100).

BACKWARD k

Go backward by k tiles, without changing its facing direction
(1 <= k < 100).

RIGHT

Turn to the right by ninety degrees.

LEFT

Turn to the left by ninety degrees.

STOP

Stop.

While executing either a "FORWARD" or a
"BACKWARD" command, the robot may bump against the
wall surrounding the field. If that happens, the robot gives up the
command execution there and stands at the center of the tile right in
front of the wall, without changing its direction.

After finishing or giving up execution of a given command, your robot
will stand by for your next command.

Input

The input consists of one or more command sequences. Each input line
has at most fifty characters.

The first line of a command sequence contains two integer numbers
telling the size of the field, the first number being the number of
columns and the second being the number of rows. There might be white
spaces (blanks and/or tabs) before, in between, or after the two numbers.
Two zeros as field size indicates the end of input.

Each of the following lines of a command sequence contains a command
to the robot. When a command has an argument, one or more white
spaces are put between them. White spaces may also appear before and
after the command and/or its argument.

A command sequence is terminated by a line containing a
"STOP" command. The next command sequence, if any,
starts from the next line.

Output

The output should be one line for each command sequence in the input.
It should contain two numbers i and j of the coordinate pair
(i, j), in this order, of the tile on which your robot stops.
Two numbers should be separated by one white spaces.

Sample Input

6 5
FORWARD 3
RIGHT
FORWARD 5
LEFT
BACKWARD 2
STOP
3 1
FORWARD 2
STOP
0 0

Output for the Sample Input

6 2
1 1

Solution in JAVA (judge verdict: Wrong Answer)

import java.io.*;
import java.util.*;


public class Main {
	public static void main(String[] args) {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));       
		try {
			String line;
			while(true){
				/* input */
				line = br.readLine();
				int c = Integer.parseInt(line.split("[ \t]")[0]), r = Integer.parseInt(line.split("[ \t]")[1]);
				if(c==0&&r==0){
					return;
				}
				int[] robot = new int[3];
				
				//first and second index indicates the current position
				robot[0] = 1;
				robot[1] = 1;
				//third index shows direction: 0:north, 1:east, 2:south, 3:west
				robot[2] = 0;
				/* commands */
				while(true){
					line = br.readLine();
					if(line.indexOf("STOP") > -1){
						break;
					} else if(line.indexOf("RIGHT") > -1){
						robot[2] = (robot[2] + 1) % 4; 
					} else if(line.indexOf("LEFT") > -1){
						robot[2] = (robot[2] + 3) % 4; 
					} else {
						String com = line.split(" ")[0];
						int n = Integer.parseInt(line.split("[ \t]")[1]);
						if(com.indexOf("FORWARD") > -1){
							switch(robot[2]){
							case 0:
								robot[1] += n;
								if(robot[1] > r) robot[1] = r;
								break;
							case 1:
								robot[0] += n;
								if(robot[0] > c) robot[0] = c;
								break;
							case 2:
								robot[1] -= n;
								if(robot[1] < 0) robot[1] = 0;
								break;
							case 3:
								robot[0] -= n;
								if(robot[0] < 0) robot[0] = 0;
								break;
							}
						}
						if(com.indexOf("BACKWARD") > -1){
							switch(robot[2]){
							case 0:
								robot[1] -= n;
								if(robot[1] < r) robot[1] = r;
								break;
							case 1:
								robot[0] -= n;
								if(robot[0] < c) robot[0] = c;
								break;
							case 2:
								robot[1] += n;
								if(robot[1] > 0) robot[1] = 0;
								break;
							case 3:
								robot[0] += n;
								if(robot[0] > 0) robot[0] = 0;
								break;
							}
						}
					}
				}
				
				
				/* output */
				System.out.println(robot[0] + " " + robot[1]);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}