第十四届蓝桥杯ABD题

A、阶乘求和：

【问题描述】

令 S = 1! + 2! + 3! + ... + 202320232023! ，求 S 的末尾 9 位数字。

提示：答案首位不为 0 。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一

个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【代码】

import java.util.*;
 
public class Main {
	public static long INF = 10000000000L;
	public static void main(String[] args) {
		long sum = 0;
		for(int i = 1; i <= 40; i ++)  {
			 sum = sum + fact(i);
		}
		System.out.println(sum % 1000000000);
    }
	public static long fact(int n) {
		long sum1 = 1;
		for(long i = 1; i <= n; i ++) {
			sum1 = sum1 * i;
			if(sum1 >= INF) sum1 = sum1 % INF;
		}
		return sum1;
	}
}

import java.math.BigInteger;
 
public class Main {
	public static void main(String[] args) {
		 BigInteger sum = BigInteger.valueOf(0);//初始化0 
		 for(int i = 1; i <= 40; i ++) { 
			 BigInteger sum1 = BigInteger.valueOf(1);
			 for(int j = 1; j <= i; j ++) {
				 sum1 = sum1.multiply(BigInteger.valueOf(j));//乘法
			 }
			 sum = sum.add(sum1);
		 }
		 System.out.println(sum);//最后复制最后九位数即是答案。
	} 
}

【核心】

mod 10^9 就行，他要看后面九个数，咱就只考虑后面九个数即可 ，即 / 10^9考虑前九位，% 10^9保留后9位，最后复制最后九位数即是答案。BigInteger是Java中用于表示任意大小整数的类,其取值范围在负无穷到正无穷之间。

10的9次方乘以任何数末九位肯定是0，所以只需找到某个较小的n，且n！包含10的9次方这个因子，发现n等于60左右。在n后面的阶乘数，对末9位数学没影响，所以循环到60就行，不需要到2023..

B、幸运数字：

【题目】

哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整 数。例如 126 是十进制下的一个哈沙德数，因为 (126) 10 mod(1+2+6) = 0 ； 126 也是八进制下的哈沙德数，因为 (126) 10 = (176) 8 ， (126) 10 mod (1 + 7 + 6) = 0 ； 同时 126 也是 16 进制下的哈沙德数，因为 (126) 10 = (7 e ) 16 ， (126) 10 mod (7 + e ) = 0 。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为哈沙德数，那么这个数字就是幸运数字，第 1 至第 10 个幸运数字的十进制表示 为：1 , 2 , 4 , 6 , 8 , 40 , 48 , 72 , 120 , 126 . . . 。现在他想知道第 2023 个幸运数 字是多少？你只需要告诉小蓝这个整数的十进制表示即可。

【题解】

10-》2,10-》8,10-》16

public class Main {
    public static void main(String[] args) {
        int number=8;
        int y=2;
        String s= Switch (number,y);
        System.out.println(s);
    }
    public  static String Switch(int n,int binary){
        StringBuilder str=new StringBuilder("");
        while(n>0)
        {
            str.append(n%binary);
            n=n/binary;
        }
        System.out.println(str.reverse().toString());
        return str.reverse().toString();
 
    }
}

public class Main {
	public static void main(String[] args) {
		  int cnt = 0;
		  int i = 1;
		  while(true) {
			  if(i % get_n(i, 2) == 0 && i % get_n(i, 8) == 0 && i % get_n(i, 10) == 0 && i % get_n(i, 16) == 0) cnt ++;
			  if(cnt == 2023)break;
			  i ++;
		  }
		  System.out.println(i);
	}
	public static int get_n(int n, int binary) {
		int sum = 0;
		while(n > 0) {
			sum = sum + n % binary;
			n = n / binary;
		}
		return sum;
	}
}

【十进制转二进制，八进制，十六进制】

Integer.toBinaryString(N)，Integer.toOctalString(N)，Integer.toHexString(N)

【十进制转N进制】

// i 是整数// radix 整数，指定十进制（i）转成 N（redix）进制

public static String toString(int i, int radix)

【N进制转十进制】

Integer.valueOf( str, N ) 方法把N进制的字符str转换成十进制

import java.awt.*;
public class t2 {
    public static void main(String[] args) {
        int ans=0;
        int i=0;
        while (true){
            i++;
            if(isCheck(i)){
                ans++;
                System.out.println(i+"为第"+ans+"个");
            }
            if(ans==2023){
                break;
            }
        }
        System.out.println("答案是："+i);
    }
    static boolean isCheck(int n){
        String temp1=Integer.toString(n,2);
        String temp2=Integer.toString(n,8);
        String temp3=n+"";
        String temp4=Integer.toString(n,16);
        int temp_1=0;
        int temp_2=0;
        int temp_3=0;
        int temp_4=0;
        for (int i = 0; i < temp1.length(); i++) {
            temp_1+=Integer.parseInt(temp1.substring(i,i+1));
        }
        if(n%temp_1!=0){
            return false;
        }
        for (int i = 0; i < temp2.length() ;i++) {
            temp_2+=Integer.parseInt(temp2.substring(i,i+1));
        }
        if(n%temp_2!=0){
            return false;
        }
        for (int i = 0; i < temp3.length(); i++) {
            temp_3+=Integer.parseInt(temp3.substring(i,i+1));
        }
        if(n%temp_3!=0){
            return false;
        }
        for (int i = 0; i < temp4.length(); i++) {
            if((temp4.substring(i,i+1)).toCharArray()[0]>='a'){
                temp_4 += (temp4.substring(i,i+1)).toCharArray()[0]-'a'+10;
            }else {
                temp_4 += Integer.parseInt(temp4.substring(i, i + 1));
            }
        }
        if(n%temp_4!=0){
            return false;
        }
        return true;
    }
}

第一个方法避免了结果为e的情况，用了JAVA的api

D、矩形总面积:

平面上有个两个矩形 R1 和 R2，它们各边都与坐标轴平行。设 (x1, y1) 和(x2, y2) 依次是 R1

的左下角和右上角坐标，(x3, y3) 和 (x4, y4) 依次是 R2 的左下角和右上角坐标，请你计算 R1 和 R2 的总面积是多少？

注意：如果 R1 和 R2 有重叠区域，重叠区域的面积只计算一次。 输入格式 输入只有一行，包含 8

个整数，依次是：x1，y1，x2，y2，x3，y3，x4 和 y4

public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        String[] sp=str.split(",");
        int x1=Integer.parseInt(sp[0]);
        int y1=Integer.parseInt(sp[1]);
        int x2=Integer.parseInt(sp[2]);
        int y2=Integer.parseInt(sp[3]);
        int x3=Integer.parseInt(sp[4]);
        int y3=Integer.parseInt(sp[5]);
        int x4=Integer.parseInt(sp[6]);
        int y4=Integer.parseInt(sp[7]);
        int max_x=Math.max(Math.max(x1,x2),Math.max(x3,x4));
        int max_y=Math.max(Math.max(y1,y2),Math.max(y3,y4));
        int max=Math.max(max_x,max_y);
        int[][] ints=new int[max+1][max+1];
        for(int y=y1;y<=y2-1;y++)
        {
            for(int x=x1;x<=x2-1;x++)
            {
                ints[y][x]=ints[y][x]+1;
            }
        }
        for(int y=y3;y<=y4-1;y++)
        {
            for(int x=x3;x<=x4-1;x++)
            {
                ints[y][x]=ints[y][x]+1;
            }
        }
        int res=0;
        for(int i=0;i<=max;i++)
        {
            for(int z=0;z<=max;z++)
            {
                if(ints[i][z]>=1)
                {
                    res++;
                }
            }
        }
        System.out.println(res);
    }
}