2048游戏核心算法：实现高效且无误的方块移动与合并

0   0   2   0
0   0   2   2
0   2   4   8
2   32  4   2

package main

import "fmt"

const (
    height = 4
    width  = 4
)

// Board 类型定义，方便操作
type Board [][]int

// slideAndMerge 负责处理单个行或列的滑动与合并
// 它将所有非零数字推到切片的前端，并合并相邻的相同数字。
// 合并只发生一次，通过 mergedFlags 避免重复合并。
func slideAndMerge(line []int) []int {
    // 1. 移除所有0，只保留有效数字
    filteredLine := make([]int, 0, len(line))
    for _, val := range line {
        if val != 0 {
            filteredLine = append(filteredLine, val)
        }
    }

    // 2. 合并相邻的相同数字，使用 mergedFlags 防止重复合并
    mergedResult := make([]int, 0, len(filteredLine))
    // mergedFlags 标记 filteredLine 中对应索引的数字是否已被合并
    // 例如，如果 filteredLine[i] 和 filteredLine[i+1] 合并，
    // 那么 filteredLine[i+1] 的值实际上已被“消耗”，不应再参与其他合并。
    // 这里我们用一个布尔数组来模拟，当 filteredLine[i+1] 参与合并后，
    // 标记 mergedFlags[i+1] 为 true，这样在后续迭代中就会跳过它。
    mergedFlags := make([]bool, len(filteredLine)) 

    for i := 0; i < len(filteredLine); i++ {
        if mergedFlags[i] { // 如果当前数字已经被标记为已合并，则跳过
            continue
        }

        // 尝试与下一个数字合并
        if i+1 < len(filteredLine) && filteredLine[i] == filteredLine[i+1] {
            mergedResult = append(mergedResult, filteredLine[i]*2)
            mergedFlags[i+1] = true // 标记下一个数字已参与合并
            // 注意：这里 i 不再手动递增，因为外层 for 循环会自动递增 i
            // 下一次循环时，如果 i+1 已经跳过，那么 mergedFlags[i+1] 就会生效
        } else {
            // 如果不能合并，或者已经合并过，则直接添加当前数字
            mergedResult = append(mergedResult, filteredLine[i])
        }
    }

    // 3. 填充0至原始长度
    result := make([]int, len(line))
    copy(result, mergedResult) // 将合并后的结果复制到新切片
    return result
}

// processCommand 根据输入方向处理棋盘的移动和合并
// 返回新的棋盘状态和是否有变化
func processCommand(board Board, input string) (Board, bool) {
    // 确保对棋盘进行深拷贝，避免直接修改原棋盘导致意外副作用
    newBoard := make(Board, height)
    for r := range newBoard {
        newBoard[r] = make([]int, width)
        copy(newBoard[r], board[r])
    }

    changed := false // 标记棋盘是否有变化

    switch input {
    case "u": // 向上移动：从上到下处理每一列
        for j := 0; j < width; j++ { // 遍历每一列
            column := make([]int, height)
            for i := 0; i < height; i++ {
                column[i] = newBoard[i][j]
            }
            // 向上移动，直接对列进行 slideAndMerge
            processedColumn := slideAndMerge(column)

            for i := 0; i < height; i++ {
                if newBoard[i][j] != processedColumn[i] {
                    changed = true
                }
                newBoard[i][j] = processedColumn[i]
            }
        }
    case "d": // 向下移动：从下到上处理每一列（逻辑上，需要反转）
        for j := 0; j < width; j++ { // 遍历每一列
            column := make([]int, height)
            for i := 0; i < height; i++ {
                column[i] = newBoard[i][j]
            }
            // 向下移动，需要将列反转，处理后再反转回来
            reversedColumn := make([]int, height)
            for i, val := range column {
                reversedColumn[height-1-i] = val
            }
            processedReversedColumn := slideAndMerge(reversedColumn)

            // 恢复顺序并更新棋盘
            for i := 0; i < height; i++ {
                if newBoard[i][j] != processedReversedColumn[height-1-i]