遥控小车

问题背景

我们需要模拟一个遥控小车在二维平面直角坐标系中的移动。小车从一个固定的初始状态出发，根据一串指令序列来更新自己的位置和朝向。

坐标系定义

Y轴正方向: 北方 (North)
Y轴负方向: 南方 (South)
X轴正方向: 东方 (East)
X轴负方向: 西方 (West)

初始状态

位置 : 坐标原点 (0, 0)。
朝向 : 面朝北方。

指令集

遥控小车只接受以下三种指令：

'G' : Go - 沿着当前朝向，向前直走 1 个单位。
'L' : Left - 原地向左转 90 度（逆时针旋转）。
'R' : Right - 原地向右转 90 度（顺时针旋转）。

任务要求

给定一个由上述指令组成的字符串 cmds，请计算小车在依次执行完所有指令后，最终所处的 (x, y) 坐标。

输入格式

cmds: 一个字符串，代表指令序列。
- 字符串仅由大写字符 'G', 'L', 'R' 组成。
- 1 <= cmds.length <= 100

输出格式

一个包含两个整数的数组或列表 [x, y]，表示小车最终的位置坐标。
保证 : 整个移动过程中，坐标 x 和 y 的值都不会超出32位有符号整数的范围。

样例说明

样例 1

输入 : "GG"
输出 : [0, 2]
解释:
1. 初始状态 : 位置 (0, 0)，朝向北。
2. 执行第一个 'G' : 沿着北方前进1个单位。
  - 新位置: (0, 1)。
  - 朝向不变，仍为北。
3. 执行第二个 'G' : 再次沿着北方前进1个单位。
  - 新位置: (0, 2)。
  - 朝向不变，仍为北。
4. 指令结束 : 最终位置为 (0, 2)。

样例 2 (示例)

输入 : "GLR"
输出 : [-1, 1]
解释:
1. 初始状态 : 位置 (0, 0)，朝向北。
2. 执行 'G' : 沿北前进1个单位。
  - 位置: (0, 1)，朝向: 北。
3. 执行 'L' : 原地左转90度。
  - 位置: (0, 1)，朝向: 从北左转变为西。
4. 执行 'R' : 原地右转90度。
  - 位置: (0, 1)，朝向: 从西右转变回北。
5. 指令结束 : 最终位置为 (0, 1)。 (修正：为了更好地展示，让我们用 "GLG" 作为例子)

样例 3 (更完整的例子)

输入 : "GLG"
输出 : [-1, 1]
解释:
1. 初始状态 : 位置 (0, 0)，朝向北。
2. 执行第一个 'G' : 沿北前进1个单位。
  - 位置: (0, 1)，朝向: 北。
3. 执行 'L' : 原地左转90度。
  - 位置: (0, 1)，朝向: 从北左转变为西。
4. 执行第二个 'G' : 沿着当前朝向（西）前进1个单位。
  - 新位置 x 坐标减 1: (0-1, 1) = (-1, 1)。
  - 朝向不变，仍为西。
5. 指令结束 : 最终位置为 (-1, 1)。

java 复制代码

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    /**
     * 计算遥控小车在执行一系列指令后的最终位置。
     *
     * @param cmds 由 'G', 'L', 'R' 组成的指令字符串。
     * @return 一个包含最终 x 和 y 坐标的长度为 2 的整数数组。
     */
    public static int[] calculateFinalPosition(String cmds) {
        // --- 1. 初始化状态 ---

        // 小车的当前位置 (x, y)，初始为原点
        int x = 0;
        int y = 0;

        // 使用一个整数表示小车的方向。
        // 0: 北 (Y轴正方向), 1: 东 (X轴正方向), 2: 南 (Y轴负方向), 3: 西 (X轴负方向)
        // 初始方向为北方
        int dirIndex = 0;

        // 使用方向向量数组来简化移动计算。
        // directions[i] 对应方向 i 的 [dx, dy] 坐标变化量。
        //         北: {0, 1}, 东: {1, 0}, 南: {0, -1}, 西: {-1, 0}
        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

        // --- 2. 遍历并执行每一条指令 ---
        for (char cmd : cmds.toCharArray()) {
            if (cmd == 'G') {
                // 'G': 直走 - 根据当前方向更新坐标
                // 获取当前方向对应的 x 和 y 的变化量
                int dx = directions[dirIndex][0];
                int dy = directions[dirIndex][1];
                // 更新坐标
                x += dx;
                y += dy;
            } else if (cmd == 'L') {
                // 'L': 左转 90 度。
                // 方向变化顺序：北(0) -> 西(3) -> 南(2) -> 东(1) -> 北(0)
                // 这是一个循环递减。使用 (dirIndex - 1 + 4) % 4 的技巧可以优雅地处理从 0 到 3 的回绕。
                dirIndex = (dirIndex - 1 + 4) % 4;
            } else if (cmd == 'R') {
                // 'R': 右转 90 度。
                // 方向变化顺序：北(0) -> 东(1) -> 南(2) -> 西(3) -> 北(0)
                // 这是一个循环递增。
                dirIndex = (dirIndex + 1) % 4;
            }
            // 根据题目描述，输入仅含 G, L, R，所以无需处理其他字符。
        }

        // --- 3. 返回最终结果 ---
        // 将最终的 x, y 坐标放入一个新数组中返回
        return new int[]{x, y};
    }

    // --- 主函数处理 ACM 输入输出 ---
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取指令字符串
        String cmds = scanner.nextLine();
        scanner.close();

        // 调用核心逻辑计算最终位置
        int[] finalPosition = calculateFinalPosition(cmds);

        // 按题目要求的格式 "[x, y]" 输出
        // Arrays.toString() 会自动生成这个格式
        System.out.println(Arrays.toString(finalPosition));
    }
}