用java创建一个100的数组并将其填满

可以使用以下代码创建一个长度为100的int数组，并将其填满：

int[] arr = new int[100]; // 创建长度为100的int数组

for (int i = 0; i < arr.length; i++) { // 填充数组
    arr[i] = i + 1;
}

这个数组中的每个元素都是从1开始递增的数字，因为在循环中我们将每个元素的值设置为其下标加1。如果你需要不同的数值，可以根据需要修改循环中的赋值语句。

相关问题

用java创建一个100的数组并用random函数将其填满

以下是用Java创建一个100的数组并用random函数将其填满的代码：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[100];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println("数组内容为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：

数组内容为：
61 95 60 51 76 68 83 69 4 72 29 77 9 66 68 42 64 53 46 48 13 48 55 25 96 65 76 70 54 3 53 67 85 61 1 98 83 51 23 5 67 34 5 53 98 99 90 60 59 94 65 78 35 50 31 2 53 70 67 69 78 99 9 94 65 43 20 42 31 18 69 65 94 4 4 83 13 76 9 40 98 67 34 2 54 3 39 73 20 88 31 73 85 83 77 70 10 6 44 92 27 74 76 55 

用java写一个数独游戏并生成唯一答案，由人填入数字，检查对错

好的，下面是一个简单的数独游戏的实现，使用 Backtracking 算法生成唯一答案，并且支持填入数字和检查对错。

import java.util.Arrays;

public class Sudoku {
    private static final int SIZE = 9;
    private static final int EMPTY = 0;
    private int[][] board;

    public Sudoku() {
        board = new int[SIZE][SIZE];
    }

    public void setBoard(int[][] board) {
        this.board = board;
    }

    public int[][] getBoard() {
        return board;
    }

    public void solve() {
        solve(0, 0);
    }

    private boolean solve(int row, int col) {
        if (row == SIZE) {
            row = 0;
            if (++col == SIZE) {
                return true;
            }
        }

        if (board[row][col] != EMPTY) {
            return solve(row + 1, col);
        }

        for (int val = 1; val <= SIZE; ++val) {
            if (isValid(row, col, val)) {
                board[row][col] = val;
                if (solve(row + 1, col)) {
                    return true;
                }
            }
        }

        board[row][col] = EMPTY;
        return false;
    }

    private boolean isValid(int row, int col, int val) {
        for (int i = 0; i < SIZE; ++i) {
            if (board[row][i] == val || board[i][col] == val) {
                return false;
            }
        }

        int boxRow = row - row % 3;
        int boxCol = col - col % 3;
        for (int i = boxRow; i < boxRow + 3; ++i) {
            for (int j = boxCol; j < boxCol + 3; ++j) {
                if (board[i][j] == val) {
                    return false;
                }
            }
        }

        return true;
    }

    public boolean isComplete() {
        for (int i = 0; i < SIZE; ++i) {
            for (int j = 0; j < SIZE; ++j) {
                if (board[i][j] == EMPTY) {
                    return false;
                }
            }
        }
        return true;
    }

    public boolean checkSolution() {
        if (!isComplete()) {
            return false;
        }

        for (int i = 0; i < SIZE; ++i) {
            boolean[] rowCheck = new boolean[SIZE];
            boolean[] colCheck = new boolean[SIZE];
            boolean[] boxCheck = new boolean[SIZE];

            for (int j = 0; j < SIZE; ++j) {
                int rowVal = board[i][j] - 1;
                int colVal = board[j][i] - 1;
                int boxVal = board[3 * (i / 3) + j / 3][3 * (i % 3) + j % 3] - 1;

                if (rowCheck[rowVal] || colCheck[colVal] || boxCheck[boxVal]) {
                    return false;
                }

                rowCheck[rowVal] = true;
                colCheck[colVal] = true;
                boxCheck[boxVal] = true;
            }
        }

        return true;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < SIZE; ++i) {
            if (i % 3 == 0) {
                sb.append(" -----------------------\n");
            }
            for (int j = 0; j < SIZE; ++j) {
                if (j % 3 == 0) {
                    sb.append("| ");
                }
                sb.append(board[i][j] == EMPTY ? "  " : board[i][j] + " ");
            }
            sb.append("|\n");
        }
        sb.append(" -----------------------\n");
        return sb.toString();
    }

    public static void main(String[] args) {
        Sudoku sudoku = new Sudoku();
        sudoku.solve();
        System.out.println(sudoku);

        // remove some numbers from the solution to create the game
        int[][] game = Arrays.copyOf(sudoku.getBoard(), SIZE);
        int numToRemove = (int) (0.5 * SIZE * SIZE);
        int numRemoved = 0;
        while (numRemoved < numToRemove) {
            int row = (int) (Math.random() * SIZE);
            int col = (int) (Math.random() * SIZE);
            if (game[row][col] != EMPTY) {
                game[row][col] = EMPTY;
                ++numRemoved;
            }
        }

        sudoku.setBoard(game);
        System.out.println(sudoku);

        // check if the game is solved correctly
        sudoku.solve();
        System.out.println(sudoku.checkSolution() ? "Correct solution!" : "Incorrect solution!");
    }
}

这个程序的主要思路是使用 Backtracking 算法生成唯一答案，然后随机删除一些数字来创建游戏。最后，检查玩家填入的数字是否正确，如果正确则显示“Correct solution!”，否则显示“Incorrect solution!”。

在 `solve()` 方法中，我们首先检查是否已经填满了整个数独板，如果是，返回true。否则，我们从左上角开始，依次填入数字，如果遇到一个已经填好的数字，则跳过它，继续搜索下一个数字。如果在当前位置填入某个数字后，导致后面无法生成唯一答案，则回溯并尝试下一个数字。

在 `isValid()` 方法中，我们检查当前位置是否可以填入给定的值。我们首先检查当前行和列是否已经有了这个值，如果有，则返回 false。然后，我们检查当前位置所在的 3x3 小正方形是否已经有了这个值。如果有，则返回 false。否则，返回 true。

在 `checkSolution()` 方法中，我们检查玩家填入的数字是否符合数独游戏的要求，即每行、每列和每个 3x3 小正方形都没有重复数字。我们使用三个布尔数组 `rowCheck`、`colCheck` 和 `boxCheck`，来分别记录当前行、当前列和当前 3x3 小正方形中出现过的数字，如果出现重复，则返回 false。

在主方法中，我们首先生成唯一答案，然后随机删除一些数字来创建游戏。最后，检查玩家填入的数字是否正确，如果正确则显示“Correct solution!”，否则显示“Incorrect solution!”。