import java.io.*;
import java.util.*;
import java.util.stream.IntStream;

//https://www.geeksforgeeks.org/intstream-range-java/

/* In this problem, we want to check if our self driving car can navigate through a particular path through the city.

A city grid will be  provided as a list of strings, where each character in the string represents a cell. Characters can be ‘X’, which represents an obstacle, ‘.’  which represents an allowed location, and ‘P’ for the starting position of the car. There are no empty starting cells. Assume the grid is valid.

Here is an example input:
[
"XXXXXXXX",
"X......X",
"X.XXXX.X",
"XP.....X",
"XXXXXXXX",
]

A list of commands will be provided, where each command is encoded in a string. The first character of the string will be one of U,D,L, or R, representing up, down, left or right. A space will follow, followed by a number representing the number of cells to move in that direction.

For example:
[
"R 5",
"U 2",
"L 5",
"D 1",
]

Please implement a solution that receives a city grid and list of commands and returns True if at the end all dots in the city grid are consumed or False otherwise.

For example, with the grid and commands mentioned above, your solution should return True since the car would traverse all the dots.

If the car would hit an obstacle or go outside the grid, your solution should eagerly return False.

The resulting code should be algorithmically correct and work with all possible edge cases. Code must compile. Looking up documentation during the interview is allowed.

*/


/*
 * To execute Java, please define "static void main" on a class
 * named Solution.
 *
 * If you need more classes, simply define them inline.
 */

class Solution {

  public static void main(String[] args) {
    String[] testGrid = new String [] {
                  "XXXXXXXX",
                  "X......X",
                  "X.XXXX.X",
                  "XP.....X",
                  "XXXXXXXX"
    };
    String[] commands = new String [] {
      "R 5",
      "U 2",
      "L 5",
      "D 1",
    };

    System.out.println(findPath(testGrid, commands));
  }

  public static boolean findPath(String[] input, String[] commands) {

    int dimX, dimY;
    dimX = input[0].length();
    dimY = input.length;

    char[][] grid = new char[input.length][input[0].length()];

    int startX = 0, startY = 0;

    for (int i = 0; i < grid.length; i++) {
      for (int j = 0; j < grid[i].length; j++) {
        if (grid[i][j] == 'P') {
          startY = i;
          startX = j;
        }
      }
    }

    for (String command : commands) {
      char dir = command.split(" ")[0].toCharArray()[0];
      int dist = Character.getNumericValue(command.split(" ")[1].toCharArray()[0]);

      // starting from startX, startY, traverse dist chars in direction, checking that each spot is traversible (. or '-')
      int[] operation = new int[2];

      switch (dir) {
        case 'R': {
          operation = new int[] { startX + dist, startY };
          break;
        }
        case 'L': {
          operation = new int[] { startX - dist, startY };
          break;
        }
        case 'U': {
          operation = new int[] { startX, startY + dist };
          break;
        }
        case 'D': {
          operation = new int[] { startX, startY - dist };
          break;
        }
      }

      System.out.println(String.format("Command: %s, operation: %d, %d", dir, operation[0], operation[1]));

      // check if we're out of bounds
      if (operation[1] >= dimY || operation[1] < 0 || operation[0] >= dimX || operation[0] < 0) {
        System.out.println("Out of bounds");
        return false;
      }

      // check if the path taken traverses any obstacles, and set '.' to '-'
      int[] range = IntStream.range(startX, operation[0]).toArray();
      for (int i : range) {
        if (grid[startY][i] != '.' || grid[startY][i] != '-' || grid[startY][i] != 'P') {
          System.out.println(String.format("grid %d %d is not . or -", startY, i));
          return false;
        } else {
          grid[startY][i] = '-';
        }
      }

      range = IntStream.range(startY, operation[1]).toArray();
      for (int i : range) {
        if (grid[i][startX] != '.' || grid[i][startX] != '-' || grid[i][startX] != 'P') {
          return false;
        } else {
          grid[i][startX] = '-';
        }
      }

      // check to make sure there are no dots left that were untraversed

      for (int i = 0; i < dimY; i++) {
        for (int j = 0; j < dimX; j++) {
          if (i == '.') {
            return false;
          }
        }
      }
    }
      return true;
  }
}



/*
Your previous C++ content is preserved below:

Hello Michael.
 */