生成随机矩阵并控制元素重复次数的教程

import java.util.Arrays;
import java.util.Random;

public class RandomMatrixProblem {
    public static void main(String[] args) {
        int[][] mat = new int[4][4];
        Random r = new Random();

        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                // 这种方法无法控制数字的出现次数
                mat[i][j] = r.nextInt(8) + 1; // 假设范围是1-8
            }
        }

        for(int i=0; i<4; i++){
            System.out.println(Arrays.toString(mat[i]));
        }
    }
}

import java.util.Random;

public class ArrayShuffler {
    /**
     * 使用Fisher-Yates算法随机打乱一个整数数组。
     * @param data 待打乱的整数数组。
     * @return 打乱后的数组。
     */
    public static int[] randomizeArray(int[] data) {
        Random r = new Random();
        for (int i = data.length - 1; i > 0; i--) { // 从最后一个元素向前遍历
            int randomIndexSwap = r.nextInt(i + 1); // 生成一个0到i（包括i）之间的随机索引
            // 交换当前元素与随机索引处的元素
            int temp = data[randomIndexSwap];
            data[randomIndexSwap] = data[i];
            data[i] = temp;
        }
        return data;
    }
}

import java.util.Arrays;
import java.util.Random;

public class RandomMatrixGenerator {

    /**
     * 使用Fisher-Yates算法随机打乱一个整数数组。
     * @param data 待打乱的整数数组。
     * @return 打乱后的数组。
     */
    public static int[] randomizeArray(int[] data) {
        Random r = new Random();
        for (int i = data.length - 1; i > 0; i--) {
            int randomIndexSwap = r.nextInt(i + 1);
            int temp = data[randomIndexSwap];
            data[randomIndexSwap] = data[i];
            data[i] = temp;
        }
        return data;
    }

    public static void main(String[] args) {
        int[][] mat = new int[4][4];
        // 初始数据数组，包含1到8的唯一数字
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8};

        // 第一次打乱数组，用于填充矩阵的前两行
        data = randomizeArray(data);

        for (int i = 0; i < 4; i++) {
            // 当i达到2时（即开始填充第三行之前），再次打乱数组
            if (i == 2) {
                data = randomizeArray(data); // 第二次打乱数组，用于填充矩阵的后两行
            }
            for (int j = 0; j < 4; j++) {
                // 根据行索引i和列索引j计算data数组中的对应位置
                // (i % 2) * 4:
                //   - 当 i = 0 或 2 时, i % 2 = 0, (i % 2) * 4 = 0
                //   - 当 i = 1 或 3 时, i % 2 = 1, (i % 2) * 4 = 4
                // 这样，对于每两行，我们使用data数组中的前8个元素
                // (0-3索引用于第一行/第三行，4-7索引用于第二行/第四行)
                mat[i][j] = data[(i % 2) * 4 + j];
            }
        }

        // 打印生成的矩阵
        for (int i = 0; i < 4; i++) {
            System.out.println(Arrays.toString(mat[i]));
        }
    }
}

import java.util.Arrays;
import java.util.Random;

public class GenericRandomMatrixGenerator {

    public static int[] randomizeArray(int[] data) {
        Random r = new Random();
        for (int i = data.length - 1; i > 0; i--) {
            int randomIndexSwap = r.nextInt(i + 1);
            int temp = data[randomIndexSwap];
            data[randomIndexSwap] = data[i];
            data[i] = temp;
        }
        return data;
    }

    public static int[][] generateMatrix(int rows, int cols, int minVal, int maxVal, int occurrences) {
        int totalElements = rows * cols;
        int numUnique = maxVal - minVal + 1;

        if (totalElements % numUnique != 0 || totalElements / numUnique != occurrences) {
            throw new IllegalArgumentException("无法满足所有数字出现指定次数的条件。请检查矩阵大小、数字范围和出现次数。");
        }

        // 构建完整的元素池
        int[] elementPool = new int[totalElements];
        int poolIndex = 0;
        for (int val = minVal; val <= maxVal; val++) {
            for (int k = 0; k < occurrences; k++) {
                elementPool[poolIndex++] = val;
            }
        }

        // 洗牌元素池
        elementPool = randomizeArray(elementPool);

        // 填充矩阵
        int[][] matrix = new int[rows][cols];
        int currentPoolIndex = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = elementPool[currentPoolIndex++];
            }
        }
        return matrix;
    }

    public static void main(String[] args) {
        // 生成一个4x4矩阵，元素1-8，每个出现2次
        int[][] myMatrix = generateMatrix(4, 4, 1, 8, 2);

        for (int i = 0; i < myMatrix.length; i++) {
            System.out.println(Arrays.toString(myMatrix[i]));
        }

        // 示例：生成一个3x3矩阵，元素1-3，每个出现3次
        // int[][] anotherMatrix = generateMatrix(3, 3, 1, 3, 3);
        // System.out.println("\nAnother Matrix (3x3, 1-3, each 3 times):");
        // for (int i = 0; i < anotherMatrix.length; i++) {
        //     System.out.println(Arrays.toString(anotherMatrix[i]));
        // }
    }
}