我想要的结果是4没下落之前是 start=[4_0,3_2],然后下落之后变成

Question

需求: 我想要的结果是4没下落之前是 start=[4_0,3_2],然后下落之后变成end=[5_0,5_2]，假设bonusList=[4_0_8,3_2_10],bonusList存储的是起始位置，
我希望bonusList可以变成[4_0_8,3_2_10，5_0_8,5_2_10],因为5_0是4_0的结束位置，然后拿到第三位数，我代码可以怎么改动
开始拿到的矩阵没下落前的矩阵:
2, 0, 0, 0, 0, 0
109, 131, 113, 109, 131, 109
109, 131, 113, 109, 131, 109
139, 139, 4, 139, 139, 139
4, 139, 0, 139, 127, 127
0, 139, 0, 113, 127, 127
109, 131, 113, 109, 131, 109

下落之后的矩阵:

0, 0, 0, 0, 0, 0
2, 131, 0, 109, 131, 109
109, 131, 0, 109, 131, 109
109, 139, 113, 139, 139, 139
139, 139, 113, 139, 127, 127
4, 139, 4, 113, 127, 127
109, 131, 113, 109, 131, 109
下落的方法

public int[][] fallMatrixsMAHJONG() {
    logger.info("下落之前~~~"+bonusList +"第几个矩阵·····"+matrixs.size());
    int[][] tempMatrix = new int[row][col];
    for (int i = matrix[0].length - 1; i >= 0; i--) {
        int index = row - 1;
        for (int j = matrix.length - 1; j >= 0; j--) {
                if (matrix[j][i] != 0) {
                    tempMatrix[index--][i] = matrix[j][i];
                }
        }
    }
    return tempMatrix;
}

Answer 1

以下内容由CHATGPT及阿里嘎多学长共同生成、有用望采纳：

---

根据你的需求，我们需要实现一个Java程序，用于处理麻将矩阵的下落逻辑，并更新bonusList。以下是完整的代码实现，包括下落逻辑和更新bonusList的逻辑。

首先，我们需要确保fallMatrixsMAHJONG方法正确地实现下落逻辑。然后，我们将实现updateBonusListAfterFall方法来更新bonusList。

以下是完整的Java代码实现：

import java.util.ArrayList;
import java.util.List;

public class MahjongMatrix {
    private int[][] matrix;
    private List<BonusPosition> bonusList;
    private static final int row = 7; // 假设行数为7
    private static final int col = 6; // 假设列数为6

    public MahjongMatrix(int[][] matrix) {
        this.matrix = matrix;
        this.bonusList = new ArrayList<>();
    }

    // 下落逻辑
    public int[][] fallMatrixsMAHJONG() {
        int[][] tempMatrix = new int[row][col];
        for (int i = col - 1; i >= 0; i--) {
            int index = row - 1;
            for (int j = matrix.length - 1; j >= 0; j--) {
                if (matrix[j][i] != 0) {
                    tempMatrix[index--][i] = matrix[j][i];
                } else {
                    index--;
                }
            }
        }
        return tempMatrix;
    }

    // 更新bonusList
    public void updateBonusListAfterFall() {
        int[][] fallenMatrix = fallMatrixsMAHJONG();
        List<BonusPosition> newBonusList = new ArrayList<>();

        for (int i = 0; i < fallenMatrix.length; i++) {
            for (int j = 0; j < fallenMatrix[i].length; j++) {
                if (fallenMatrix[i][j] != 0) {
                    int originalX = findOriginalX(fallenMatrix[i][j], matrix);
                    int originalY = findOriginalY(fallenMatrix[i][j], matrix, originalX);
                    int bonusValue = getBonusValue(originalX, originalY);

                    newBonusList.add(new BonusPosition(originalX, originalY, bonusValue));
                }
            }
        }

        this.bonusList = newBonusList;
    }

    // 辅助方法，用于在原始矩阵中找到特定元素的X坐标
    private int findOriginalX(int value, int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] == value) {
                    return j;
                }
            }
        }
        return -1; // 如果找不到，返回-1
    }

    // 辅助方法，用于在原始矩阵中找到特定元素的Y坐标
    private int findOriginalY(int value, int[][] matrix, int x) {
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[i][x] == value) {
                return i;
            }
        }
        return -1; // 如果找不到，返回-1
    }

    // 辅助方法，用于获取特定位置的bonus值
    private int getBonusValue(int x, int y) {
        // 假设bonus值不变，直接返回原始位置的bonus值
        return bonusList.stream()
                .filter(bp -> bp.getX() == x && bp.getY() == y)
                .mapToInt(BonusPosition::getBonusValue)
                .findFirst().orElse(-1);
    }

    // 打印矩阵
    public void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }

    // 打印bonusList
    public void printBonusList() {
        for (BonusPosition bp : bonusList) {
            System.out.println("BonusPosition: " + bp.getX() + "_" + bp.getY() + "_" + bp.getBonusValue());
        }
    }

    // 测试
    public static void main(String[] args) {
        int[][] matrix = {
            {2, 0, 0, 0, 0, 0},
            {109, 131, 113, 109, 131, 109},
            {109, 131, 113, 109, 131, 109},
            {139, 139, 4, 139, 139, 139},
            {4, 139, 0, 139, 127, 127},
            {0, 139, 0, 113, 127, 127},
            {109, 131, 113, 109, 131, 109}
        };

        MahjongMatrix mahjongMatrix = new MahjongMatrix(matrix);
        mahjongMatrix.printMatrix(mahjongMatrix.matrix);
        System.out.println("下落之前: " + mahjongMatrix.bonusList);

        mahjongMatrix.updateBonusListAfterFall();
        mahjongMatrix.printMatrix(mahjongMatrix.fallMatrixsMAHJONG());
        System.out.println("下落之后: " + mahjongMatrix.bonusList);
    }

    // BonusPosition类
    public static class BonusPosition {
        private int x;
        private int y;
        private int bonusValue;

        public BonusPosition(int x, int y, int bonusValue) {
            this.x = x;
            this.y = y;
            this.bonusValue = bonusValue;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

        public int getBonusValue() {
            return bonusValue;
        }

        @Override
        public String toString() {
            return x + "_" + y + "_" + bonusValue;
        }
    }
}

解释

1. 下落逻辑：fallMatrixsMAHJONG方法将矩阵中的非零元素向下移动，填充上面的空位。这里使用了两层循环，外层循环遍历每一列，内层循环从底部开始向上移动元素。

2. 更新bonusList：updateBonusListAfterFall方法首先调用fallMatrixsMAHJONG获取下落后的矩阵，然后遍历下落后的矩阵，找到所有非零元素的新位置。对于每个非零元素，使用findOriginalX和findOriginalY方法找到其在原始矩阵中的位置，并使用getBonusValue方法获取其bonus值，最后将新的BonusPosition添加到bonusList中。

3. 辅助方法：findOriginalX、findOriginalY和getBonusValue方法分别用于在原始矩阵中找到特定元素的X坐标、Y坐标和bonus值。

4. 测试：在main方法中，我们创建了一个MahjongMatrix实例，并使用示例矩阵进行测试。首先打印原始矩阵和bonusList，然后调用updateBonusListAfterFall方法更新bonusList，并打印下落后的矩阵和更新后的bonusList。

希望这能帮助你实现所需的功能！