「Java案例」猜数游戏案例实现猜数字游戏设计一个三位数的猜数游戏，三位数随机生成。程序提示用户输入一个三位的数字，

案例实现

猜数字游戏

设计一个三位数的猜数游戏，三位数随机生成。程序提示用户输入一个三位的数字，依照以下的规则决定赢取多少奖金：1) 如果用户输入的数字和随机数字完全一致，输出：“恭喜恭喜！完全猜对了！获得三个赞！”2) 如果用户输入的数字覆盖了随机生成的所有数字(不管顺序)，输出：“输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！”3) 如果用户输入的数字匹配了1个或2个数字，输出：“输入的数字匹配了1个或2个数字！还不错，获得一个赞！”

# 源文件保存为“GuessNumberDemo.java”
import java.util.Random;

public class GuessNumberDemo {
  public static void main(String[] args) {
	    // Generate a lottery
		Random random=new Random();
		int lottery = 100+random.nextInt(900);
		
		// Prompt the user to enter a guess
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入你猜的三位整数: ");
		int guess = input.nextInt();
		
		// Get digits
		int l1 = lottery / 100;
		int l2 = (lottery % 100) / 10; // l2 = (lottery / 10) % 10
		int l3 = lottery % 10;
		
		int g1 = guess / 100;
		int g2 = (guess % 100) / 10;
		int g3 = guess % 10;
		
		System.out.println("随机生成的整数是：" + lottery);
		
		// Check the guess
		if (guess == lottery)
		  System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
		else if (g1 == l1 && g3 == l2 && g2 == l3 ||
		    g2 == l1 && g1 == l2 && g3 == l3 ||
		    g2 == l1 && g3 == l2 && g1 == l3 ||
		    g3 == l1 && g1 == l2 && g2 == l3 ||
		    g3 == l1 && g2 == l2 && g1 == l3)
		  System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
		else if (g1 == l1 || g1 == l2 || g1 == l3 ||
		    g2 == l1 || g2 == l2 || g2 == l3 ||
		    g3 == l1 || g3 == l2 || g3 == l3)
		  System.out.println("输入的数字匹配了1个或2个数字！还不错，获得一个赞！");
		else
		  System.out.println("有点遗憾！下次再来！");
	  }
}

运行结果 输入数字550

请输入你猜的三位整数: 550
随机生成的整数是：410
输入的数字匹配了1个或2个数字！还不错，获得一个赞！

猜数游戏实现

# 源文件保存为“NumberGuessingGame.java”
import java.util.Scanner;
import java.util.Random;
import java.util.HashSet;
import java.util.Set;

public class NumberGuessingGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();
        
        // 生成不重复数字的三位数
        int secretNumber;
        do {
            secretNumber = 100 + random.nextInt(900); // 100-999
        } while (!hasUniqueDigits(secretNumber));
        
        System.out.println("已生成一个三位数，数字不重复，请开始猜测！");
        
        // 获取用户输入
        System.out.print("请输入一个三位数：");
        int guess = scanner.nextInt();
        
        // 验证输入是否为三位数
        if (guess < 100 || guess > 999) {
            System.out.println("请输入有效的三位数！");
            return;
        }
        
        // 比较数字
        if (guess == secretNumber) {
            System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
        } else if (containsAllDigits(secretNumber, guess)) {
            System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
        } else {
            int matchedDigits = countMatchedDigits(secretNumber, guess);
            System.out.printf("输入的数字匹配了%d个数字！还不错，获得一个赞！%n", matchedDigits);
        }
        
        System.out.println("正确答案是：" + secretNumber);
        scanner.close();
    }
    
    // 检查数字是否有重复数字
    private static boolean hasUniqueDigits(int number) {
        Set<Character> digits = new HashSet<>();
        String numStr = String.valueOf(number);
        for (char c : numStr.toCharArray()) {
            if (!digits.add(c)) {
                return false;
            }
        }
        return true;
    }
    
    // 检查猜测数字是否包含所有秘密数字
    private static boolean containsAllDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();
        
        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);
        
        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }
        
        for (char c : guessStr.toCharArray()) {
            guessDigits.add(c);
        }
        
        return guessDigits.containsAll(secretDigits);
    }
    
    // 计算匹配的数字个数
    private static int countMatchedDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();
        
        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);
        
        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }
        
        int count = 0;
        for (char c : guessStr.toCharArray()) {
            if (secretDigits.contains(c)) {
                count++;
            }
        }
        
        return count;
    }
}

运行结果 输入数字520

已生成一个三位数，数字不重复，请开始猜测！
请输入一个三位数：550
输入的数字匹配了3个数字！还不错，获得一个赞！
正确答案是：520

代码解析：

随机数生成：使用Random类生成100-999的三位数，确保数字不重复
输入验证：检查用户输入是否为有效的三位数
三种判断条件：
- 完全匹配：直接比较两个数字
- 覆盖所有数字：使用HashSet检查是否包含所有数字
- 匹配部分数字：统计匹配的数字个数
辅助方法：
- hasUniqueDigits：确保生成的数字没有重复数字
- containsAllDigits：检查是否包含所有数字
- countMatchedDigits：计算匹配的数字个数

多次猜测机会

# 源文件保存为“MultipleGuessGame.java”
import java.util.Scanner;
import java.util.Random;
import java.util.HashSet;
import java.util.Set;

public class MultipleGuessGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        int secretNumber = generateUniqueNumber(random);
        System.out.println("已生成一个三位数，数字不重复，你有5次猜测机会！");

        for (int attempt = 1; attempt <= 5; attempt++) {
            System.out.printf("第%d次尝试，请输入一个三位数：", attempt);
            int guess = scanner.nextInt();

            if (guess < 100 || guess > 999) {
                System.out.println("请输入有效的三位数！");
                attempt--;  // 不消耗尝试次数
                continue;
            }

            if (guess == secretNumber) {
                System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
                return;
            } else if (containsAllDigits(secretNumber, guess)) {
                System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
            } else {
                int matched = countMatchedDigits(secretNumber, guess);
                System.out.printf("输入的数字匹配了%d个数字！还不错，获得一个赞！%n", matched);
            }
        }

        System.out.println("很遗憾，机会用完了！正确答案是：" + secretNumber);
        scanner.close();
    }

    private static int generateUniqueNumber(Random random) {
        int number;
        do {
            number = 100 + random.nextInt(900);
        } while (!hasUniqueDigits(number));
        return number;
    }

    // 检查数字是否有重复数字
    private static boolean hasUniqueDigits(int number) {
        Set<Character> digits = new HashSet<>();
        String numStr = String.valueOf(number);
        for (char c : numStr.toCharArray()) {
            if (!digits.add(c)) {
                return false;
            }
        }
        return true;
    }

    // 检查猜测数字是否包含所有秘密数字
    private static boolean containsAllDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        for (char c : guessStr.toCharArray()) {
            guessDigits.add(c);
        }

        return guessDigits.containsAll(secretDigits);
    }

    // 计算匹配的数字个数
    private static int countMatchedDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        int count = 0;
        for (char c : guessStr.toCharArray()) {
            if (secretDigits.contains(c)) {
                count++;
            }
        }

        return count;
    }
}

运行结果 多次输入数据

已生成一个三位数，数字不重复，你有5次猜测机会！
第1次尝试，请输入一个三位数：123
输入的数字匹配了0个数字！还不错，获得一个赞！
第2次尝试，请输入一个三位数：456
输入的数字匹配了0个数字！还不错，获得一个赞！
第3次尝试，请输入一个三位数：789
输入的数字匹配了2个数字！还不错，获得一个赞！
第4次尝试，请输入一个三位数：780
输入的数字匹配了2个数字！还不错，获得一个赞！
第5次尝试，请输入一个三位数：790
输入的数字匹配了2个数字！还不错，获得一个赞！
很遗憾，机会用完了！正确答案是：809

代码特点：

提供5次猜测机会
输入错误不消耗尝试次数
每次猜测后给出反馈
机会用完后显示正确答案

难度分级

# 源文件保存为“DifficultyLevelGame.java”
import java.util.Scanner;
import java.util.Random;

public class DifficultyLevelGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        System.out.println("选择难度级别：");
        System.out.println("1. 简单（数字可重复）");
        System.out.println("2. 困难（数字不重复）");
        int level = scanner.nextInt();

        int secretNumber;
        if (level == 1) {
            secretNumber = 100 + random.nextInt(900);  // 数字可重复
        } else {
            secretNumber = generateUniqueNumber(random);  // 数字不重复
        }


        System.out.println("已生成一个三位数，数字不重复，请开始猜测！");

        // 获取用户输入
        System.out.print("请输入一个三位数：");
        int guess = scanner.nextInt();

        // 验证输入是否为三位数
        if (guess < 100 || guess > 999) {
            System.out.println("请输入有效的三位数！");
            return;
        }

        // 比较数字
        if (guess == secretNumber) {
            System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
        } else if (containsAllDigits(secretNumber, guess)) {
            System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
        } else {
            int matchedDigits = countMatchedDigits(secretNumber, guess);
            System.out.printf("输入的数字匹配了%d个数字！还不错，获得一个赞！%n", matchedDigits);
        }

        System.out.println("正确答案是：" + secretNumber);
        scanner.close();
    }


    private static int generateUniqueNumber(Random random) {
        int number;
        do {
            number = 100 + random.nextInt(900);
        } while (!hasUniqueDigits(number));
        return number;
    }

    // 检查数字是否有重复数字
    private static boolean hasUniqueDigits(int number) {
        Set<Character> digits = new HashSet<>();
        String numStr = String.valueOf(number);
        for (char c : numStr.toCharArray()) {
            if (!digits.add(c)) {
                return false;
            }
        }
        return true;
    }

    // 检查猜测数字是否包含所有秘密数字
    private static boolean containsAllDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        for (char c : guessStr.toCharArray()) {
            guessDigits.add(c);
        }

        return guessDigits.containsAll(secretDigits);
    }

    // 计算匹配的数字个数
    private static int countMatchedDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        int count = 0;
        for (char c : guessStr.toCharArray()) {
            if (secretDigits.contains(c)) {
                count++;
            }
        }

        return count;
    }
}

运行结果 依次输入数据

选择难度级别：
1. 简单（数字可重复）
2. 困难（数字不重复）
1
已生成一个三位数，数字不重复，请开始猜测！
请输入一个三位数：123
输入的数字匹配了1个数字！还不错，获得一个赞！
正确答案是：279

代码特点： 提供两种难度级别简单级别数字可重复困难级别数字不重复增强游戏可玩性

操作练习题

添加计分系统

要求：

根据猜测次数和匹配程度计算得分
完全匹配得100分
覆盖所有数字得50分
每匹配一个数字得10分
显示最终得分

参考代码：

# 源文件保存为“NumberGuessingGame.java”
import java.util.Scanner;
import java.util.Random;
import java.util.HashSet;
import java.util.Set;

public class NumberGuessingGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        // 生成不重复数字的三位数
        int secretNumber;
        do {
            secretNumber = 100 + random.nextInt(900); // 100-999
        } while (!hasUniqueDigits(secretNumber));

        System.out.println("已生成一个三位数，数字不重复，请开始猜测！");

        // 获取用户输入
        System.out.print("请输入一个三位数：");
        int guess = scanner.nextInt();

        // 验证输入是否为三位数
        if (guess < 100 || guess > 999) {
            System.out.println("请输入有效的三位数！");
            return;
        }

        int score = 0;
        if (guess == secretNumber) {
            score = 100;
            System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
        } else if (containsAllDigits(secretNumber, guess)) {
            score = 50;
            System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
        } else {
            int matched = countMatchedDigits(secretNumber, guess);
            score = matched * 10;
            System.out.printf("输入的数字匹配了%d个数字！还不错，获得一个赞！%n", matched);
        }
        System.out.println("你的得分是：" + score);
        System.out.println("正确答案是：" + secretNumber);
        scanner.close();
    }

    // 检查数字是否有重复数字
    private static boolean hasUniqueDigits(int number) {
        Set<Character> digits = new HashSet<>();
        String numStr = String.valueOf(number);
        for (char c : numStr.toCharArray()) {
            if (!digits.add(c)) {
                return false;
            }
        }
        return true;
    }

    // 检查猜测数字是否包含所有秘密数字
    private static boolean containsAllDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        for (char c : guessStr.toCharArray()) {
            guessDigits.add(c);
        }

        return guessDigits.containsAll(secretDigits);
    }

    // 计算匹配的数字个数
    private static int countMatchedDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        int count = 0;
        for (char c : guessStr.toCharArray()) {
            if (secretDigits.contains(c)) {
                count++;
            }
        }

        return count;
    }
}

运行结果 输入数据123

已生成一个三位数，数字不重复，请开始猜测！
请输入一个三位数：123
输入的数字匹配了1个数字！还不错，获得一个赞！
你的得分是：10
正确答案是：289

添加数字位置提示

要求：

不仅匹配数字，还要匹配位置
提示有多少数字位置正确
例如：秘密数字123，猜测132 → 1数字位置正确（数字1）

参考代码：

# 源文件保存为“NumberGuessingGame.java”
import java.util.Scanner;
import java.util.Random;
import java.util.HashSet;
import java.util.Set;

public class NumberGuessingGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        // 生成不重复数字的三位数
        int secretNumber;
        do {
            secretNumber = 100 + random.nextInt(900); // 100-999
        } while (!hasUniqueDigits(secretNumber));

        System.out.println("已生成一个三位数，数字不重复，请开始猜测！");

        // 获取用户输入
        System.out.print("请输入一个三位数：");
        int guess = scanner.nextInt();

        // 验证输入是否为三位数
        if (guess < 100 || guess > 999) {
            System.out.println("请输入有效的三位数！");
            return;
        }

        int score = 0;
        if (guess == secretNumber) {
            score = 100;
            System.out.println("恭喜恭喜！完全猜对了！获得三个赞！");
        } else if (containsAllDigits(secretNumber, guess)) {
            score = 50;
            System.out.println("输入的数字覆盖了随机生成的所有数字！很棒，获得两个赞！");
        } else {
            int matched = countMatchedDigits(secretNumber, guess);
            score = matched * 10;
            System.out.printf("输入的数字匹配了%d个数字！还不错，获得一个赞！%n", matched);
        }
        System.out.println("正确答案是：" + secretNumber);
        int correctPositions = countCorrectPositions(secretNumber, guess);
        System.out.printf("%d个数字位置正确%n", correctPositions);
        scanner.close();
    }

    // 检查数字是否有重复数字
    private static boolean hasUniqueDigits(int number) {
        Set<Character> digits = new HashSet<>();
        String numStr = String.valueOf(number);
        for (char c : numStr.toCharArray()) {
            if (!digits.add(c)) {
                return false;
            }
        }
        return true;
    }

    // 检查猜测数字是否包含所有秘密数字
    private static boolean containsAllDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        for (char c : guessStr.toCharArray()) {
            guessDigits.add(c);
        }

        return guessDigits.containsAll(secretDigits);
    }

    // 计算匹配的数字个数
    private static int countMatchedDigits(int secret, int guess) {
        Set<Character> secretDigits = new HashSet<>();
        Set<Character> guessDigits = new HashSet<>();

        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);

        for (char c : secretStr.toCharArray()) {
            secretDigits.add(c);
        }

        int count = 0;
        for (char c : guessStr.toCharArray()) {
            if (secretDigits.contains(c)) {
                count++;
            }
        }

        return count;
    }
    private static int countCorrectPositions(int secret, int guess) {
        String secretStr = String.valueOf(secret);
        String guessStr = String.valueOf(guess);
        int count = 0;

        for (int i = 0; i < 3; i++) {
            if (secretStr.charAt(i) == guessStr.charAt(i)) {
                count++;
            }
        }
        return count;
    }
}

运行结果 输入数据123

已生成一个三位数，数字不重复，请开始猜测！
请输入一个三位数：123
输入的数字匹配了2个数字！还不错，获得一个赞！
正确答案是：421
1个数字位置正确