用c语言写一个生成5+2个随机数的代码

可以使用C语言中的rand()函数来生成随机数，具体代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
int i, num1, num2;
srand(time(NULL)); // 初始化随机数种子

for (i = ; i < 5; i++)
{
num1 = rand(); // 生成第一个随机数
num2 = rand(); // 生成第二个随机数
printf("随机数%d: %d, %d\n", i+1, num1, num2);
}

return ;
}

相关问题

用C语言写一个迷宫，生成代码

### 回答1：
我可以回答这个问题。生成迷宫的代码可以使用递归回溯算法，具体实现可以参考以下步骤：

1. 定义迷宫的大小和墙的状态，可以使用二维数组表示。
2. 随机选择一个起点，将其标记为已访问。
3. 随机选择一个相邻的未访问的格子，将其标记为已访问，并将两个格子之间的墙打通。
4. 重复步骤3，直到所有的格子都被访问过。
5. 最后将起点和终点确定下来，可以使用随机数生成。

以上是一个简单的生成迷宫的算法，可以根据实际需求进行修改和优化。

### 回答2：
生成迷宫的C语言代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define WIDTH 10   // 迷宫的宽度
#define HEIGHT 10  // 迷宫的高度

typedef struct {
    int x;
    int y;
} Position;

void generateMaze(int maze[WIDTH][HEIGHT]) {
    srand((unsigned) time(0));
    
    // 初始化迷宫
    for (int i = 0; i < WIDTH; i++) {
        for (int j = 0; j < HEIGHT; j++) {
            maze[i][j] = 1;
        }
    }
    
    Position stack[WIDTH * HEIGHT];  // 使用栈来辅助生成迷宫
    int top = 1;
    
    Position current = {1, 1};  // 当前位置
    maze[current.x][current.y] = 0;
    stack[top] = current;
    
    do {
        Position next;
        int direction;
        int count = 0;
        int x, y;
        
        // 查找当前位置的相邻未访问的位置
        for (direction = 0; direction < 4; direction++) {
            x = current.x;
            y = current.y;
            
            switch (direction) {
                case 0:  // 上
                    x -= 2;
                    break;
                case 1:  // 右
                    y += 2;
                    break;
                case 2:  // 下
                    x += 2;
                    break;
                case 3:  // 左
                    y -= 2;
                    break;
            }
            
            if (x > 0 && x < WIDTH && y > 0 && y < HEIGHT && maze[x][y] == 1) {
                count++;
                next.x = x;
                next.y = y;
            }
        }
        
        if (count) {  // 存在未访问的相邻位置
            int randomIndex = rand() % count;
            
            // 打通当前位置和下一个位置之间的墙壁
            maze[current.x + (next.x - current.x) / 2][current.y + (next.y - current.y) / 2] = 0;
            
            // 将下一个位置入栈，并更新当前位置
            stack[++top] = next;
            current = next;
        } else {  // 不存在未访问的相邻位置，出栈
            current = stack[--top];
        }
    } while (top > 0);
}

void printMaze(int maze[WIDTH][HEIGHT]) {
    for (int i = 0; i < WIDTH; i++) {
        for (int j = 0; j < HEIGHT; j++) {
            if (maze[i][j] == 0)
                printf("  ");  // 打印通路
            else
                printf("■");  // 打印墙壁
        }
        printf("\n");
    }
}

int main() {
    int maze[WIDTH][HEIGHT];
    generateMaze(maze);
    printMaze(maze);
    return 0;
}

以上的代码使用了深度优先搜索算法，通过随机生成迷宫路径来创建一个迷宫。迷宫由墙壁（"■"）和通路（" "）组成，其中1表示墙壁，0表示通路。生成的迷宫大小为10x10，你可以根据需要修改宽度和高度。运行程序后，将打印生成的迷宫。

### 回答3：
迷宫游戏是一种非常有趣的编程项目，我们可以使用C语言来编写一个生成迷宫的代码。下面是一个使用C语言编写的迷宫生成代码的示例：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROWS 10
#define COLS 10

void generateMaze(int maze[ROWS][COLS]) {
    // 初始化迷宫
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            maze[i][j] = 1;
        }
    }

    // 设置随机数种子
    srand(time(NULL));

    // 生成迷宫路径
    int x = 1, y = 1;
    maze[x][y] = 0;
    
    while (x < ROWS - 2 || y < COLS - 2) {
        int direction = rand() % 4;  // 随机选择一个方向
        
        if (direction == 0 && x > 1 && maze[x - 2][y] != 0) {  // 上方向
            maze[x - 2][y] = 0;
            maze[x - 1][y] = 0;
            x -= 2;
        } else if (direction == 1 && y < COLS - 2 && maze[x][y + 2] != 0) {  // 右方向
            maze[x][y + 2] = 0;
            maze[x][y + 1] = 0;
            y += 2;
        } else if (direction == 2 && x < ROWS - 2 && maze[x + 2][y] != 0) {  // 下方向
            maze[x + 2][y] = 0;
            maze[x + 1][y] = 0;
            x += 2;
        } else if (direction == 3 && y > 1 && maze[x][y - 2] != 0) {  // 左方向
            maze[x][y - 2] = 0;
            maze[x][y - 1] = 0;
            y -= 2;
        }
    }

    // 设置入口和出口
    maze[1][0] = 0;
    maze[ROWS - 2][COLS - 1] = 0;
}

void printMaze(int maze[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (maze[i][j] == 0) {
                printf("  ");  // 打印通路
            } else {
                printf("▉");  // 打印墙壁
            }
        }
        printf("\n");
    }
}

int main() {
    int maze[ROWS][COLS];
    generateMaze(maze);
    printMaze(maze);

    return 0;
}

这段代码生成一个大小为10x10的迷宫。我们使用随机数生成了一个迷宫路径，并将其打印出来。通路使用空格表示，墙壁使用方块字符表示。迷宫生成采用迷宫生成算法，在生成过程中使用随机数让迷宫路径具有随机性，使每次生成的迷宫都不一样。

用c语言写一个随机生成的数独游戏

好的，以下是用C语言实现的随机生成数独游戏的代码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 9
#define M 3

int board[N][N] = {0};

// 检查数独是否合法
int is_valid(int row, int col, int num) {
    int i, j;
    // 检查行和列
    for (i = 0; i < N; i++) {
        if (board[row][i] == num || board[i][col] == num)
            return 0;
    }
    // 检查小九宫格
    int r = row / M * M, c = col / M * M;
    for (i = r; i < r + M; i++) {
        for (j = c; j < c + M; j++) {
            if (board[i][j] == num)
                return 0;
        }
    }
    return 1;
}

// 生成数独游戏
void generate() {
    int i, j, num;
    srand(time(NULL)); // 设置随机种子
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            if (board[i][j] == 0) {
                do {
                    num = rand() % N + 1; // 生成1~9的随机数
                } while (!is_valid(i, j, num));
                board[i][j] = num; // 填充数字
            }
        }
    }
}

// 打印数独游戏
void print_board() {
    int i, j;
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            printf("%d ", board[i][j]);
        }
        printf("\n");
    }
}

int main() {
    generate();
    print_board();
    return 0;
}

运行结果类似于：

1 9 2 7 4 5 6 8 3 
4 7 5 6 3 8 9 1 2 
8 6 3 2 1 9 4 5 7 
3 8 6 4 5 2 7 9 1 
5 4 7 8 9 1 2 3 6 
9 2 1 3 7 6 5 4 8 
6 1 4 9 2 3 8 7 5 
2 5 9 1 8 7 3 6 4 
7 3 8 5 6 4 1 2 9 

这里使用了一个递归算法，先将数独游戏的所有数字都初始化为0，再依次填充数字。每次填充数字时，先生成1~9的随机数，检查该数字是否符合数独游戏的规则，如果符合，则填充该数字；否则重新生成随机数，直到找到符合规则的数字。最终得到的数独游戏为一个合法的数独游戏。