第十四届蓝桥杯B组Java赛道题之幸运数字

 题目：

public class A47 {

	public static void main(String[] args) {
		int count = 0;
		long num = 1;

		while (count < 2023) {
			if (shiJinZhi(num) && erJinZhi(num) && baJinZhi(num) && shiLiuJinZhi(num)) {
				count++;
			}
			num++;
		}
		System.out.println("第 2023 个幸运数字是：" + (num - 1));
	}
	public static boolean shiJinZhi(long i) {//十进制
		long sum = 0;
		long n = i;
		while (n > 0) {
			sum += n % 10;
			n /= 10;
		}
		return i % sum == 0;
	}

	public static boolean erJinZhi(long i) {//二进制
	    long x = i;
	    String binary = Long.toBinaryString(x);
	    int sum = 0;
	    
	    for (int j = 0; j < binary.length(); j++) {
	        sum += binary.charAt(j) - '0';
	    }

	    return i % sum == 0;
	}

	public static boolean baJinZhi(long i) {//八进制
		long x = i;
		String ba = Long.toOctalString(x);
		long num = Long.parseLong(ba);
		long sum = 0;
		while (num > 0) {
			sum += num % 10;
			num /= 10;
		}
		return i % sum == 0;
	}

	public static boolean shiLiuJinZhi(long i) {//十六进制
		long x = i;
		String shiLiu = Long.toHexString(x);
		int sum = 0;
		for (char c : shiLiu.toCharArray()) {
			if (Character.isDigit(c)) {
				sum += Character.digit(c, 16);
			} else {
				switch (c) {
				case 'a':
					sum += 10;
					break;
				case 'b':
					sum += 11;
					break;
				case 'c':
					sum += 12;
					break;
				case 'd':
					sum += 13;
					break;
				case 'e':
					sum += 14;
					break;
				case 'f':
					sum += 15;
					break;
				}
			}
		}
		return i % sum == 0;
	}
}

代码逐行解释：

​
public class A47 {  
    // 定义主方法，程序的入口点  
    public static void main(String[] args) {  
        // 初始化计数器，用于记录找到的幸运数字的数量  
        int count = 0;  
        // 初始化当前检查的数字，从1开始  
        long num = 1;  
  
        // 当找到的幸运数字数量小于2023时，继续循环  
        while (count < 2023) {  
            // 检查当前数字num是否满足所有条件（十进制、二进制、八进制、十六进制）  
            if (shiJinZhi(num) && erJinZhi(num) && baJinZhi(num) && shiLiuJinZhi(num)) {  
                // 如果满足所有条件，计数器加1  
                count++;  
            }  
            // 检查下一个数字  
            num++;  
        }  
  
        // 循环结束后，输出第2023个幸运数字，注意这里为什么是num - 1  
        // 因为在循环结束后，num已经自增了，所以要减1才能得到第2023个幸运数字  
        System.out.println("第 2023 个幸运数字是：" + (num - 1));  
    }  
  
    // 检查数字i的十进制各位数之和是否能整除i本身  
    public static boolean shiJinZhi(long i) {  
        long sum = 0; // 用于存储各位数之和  
        long n = i;   // 临时变量，用于计算  
        // 当n大于0时，循环继续  
        while (n > 0) {  
            // 计算n的个位数，并累加到sum中  
            sum += n % 10;  
            // 去掉n的个位数，准备计算下一位  
            n /= 10;  
        }  
        // 返回i是否能被sum整除  
        return i % sum == 0;  
    }  
  
    // 检查数字i的二进制表示中1的个数是否能整除i本身  
    public static boolean erJinZhi(long i) {  
        long x = i;    // 临时变量，用于计算  
        // 将数字i转换为二进制字符串  
        String binary = Long.toBinaryString(x);  
        int sum = 0;   // 用于存储二进制中1的个数  
  
        // 遍历二进制字符串中的每个字符  
        for (int j = 0; j < binary.length(); j++) {  
            // 如果字符是'1'，则sum加1  
            sum += binary.charAt(j) - '0';  
        }  
  
        // 返回i是否能被sum整除  
        return i % sum == 0;  
    }  
  
    // 检查数字i的八进制表示转换为十进制后，各位数之和是否能整除i本身  
    public static boolean baJinZhi(long i) {  
        long x = i;               // 临时变量，用于计算  
        // 将数字i转换为八进制字符串  
        String ba = Long.toOctalString(x);  
        // 将八进制字符串转换为十进制数字  
        long num = Long.parseLong(ba);  
        long sum = 0;           // 用于存储各位数之和  
  
        // 当num大于0时，循环继续  
        while (num > 0) {  
            // 计算num的个位数，并累加到sum中  
            sum += num % 10;  
            // 去掉num的个位数，准备计算下一位  
            num /= 10;  
        }  
  
        // 返回i是否能被sum整除  
        return i % sum == 0;  
    }  
  
    // 检查数字i的十六进制表示中，每个字符（数字或字母a-f）代表的数值之和是否能整除i本身  
    public static boolean shiLiuJinZhi(long i) {  
        long x = i;               // 临时变量，用于计算  
        // 将数字i转换为十六进制字符串  
        String shiLiu = Long.toHexString(x);  
        int sum = 0;             // 用于存储十六进制中字符代表的数值之和  
  
        // 遍历十六进制字符串中的每个字符  
        for (char c : shiLiu.toCharArray()) {  
            // 如果字符是数字  
            if (Character.isDigit(c)) {  
                // 将字符转换为对应的数字，并累加到sum中  
                sum += Character.digit(c, 16);  
            } else {  
                // 如果字符是字母a-f，则根据十六进制规则累加到sum中  
                switch (c) {  
                    case 'a':  
                        sum += 10

​

方法二：

  
public class Main { // 定义一个名为Main的公共类  
  public static void main(String[] args) { // 主方法，程序的入口点  
    int count = 0; // 初始化计数器，用于记录满足条件的整数的数量  
    int ail = 1; // 初始化变量ail，从1开始检查整数是否满足条件  
    while(true) { // 无限循环，会一直执行直到找到第2023个满足条件的整数  
      if(fn(ail)) { // 调用fn方法检查ail是否满足条件  
        count++; // 如果满足条件，则计数器加1  
      }  
      if(count == 2023) { // 如果已经找到2023个满足条件的整数  
        System.out.println(ail); // 输出这个整数  
        break; // 跳出循环  
      }  
      ail++; // 检查下一个整数  
    }  
  }  
  
  public static boolean fn(int x) { // 定义一个方法fn，用于检查整数x是否满足条件  
    int[] nums = {10,11,12,13,14,15}; // 定义一个数组，用于十六进制字符'a'到'f'的数值映射  
    char[] ch1 = Integer.toString(x, 2).toCharArray(); // 将整数x转换为二进制字符串，并转换为字符数组  
    char[] ch2 = Integer.toString(x, 8).toCharArray(); // 将整数x转换为八进制字符串，并转换为字符数组  
    char[] ch3 = Integer.toString(x, 16).toCharArray(); // 将整数x转换为十六进制字符串，并转换为字符数组  
    char[] ch4 = (x+"").toCharArray(); // 将整数x转换为十进制字符串，并转换为字符数组  
  
    int count1 = 0; // 初始化计数器，用于计算二进制字符串中1的个数  
    for (int i = 0; i < ch1.length; i++) { // 遍历二进制字符数组  
      count1 += Integer.valueOf(ch1[i]+""); // 将字符转换为整数并累加到count1中  
    }  
  
    int count2 = 0; // 初始化计数器，用于计算八进制字符串中数字的和  
    for (int i = 0; i < ch2.length; i++) { // 遍历八进制字符数组  
      count2 += Integer.valueOf(ch2[i]+""); // 将字符转换为整数并累加到count2中  
    }  
  
    int count3 = 0; // 初始化计数器，用于计算十六进制字符串中字符代表的数值之和  
    for (int i = 0; i < ch3.length; i++) { // 遍历十六进制字符数组  
      if(ch3[i] >= 'a' && ch3[i] <= 'f') { // 如果字符是'a'到'f'中的一个  
        count3 += nums[ch3[i] - 'a']; // 使用数组nums查找对应的数值并累加到count3中  
        continue; // 继续下一个循环  
      }  
      count3 += Integer.valueOf(ch3[i]+""); // 如果字符是数字，则将其转换为整数并累加到count3中  
    }  
  
    int count4 = 0; // 初始化计数器，用于计算十进制字符串中数字的和  
    for (int i = 0; i < ch4.length; i++) { // 遍历十进制字符数组  
      count4 += Integer.valueOf(ch4[i]+""); // 将字符转换为整数并累加到count4中  
    }  
  
    // 检查x是否可以被count1, count2, count3, count4整除  
    if(x % count1 != 0) return false; // 如果x不能被count1整除，则返回false  
    if(x % count2 != 0) return false; // 如果x不能被count2整除，则返回false  
    if(x % count3 != 0) return false; // 如果x不能被count3整除，则返回false  
    if(x % count4 != 0) return false; // 如果x不能被count4整除，则返回false  
  
    // 如果x满足上述所有条件，则返回true  
    return true;

 如果你觉得这篇文章对你有用，那就给个关注吧！！