Alphabet Board Path Problem in Java

We are provided with an alphabet board that consists all the letters of English language from A to Z as shown in the below mentioned diagram.

On the above-mentioned alphabet board, we start at the position (0,0) and we can take only the below-mentioned moves:

'U' indicates that your position moves up by one row, only if it exists on the board.
'D' indicates that your position moves down by one row, only if it exists on the board.
'L' indicates that your position moves left by one column, only if it exists on the board.
'R' indicates that your position moves right by one column, only if it exists on the board.
'!' indicates that the character board[row][column] will be added at the current positon (row, column) of the answer.

Solution to the Problem

Obtain all letters' positions. For each pair of adjacent letters, obtain the path by the difference between the two positions' rows and the difference between the two positions' columns. When each letter is to be typed, add the path from the previous position to the current position to the sequence, and add '!' to the sequence.

If the current letter or the previous letter is z, then the path needs to be obtained differently. Since z is only letter in the last row, it is impossible to move left in the last row to reach z, and it is also impossible to move right in the last row from z. Therefore, to move to z, first move left to the leftmost column then move down. To move from z, first move up then move right (if the next letter is not in the leftmost column).

Finally, return the sequence.

Example 1:

Input: "English"

Output: DDDDD!UUURRR!ULL!D!URR!DD!UUL!

Example 2:

Input: "Alphabets"

Output: DDDDD!UUUR!DL!UURR!ULL!R!RRR!DDD!L!

Filename: AlphabetBoardPath.java

public class AlphabetBoardPath {
    public static void main(String[] args) {
        AlphabetBoardPath obj = new AlphabetBoardPath();
        String ans = obj.alphabetBoardPath("Alphabets");
        System.out.println(ans);
    }
    public String alphabetBoardPath(String target) {
        char[] arr = target.toCharArray();
        StringBuilder Stringbuilder = new StringBuilder();
        char[][] mainBoard = new char[][] { { 'a', 'b', 'c', 'd', 'e' }, { 'f', 'g', 'h', 'i', 'j' },
                { 'k', 'l', 'm', 'n', 'o' }, { 'p', 'q', 'r', 's', 't' },
                { 'u', 'v', 'w', 'x', 'y' }, { 'z' } };
        int pre_row = 0, pre_column = 0, Row = 0, Column = 0;
        for (char c : arr) {
            Row = getRowValue(c);
            Column = getColumnValue(c, Row);
            Stringbuilder.append(findPathValue(c, mainBoard, pre_row, pre_column, Row, Column));
            pre_row = Row;
            pre_column = Column;
        }
        return Stringbuilder.toString();
    }
    public int getRowValue(char c) {
        if (c >= 'a' && c <= 'e') {
            return 0;
        } else if (c >= 'f' && c <= 'j') {
            return 1;
        } else if (c >= 'k' && c <= 'o') {
            return 2;
        } else if (c >= 'p' && c <= 't') {
            return 3;
        } else if (c >= 'u' && c <= 'y') {
            return 4;
        } else {
            return 5;
        }
    }
    public int getColumnValue(char c, int Row) {
        if (Row == 0) {
            return c - 'a';
        } else if (Row == 1) {
            return c - 'f';
        } else if (Row == 2) {
            return c - 'k';
        } else if (Row == 3) {
            return c - 'p';
        } else if (Row == 4) {
            return c - 'u';
        } else {
            return 0;
        }
    }
    public String findPathValue(char c, char[][] mainBoard, int srow, int scolumn, int drow, int dcolumn) {
        String ans = "";
        boolean checkZ = false;
        if (drow != srow) {
            if (drow == 5) {
                checkZ = true;
                drow--;
            }
            if (drow > srow) {
                while (drow > srow) {
                    ans = ans + "D";
                    srow++;
                }
            } else {
                while (drow < srow) {
                    ans = ans + "U";
                    drow++;
                }
            }
        }
        if (dcolumn > scolumn) {
            while (dcolumn > scolumn) {
                ans = ans + "R";
                scolumn++;
            }
        } else {
            while (dcolumn < scolumn) {
                ans = ans + "L";
                dcolumn++;
            }
        }
        if (checkZ) {
            ans = ans + "D";
        }
        ans = ans + "!";
        return ans;
    }
}

Output: