switch写出比三个数大小

当您想要比较三个数字并根据它们的大小执行相应操作时，可以使用`switch`语句结合嵌套的`if`条件。虽然`switch`通常用于单个变量的选择，通过组合和巧妙设计，可以模拟类似的功能。以下是一个简单的例子，展示了如何根据数字的大小打印不同的信息：

int num1 = 5;
int num2 = 7;
int num3 = 3;

int max = (num1 > num2) ? ((num1 > num3) ? num1 : num3) : ((num2 > num3) ? num2 : num3);
String result;

switch (max) {
    case num1:
        result = "num1 is the largest";
        break;
    case num2:
        result = "num2 is the largest";
        break;
    case num3:
        result = "num3 is the largest";
        break;
}

System.out.println(result);

在这个例子中，首先找出最大值，然后根据`switch`中的`case`分支判断哪个数是最大的，并设置相应的结果字符串。

相关问题

写一个JAVA扫雷小游戏

好的，以下是一个简单的JAVA扫雷小游戏的实现，代码中有注释说明每个部分的作用。

import java.util.Random;
import java.util.Scanner;

public class Minesweeper {

    // 游戏难度，决定雷区大小和雷的数量
    private static final int EASY = 1;
    private static final int MEDIUM = 2;
    private static final int HARD = 3;

    // 游戏状态
    private static final int PLAYING = 0;
    private static final int WIN = 1;
    private static final int LOSE = -1;

    // 雷区
    private int[][] board;
    // 雷的数量
    private int numMines;
    // 游戏状态
    private int gameStatus;

    public Minesweeper(int difficulty) {
        // 根据难度获取雷区大小和雷的数量
        int size = 0;
        switch (difficulty) {
            case EASY:
                size = 8;
                numMines = 10;
                break;
            case MEDIUM:
                size = 12;
                numMines = 20;
                break;
            case HARD:
                size = 16;
                numMines = 40;
                break;
            default:
                System.out.println("Invalid difficulty level.");
                return;
        }

        // 初始化雷区
        board = new int[size][size];
        Random rand = new Random();
        for (int i = 0; i < numMines; i++) {
            int x = rand.nextInt(size);
            int y = rand.nextInt(size);
            // 如果该位置已经有雷了，重新生成一个位置
            while (board[x][y] == -1) {
                x = rand.nextInt(size);
                y = rand.nextInt(size);
            }
            board[x][y] = -1;
        }

        // 计算每个格子周围的雷的数量
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (board[i][j] == -1)
                    continue;
                int count = 0;
                if (i > 0 && j > 0 && board[i - 1][j - 1] == -1)
                    count++;
                if (i > 0 && board[i - 1][j] == -1)
                    count++;
                if (i > 0 && j < size - 1 && board[i - 1][j + 1] == -1)
                    count++;
                if (j > 0 && board[i][j - 1] == -1)
                    count++;
                if (j < size - 1 && board[i][j + 1] == -1)
                    count++;
                if (i < size - 1 && j > 0 && board[i + 1][j - 1] == -1)
                    count++;
                if (i < size - 1 && board[i + 1][j] == -1)
                    count++;
                if (i < size - 1 && j < size - 1 && board[i + 1][j + 1] == -1)
                    count++;
                board[i][j] = count;
            }
        }

        // 初始化游戏状态
        gameStatus = PLAYING;
    }

    public void play() {
        Scanner scanner = new Scanner(System.in);
        while (gameStatus == PLAYING) {
            printBoard();
            System.out.print("Enter row and column (e.g. 1 2): ");
            int row = scanner.nextInt() - 1;
            int col = scanner.nextInt() - 1;
            // 判断输入是否合法
            if (row < 0 || row >= board.length || col < 0 || col >= board.length) {
                System.out.println("Invalid input.");
                continue;
            }
            // 如果已经翻开了该格子，提示用户重新输入
            if (board[row][col] >= 0 && board[row][col] <= 8) {
                System.out.println("This cell has already been revealed.");
                continue;
            }
            // 如果是雷，游戏结束，打印出所有的雷
            if (board[row][col] == -1) {
                gameStatus = LOSE;
                printBoard(true);
                System.out.println("You lose!");
                break;
            }
            // 如果是空格，翻开所有相邻的空格
            if (board[row][col] == 0) {
                reveal(row, col);
            }
            // 如果是数字格，直接翻开
            if (board[row][col] > 0 && board[row][col] <= 8) {
                board[row][col] += 10;
            }
            // 判断是否胜利
            if (isWin()) {
                gameStatus = WIN;
                printBoard(true);
                System.out.println("You win!");
                break;
            }
        }
    }

    // 打印出当前的雷区
    private void printBoard() {
        System.out.print("  ");
        for (int i = 1; i <= board.length; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < board.length; i++) {
            System.out.print((i + 1) + " ");
            for (int j = 0; j < board.length; j++) {
                if (board[i][j] == -1) {
                    System.out.print("* ");
                } else if (board[i][j] >= 0 && board[i][j] <= 8) {
                    System.out.print(". ");
                } else if (board[i][j] >= 10 && board[i][j] <= 18) {
                    System.out.print((board[i][j] - 10) + " ");
                }
            }
            System.out.println();
        }
    }

    // 打印出所有的雷
    private void printBoard(boolean showMines) {
        System.out.print("  ");
        for (int i = 1; i <= board.length; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < board.length; i++) {
            System.out.print((i + 1) + " ");
            for (int j = 0; j < board.length; j++) {
                if (board[i][j] == -1) {
                    if (showMines) {
                        System.out.print("* ");
                    } else {
                        System.out.print(". ");
                    }
                } else if (board[i][j] >= 0 && board[i][j] <= 8) {
                    System.out.print(". ");
                } else if (board[i][j] >= 10 && board[i][j] <= 18) {
                    System.out.print((board[i][j] - 10) + " ");
                }
            }
            System.out.println();
        }
    }

    // 翻开所有相邻的空格
    private void reveal(int row, int col) {
        if (row < 0 || row >= board.length || col < 0 || col >= board.length) {
            return;
        }
        if (board[row][col] >= 10) {
            return;
        }
        if (board[row][col] > 0 && board[row][col] <= 8) {
            board[row][col] += 10;
            return;
        }
        board[row][col] += 10;
        reveal(row - 1, col - 1);
        reveal(row - 1, col);
        reveal(row - 1, col + 1);
        reveal(row, col - 1);
        reveal(row, col + 1);
        reveal(row + 1, col - 1);
        reveal(row + 1, col);
        reveal(row + 1, col + 1);
    }

    // 判断是否胜利
    private boolean isWin() {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board.length; j++) {
                if (board[i][j] == -1) {
                    continue;
                }
                if (board[i][j] >= 0 && board[i][j] <= 8) {
                    return false;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Welcome to Minesweeper!");
        System.out.println("Please select difficulty level:");
        System.out.println("1) Easy");
        System.out.println("2) Medium");
        System.out.println("3) Hard");
        int difficulty = scanner.nextInt();
        Minesweeper game = new Minesweeper(difficulty);
        game.play();
    }
}

该游戏支持三种不同的难度级别，分别是容易、中等和困难。玩家需要根据提示输入行和列的坐标，翻开雷区中的格子，直到所有的非雷格子都被翻开为止。如果翻开的格子是空格，那么所有相邻的空格也会被翻开。如果翻开的格子是数字格，那么只有这个格子会被翻开。如果翻开的格子是雷，那么游戏结束，打印出所有的雷。如果所有的非雷格子都被翻开，那么游戏胜利。

1、 登录：密码设置为“abc”，共三次输入密码机会，超过三次为登录不成功。 2、 选择项目：列出三个选项，1、猜数字。2、猜大小。3、退出。选择项目后，执行相应内容。 3、 猜数字：随机产生一个[0，99]间的整数，5次猜数字机会，没猜中会提示太大还是太小。猜完显示出正确答案 4、 猜大小：随机产生一个[1,6]间的整数，1-3为小，4-6为大，用户猜大小。 注：猜数字和猜大小模块后，回到选择项目模块。 用c语言写出上述代码

以下是代码实现：

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

// 定义全局变量
char password[10] = "abc"; // 登录密码
int guess_num_chance = 5; // 猜数字次数
int guess_size_chance = 5; // 猜大小次数

// 登录函数
int login() {
    char input_password[10];
    int chance = 3;
    while (chance > 0) {
        printf("请输入密码：");
        scanf("%s", input_password);
        getchar(); // 消耗掉输入缓冲区中的换行符
        if (strcmp(input_password, password) == 0) {
            printf("登录成功！\n");
            return 1; // 登录成功，返回1
        } else {
            printf("密码错误，请重试！\n");
            chance--;
        }
    }
    printf("密码错误次数超过三次，登录失败！\n");
    return 0; // 登录失败，返回0
}

// 猜数字函数
void guess_num() {
    srand(time(NULL)); // 初始化随机数种子
    int answer = rand() % 100; // 生成[0,99]间的随机数
    int guess;
    for (int i = 0; i < guess_num_chance; i++) {
        printf("请输入一个0到99之间的整数：");
        scanf("%d", &guess);
        getchar(); // 消耗掉输入缓冲区中的换行符
        if (guess == answer) {
            printf("恭喜你，猜对了！\n");
            return;
        } else if (guess < answer) {
            printf("你猜的数字太小了！\n");
        } else {
            printf("你猜的数字太大了！\n");
        }
    }
    printf("很遗憾，你没有在%d次内猜对，正确答案是%d。\n", guess_num_chance, answer);
}

// 猜大小函数
void guess_size() {
    srand(time(NULL)); // 初始化随机数种子
    int answer = rand() % 6 + 1; // 生成[1,6]间的随机数
    int guess;
    for (int i = 0; i < guess_size_chance; i++) {
        printf("请输入一个数字（1表示小，2表示中，3表示大）：");
        scanf("%d", &guess);
        getchar(); // 消耗掉输入缓冲区中的换行符
        if (guess == 1 && answer <= 3 || guess == 2 && answer == 4 || guess == 3 && answer >= 5) {
            printf("恭喜你，猜对了！\n");
            return;
        } else {
            printf("很遗憾，你猜错了！\n");
        }
    }
    printf("很遗憾，你没有在%d次内猜对，正确答案是%s。\n", guess_size_chance, answer <= 3 ? "小" : "大");
}

// 主函数
int main() {
    int choice;
    int logged_in = 0; // 记录是否已登录
    while (1) {
        printf("请选择以下项目：\n");
        printf("1. 猜数字\n");
        printf("2. 猜大小\n");
        printf("3. 退出\n");
        scanf("%d", &choice);
        getchar(); // 消耗掉输入缓冲区中的换行符
        switch (choice) {
            case 1:
                if (!logged_in) {
                    logged_in = login(); // 如果未登录，则先登录
                }
                if (logged_in) {
                    guess_num(); // 登录成功后，执行猜数字游戏
                }
                break;
            case 2:
                if (!logged_in) {
                    logged_in = login(); // 如果未登录，则先登录
                }
                if (logged_in) {
                    guess_size(); // 登录成功后，执行猜大小游戏
                }
                break;
            case 3:
                printf("欢迎下次再来！\n");
                return 0;
            default:
                printf("无效的选择，请重新选择！\n");
        }
    }
    return 0;
}

注意事项：

1. 为了避免输入缓冲区中的换行符对后续输入造成影响，建议使用`scanf`函数读取输入，然后使用`getchar`函数消耗掉输入缓冲区中的换行符。

2. 在猜数字和猜大小模块后，需要回到选择项目模块，因此需要在执行完游戏后再次进入循环，等待用户的选择。为了实现这个功能，可以使用`break`语句跳出当前的`switch`语句，然后重新进入循环。

3. 为了防止用户在未登录的情况下直接进入游戏，可以在选择游戏前设置一个`logged_in`标志，初始值为0，表示未登录。如果用户选择了游戏，则先判断`logged_in`的值，如果为0，则调用`login`函数进行登录。登录成功后，将`logged_in`的值设置为1，表示已登录。