# How to find the next position in a 2D array based on the current position? [closed]

Suppose I have an array with 3 rows and 4 columns `const arr = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]` and I give an input like `["straight", "right", "left"]` and the initial position is `arr[0][0]` and the initial direction is `"east"`.

```[
[1,  2,  3,  4],
[5,  6,  7,  8],
[9, 10, 11, 12]
]
```

From initial position going `"straight"` should give `2`. And then from here going `"right"` should give `6` and finally a `"left"` from here should give `7`.

How can I achieve this in JavaScript?

• Create a map that gives the next direction based on the current direction and move.
• Now for every move calculate the next direction and check if it’s a valid move, if it is then return the next value, position & direction and repeat this for every move.
• If the move is invalid at any point this solution throws an error, you can customize the error handling according to your needs.

```const nextDirMap = {
north: { left: "west", right: "east", straight: "north" },
south: { left: "east", right: "west", straight: "south" },
east: { left: "north", right: "south", straight: "east" },
west: { left: "south", right: "north", straight: "west" },
};

function getNextPos(grid, currPos, currDir, move) {
const nextDir = nextDirMap[currDir][move];
const [r, c] = currPos;
const maxRowLength = grid.length;
const maxColLength = grid[0].length;

switch (nextDir) {
case "north": {
if (r <= 0) {
throw "Unable to move";
}
return { val: grid[r - 1][c], pos: [r - 1, c], dir: "north" };
}
case "south": {
if (r >= maxRowLength) {
throw "Unable to move";
}
return { val: grid[r + 1][c], pos: [r + 1, c], dir: "south" };
}
case "east": {
if (c >= maxColLength) {
throw "Unable to move";
}
return { val: grid[r][c + 1], pos: [r, c + 1], dir: "east" };
}
case "west": {
if (c <= 0) {
throw "Unable to move";
}
return { val: grid[r][c - 1], pos: [r, c - 1], dir: "west" };
}
}
}

function solution(grid, initPos, initDir, moves) {
let currPos = initPos;
let currDir = initDir;
let currVal;
moves.forEach((move) => {
let { val, pos, dir } = getNextPos(grid, currPos, currDir, move);
currDir = dir;
currPos = pos;
currVal = val;
});
return currVal;
}

const res = solution(
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
],
[0, 0],
"east",
["straight", "right", "left"]
);

console.log(res); // 7```

Note the solution assumes that you’ve a valid grid (same no. of columns for all rows) and it has at least one row.