2025蓝桥杯JAVA编程题训练Day6

1.小盘算器

题目描述

模仿程序型盘算器，依次输入指令，可能包含的指令有

• 数字：'NUMX'，X 为一个只包含大写字母和数字的字符串，表现一个当进步制的数。
  
• 运算指令：'ADD','SUB','MUL','DIV','MOD'，分别表现加减乘，除法取商，除法取余。
  
• 进制转换指令：'CHANGE K'，将当进步制转换为 K 进制(2≤K≤36)。
  
• 输出指令：'EQUAL'，以当进步制输出效果。
  
• 重置指令：'CLEAR'，扫除当前数字。
  

指令按照以下规则给出：
数字，运算指令不会一连给出，进制转换指令，输出指令，重置指令有可能一连给出。
运算指令后出现的第一个数字，表现参与运算的数字。且在该运算指令和该数字中心不会出现运算指令和输出指令。
重置指令后出现的第一个数字，表现基础值。且在重置指令和第一个数字中心不会出现运算指令和输出指令。
进制转换指令可能出现在任何地方。
运算过程中中心变量均为非负整数，且小于 263。
以大写的'A'~'Z'表现 10~35。
输入描述

第 1 行：1 个n（1≤n<5×10^5），表现指令数量。
第 2 ⋯n+1行：每行给出一条指令。指令序列一定以'CLEAR'作为开始，而且满足指令规则。
初始默认的进制是十进制。
输出描述

依次输出每一次 'EQUAL' 得到的效果。
输入输出样例

   输入

1. 7
2. CLEAR
3. NUM 1024
4. CHANGE 2
5. ADD
6. NUM 100000
7. CHANGE 8
8. EQUAL

复制代码

   输出

1. 2040

复制代码

AC代码

1. import java.util.*;
2. public class exercise1 {
3.     static Scanner scan=new Scanner(System.in);
4.     public static void main(String[] args) {
5.             int t=scan.nextInt();
6.             long ans=0;
7.             int sys=10;
8.             String str=null; // 当运算时确定操作符
9.             boolean flag=false;
10.             while(t-->0) { //先判断t再减
11.                     String s=scan.next(); //空格之前的,不包含空格后
12.                     if(s.equals("CLEAR")) {
13.                             ans=0;
14.                             flag=false;
15.                     }else if(s.equals("NUM")) {
16.                             String n=scan.next();
17.                             if(!flag) {
18.                                     // flag为false表示初始赋值
19.                                     ans=Long.parseLong(n, sys);
20.                                     flag=true; // 之后的为运算数
21.                             }else {
22.                                     long m=Long.parseLong(n,sys);
23.                                     if(str.equals("ADD")) {
24.                                             ans+=m;
25.                                     }else if(str.equals("SUB")) {
26.                                             ans-=m;
27.                                     }else if(str.equals("MUL")) {
28.                                             ans*=m;
29.                                     }else if(str.equals("DIV")) {
30.                                             ans/=m;
31.                                     }else if(str.equals("MOD")) {
32.                                             ans%=m;
33.                                     }
34.                             }
35.                     }else if(s.equals("EQUAL")) {
36.                             System.out.println(Long.toString(ans,sys).toUpperCase());
37.                     }else if(s.equals("CHANGE")) {
38.                             sys=scan.nextInt();
39.                     }else { // 运算指令（只有操作符）
40.                             str=s;
41.                             flag=true;
42.                     }
43.             }
44.     }
45. }

复制代码

 2.小数第n位

题目描述

我们知道，整数做除法时，有时得到有限小数，有时得到无穷循环小数。
如果我们把有限小数的末尾加上无穷多个 0，它们就有了统一的情势。
本题的任务是：在上面的约定下，求整数除法小数点后的第 nn 位开始的 3 位数。
输入描述

输入一行三个整数：a b na b n，用空格分开。aa 是被除数，bb 是除数，nn 是所求的小数后位置（0<a,b,n<1090<a,b,n<109）
输出描述

输出一行 3 位数字，表现：aa 除以 bb，小数后第 nn 位开始的 3 位数字。
输入输出样例

   输入

1. 1 8 1

复制代码

   输出

1. 125

复制代码

AC代码

（1）过20%样例，暴力 

1. import java.util.*;
2. public class exercise1 {
3.     static Scanner scan=new Scanner(System.in);
4.     public static void main(String[] args) {
5.             long a=scan.nextInt();
6.             long b=scan.nextInt();
7.             long n=scan.nextInt();
8.             String s=Double.toString((a*1.0)/(b*1.0));
9.             long idx=s.indexOf(".");
10.             long tt=idx+n;
11.             for(int i=1;i<=3;i++) {
12.                     if(tt>=s.length())System.out.print(0);
13.                     else System.out.print(s.charAt((int)tt));
14.                     tt++;
15.             }
16.     }
17. }

复制代码

3.类斐波那契循环数

问题描述

对于一个有 n 位的十进制数 N=d1d2d3…dn​，可以生成一个类斐波那契数列S，数列 S 的前 nn 个数为：
{S1=d1,S2=d2,S3=d3,…,Sn=dn}
数列 S 的第 k(k>n) 个数为：
∑​Si​（i=k-n到k-1）
如果这个数 N 会出现在对应的类斐波那契数列 S 中，那么 N 就是一个类斐波那契循环数。
例如对于 197，对应的数列 S 为：
{1,9,7,17,33,57,107,197,…}
197 出现在 S 中，所以 197 是一个类斐波那契循环数。
叨教在 0 至 10^7 中，最大的类斐波那契循环数是多少?
答案提交

这是一道效果填空的题，你只需要算出效果后提交即可。本题的效果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解题要点

• 求最大，则从最大到小摆列
  
• 对于n个数，数组num只需要0到n-1，因为求和也只求0到n-1。因为每次求完和都放在后面，且不断向后n个n个求和，因此只需把效果使用取模的方式放到num中。（如num[j%n]=sum）
  
• 求和数组可以使用：sum=Arrays.stream(num).sum()
  

AC代码

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 for(int i=10000000;i>0;i--) {
6.                         if(check(i)) {
7.                                 System.out.println(i);
8.                                 break;
9.                         }
10.                 }
11.         }
12.         public static boolean check(int x) {
13.                 String s=x+"";
14.                 int n=s.length();
15.                 int[] num=new int[n];
16.                 for(int i=0;i<n;i++) {
17.                         num[i]=s.charAt(i)-'0';
18.                 }
19.                 int sum=0;
20.                 for(int i=n;sum<x;i++) {
21.                         sum=Arrays.stream(num).sum();//数组求和
22.                         num[i%n]=sum;
23.                 }
24.                 //循环退出为sum>=x
25.                 return sum==x;
26.         }
27. }

复制代码

4.分布式队列

问题描述

小蓝最近学习了一种神奇的队列： 分布式队列。简单来说，分布式队列包含 N 个节点（编号为 0 至 N−1，此中 0 号为主节点），此中只有一个主节点，别的为副节点。
主/副节点中都各自维护着一个队列，当往分布式队列中添加元素时，都是由主节点完成的（每次都会添加元素到主节点对应的队列的尾部）；副节点只负责同步主节点中的队列。可以以为主/副节点中的队列是一个长度无穷的一维数组，下标为 0,1,2,3…，同时副节点中的元素的同步次序和主节点中的元素添加次序保持一致。
由于副本的同步速度各异，因此为了保障数据的一致性，元素添加到主节点后，需要同步到所有的副节点后，才具有可见性。
给出一个分布式队列的运行状态，所有的操纵都按输入次序实行。你需要答复在某个时候，队列中有多少个元素具有可见性。
输入格式

第一行包含一个整数 N，表现节点个数。
接下来包含多行输入，每一行包含一个操纵，操纵类型共有以下三种： add、sync 和 query，各自的输入格式如下：

• addelement： 表现这是一个添加操纵，将元素 element 添加到队列中;
  
• syncfollowerid​： 表现这是一个同步操纵，followerid​ 号副节点会从主节点中同步下一个本身缺失的元素;
  
• query： 查询操纵，扣问当前分布式队列中有多少个元素具有可见性。
  

输出格式

对于每一个 query操纵，输出一行，包含一个整数表现答案。
样例输入

1. 3
2. add 1
3. add 2
4. query
5. add 1
6. sync 1
7. sync 1
8. sync 2
9. query
10. sync 1
11. query
12. sync 2
13. sync 2
14. sync 1
15. query

复制代码

样例输出

1. 0
2. 1
3. 1
4. 3

复制代码

样例阐明

实行到第一个 query时，队列内容如下：
0： [1,2]
1： []
2： []
两个副节点中都无元素，因此答案为 0。
实行到第二个 query 时，队列内容如下：
0： [1,2,1]
1： [1,2]
2： [1]
只有下标为 0 的元素被所有节点同步，因此答案为 1 。
实行到第三个 query 时，队列内容如下：
0： [1,2,1]
1： [1,2,1]
2： [1]
只有下标为 0 的元素被所有节点同步，因此答案为 1。
实行到第四个 query 时，队列内容如下：
0： [1,2,1]
1： [1,2,1]
2： [1,2,1]
三个元素都被所有节点同步，因此答案为 3。
解题要点

• 对处理不限定命量的输入（一行一行），接纳while(scan.hasNext())
  
• 对于中心有空格，可以使用String op=scan.next()，只接收到空格前
  

AC代码 

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 int n=scan.nextInt();
6.                 int[] count=new int[n];
7.                 while(scan.hasNext()) { //对于处理不限定的输入
8.                         String op=scan.next();//空格前
9.                         if(op.equals("add")) {
10.                                 int x=scan.nextInt();//其实可以不用管，接收就好了
11.                                 count[0]++;
12.                         }else if(op.equals("sync")) {
13.                                 int x=scan.nextInt();
14.                                 count[x]=Math.min(count[0], count[x]+1);
15.                         }else {
16.                                 int res=count[0];
17.                                 for(int i=1;i<n;i++) {
18.                                         res=Math.min(res, count[i]);
19.                                 }
20.                                 System.out.println(res);
21.                         }
22.                 }
23.         }
24. }

复制代码

5.食堂

问题描述

S 学校里一共有 a2个两人寝、a3​ 个三人寝，a4个四人寝，而食堂里有 b4​ 个四人桌和 b6​ 个六人桌。学校想要安排门生们在食堂用餐，而且满足每个睡房里的同学都在同一桌就坐，叨教这个食堂最多同时满足多少同学用餐？
输入格式

接纳多组数据输入。
输入共 q+1 行。
第一行为一个正整数 q 表现数据组数。
后面 q 行，每行五个非负整数 a2,a3,a4,b4,b6表现一组数据。
输出格式

输出共 q 行，每行一个整数表现对应输入数据的答案。
样例输入

1. 2
2. 3 0 1 0 1
3. 0 2 2 1 1

复制代码

样例输出

1. 6
2. 10

复制代码

样例阐明

对于第一组数据，只有一个六人桌，因此最多安排三个两人寝的同学就餐，答案为 (2+2+2)=6(2+2+2)=6 。
对于第二组数据，用一个六人桌安排两个三人寝的同学，用一个四人桌安排一个四人寝的同学，答案为 (3+3)+(4)=10(3+3)+(4)=10 。
解题要点

• 先满足可以或许把桌子都坐满的情况。
  
• 然后再依次满足由缺1个到缺4个的情况。
  

AC代码

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 int n=scan.nextInt();
6.                 while(n-->0) {
7.                         int ans=0;
8.                         int a2=scan.nextInt();
9.                         int a3=scan.nextInt();
10.                         int a4=scan.nextInt();
11.                         int b4=scan.nextInt();
12.                         int b6=scan.nextInt();
13.                         //4-4人寝
14.                         while(b4>0&&a4>=1) {
15.                                 b4--;a4--;ans+=4;
16.                         }
17.                         //2*2-4人寝
18.                         while(b4>0&&a2>=2) {
19.                                 b4--;a2-=2;ans+=4;
20.                         }
21.                         //4+2-6人寝
22.                         while(b6>0&&a4>=1&&a2>=1) {
23.                                 b6--;a4--;a2--;ans+=6;
24.                         }
25.                         //3+3-6人寝
26.                         while(b6>0&&a3>=2) {
27.                                 b6--;a3-=2;ans+=6;
28.                         }
29.                         //2*3-6人寝
30.                         while(b6>0&&a2>=3) {
31.                                 b6--;a2-=3;ans+=6;
32.                         }
33.                         //3剩1-4人寝
34.                         while(b4>0&&a3>=1) {
35.                                 b4--;a3--;ans+=3;
36.                         }
37.                         //2+3剩1-6人寝
38.                         while(b6>0&&a2>=1&&a3>=1) {
39.                                 b6--;a2--;a3--;ans+=5;
40.                         }
41.                         //2剩2-4人寝
42.                         while(b4>0&&a2>=1) {
43.                                 b4--;a2--;ans+=2;
44.                         }
45.                         //4剩2-6人寝
46.                         while(b6>0&&a4>=1) {
47.                                 b6--;a4--;ans+=4;
48.                         }
49.                         //2*2剩2-6人寝
50.                         while(b6>0&&a2>=2) {
51.                                 b6--;a2-=2;ans+=4;
52.                         }
53.                         //3剩3-6人寝
54.                         while(b6>0&&a3>=1) {
55.                                 b6--;a3--;ans+=3;
56.                         }
57.                         //2剩4-6人寝
58.                         while(b6>0&&a2>=1) {
59.                                 b6--;a2--;ans+=2;
60.                         }
61.                         System.out.println(ans);
62.                 }
63.         }
64. }

复制代码

6.最优分组

问题描述

小蓝开了一家宠物店，最近有一种 X 病毒在动物之间进行传染，小蓝为了以防万一打算购买测试剂对本身的宠物进行病毒感染测试。
为了淘汰使用的测试剂数目，小蓝想到了一个好方法：将 N 个宠物平均分为若干组，使得每组恰好有 K 只宠物，这样对同一组的宠物进行采样并混淆后用一个试剂进行检测，如果测试效果为阴性则阐明组内宠物都未感染 X 病毒；如果是阳性的话则需要对组内所有 K 只宠物单独检测，需要再消耗 K 支测试剂（当 K=1 时，就没须要再次进行单独检测了，因为组内只有一只宠物，一次检测便能确认答案）。
现在我们已知小蓝的宠物被感染的概率为 p，叨教 K 应该取值为多少才能使得盼望的测试剂的消耗数目最少？如果有多个答案输出最小的 K。
输入格式

第一行，一个整数 N 。
第二行，一个浮点数 p 。
输出格式

输出一行，一个整数 K 表现答案。
样例输入

1. 1000
2. 0.05

复制代码

样例输出

1. 5

复制代码

解题要点

• 一组K只宠物,那么没有宠物感染的概率就是P=(1-p)^K,至少有一只宠物感染的概率即1-P。
  
• 需要使用的药剂数量盼望E=P*(N/K)+(1-P)*(N/K)+(1-P)*(N/K)*K。
  
• 起首第一个是没有宠物感染P，则有N/K组，则只需要P*(N/K)个药剂（一组一个）；
  
• 然后第二个是有宠物感染(1-P)，则有N/K组，第一轮只需要(1-P)*(N/K)个药剂（一组一个）,第二轮在N/K组中此中有(1-P)*(N/K)个组是有感染的，因此对(1-P)*(N/K)个组每个组K个宠物再进行检测，即使用(1-P)*(N/K)*K个药剂。
  

AC代码 

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 int n=scan.nextInt();
6.                 double p=scan.nextFloat();
7.                 int mink=Integer.MAX_VALUE;
8.                 double miny=Double.MAX_VALUE;
9.                 for(int k=n;k>=1;k--) {
10.                         if(n%k==0) { //(保证这个)能完整分完，答案更小
11.                                 double P=Math.pow(1-p, k);
12.                                 double E=(P+(1-P)*(1+k))*(n/k);
13.                                 if(k==1)E=n;
14.                                 if(E<=miny) {
15.                                         miny=E;
16.                                         mink=k;
17.                                 }
18.                         }
19.                 }
20.                 System.out.println(mink);
21.         }
22. }

复制代码

7.星际观光

问题描述

小明国庆节准备去某星系进行星际观光，这个星系里一共有 n 个星球，此中部署了 m 道双向传送门，第 ii 道传送门可以毗连 ai,bi 两颗星球（ai≠bi 且任意两颗星球之间最多只有一个传送门）。
他看中了一款 “旅游盲盒”，一共有 Q 个盲盒，第 i 个盲盒里的观光方案规定了观光的起始星球 xi 和最多可以使用传送门的次数 yi​。只要从起始星球出发，使用传送门不凌驾规定次数能到达的所有星球都可以去观光。
小明关心在每个方案中有多少个星球可以观光到。小明只能在这些盲盒里随机选一个购买，他想知道能观光到的不同星球的数量的盼望是多少。
输入格式

输入共 m+Q+1 行。
第一行为三个正整数 n,m,Q 。
后面 m 行，每行两个正整数 ai,bi 。
后面 Q 行，每行两个整数 xi,yi 。
输出格式

输出共一行，一个浮点数（四舍五入保存两位小数）。
样例输入

1. 3 2 3
2. 1 2
3. 2 3
4. 2 1
5. 2 0
6. 1 1

复制代码

样例输出

1. 2.00

复制代码

样例阐明

第一个盲盒可以观光到 1,2,3。
第二个盲盒可以观光到 2。
第三个盲盒可以观光到 1,2。
所以盼望是 (3+1+2)/3=2.00
。
解题要点

• 传送门可以毗连两颗星球----》两个节点相连
  
• 只要从起始星球x出发，使用传送门不凌驾规定次数y能到达的所有星球都可以去观光---》只要从起始点x，距离<=y都可以到达
  
• 求盼望，即求概率，把从q个（xi起始点，yi距离）所能到达的点都加起来（可以重复），末了再除以q，则是我们末了要的答案
  
• 数据范围小使用floyd，用数组求节点到节点的最短距离，注意需要数组初始
  
• floyd数组初始：cnt[j]=一个较大的数(i!=j),且cnt=0
  
• floyd得到效果：for(k):for(i):for(j):cnt[j]=min(cnt[j],cnt[k]+cnt[k][j])
  

AC代码

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 //某些节点相连，求规定起点和规定距离中能到达的最多的节点数
6.                 //传送门即节点相邻，使用传送门的次数即规定的距离
7.                 //求节点到节点的最短距离使用foyld
8.                 int n=scan.nextInt();
9.                 int m=scan.nextInt();
10.                 int q=scan.nextInt();
11.                 int[][] cnt=new int[n+1][n+1];
12.                 //数组初始！！
13.                 //还可以这样：for(int i=1;i<=n;i++)Arrays.fill(cnt[i], 10000);
14.                 for(int i=1;i<=n;i++) {
15.                         for(int j=1;j<=n;j++) {
16.                                 cnt[i][j]=10000;
17.                                 if(i==j)cnt[i][j]=0;
18.                         }
19.                 }
20.                
21.                 for(int i=1;i<=m;i++) {
22.                         int a=scan.nextInt();
23.                         int b=scan.nextInt();
24.                         cnt[a][b]=1;
25.                         cnt[b][a]=1;
26.                 }
27.                 //floyd
28.                 for(int k=1;k<=n;k++) {
29.                         for(int i=1;i<=n;i++) {
30.                                 for(int j=1;j<=n;j++) {
31.                                         cnt[i][j]=Math.min(cnt[i][j], cnt[i][k]+cnt[k][j]);
32.                                 }
33.                         }
34.                 }
35.                 int ans=0;
36.                 for(int i=1;i<=q;i++) {
37.                         int x=scan.nextInt();//起点x
38.                         int y=scan.nextInt();//距离y
39.                         int count=0;
40.                         for(int j=1;j<=n;j++) {
41.                                 //只要从起始点出发，距离<=y都可以到达
42.                                 if(cnt[x][j]<=y)count++;
43.                         }
44.                         ans+=count;
45.                 }
46.                 //求期望
47.                 System.out.printf("%.2f",ans*1.0/q);
48.         }
49. }

复制代码

8.过年

问题描述

蓝桥村的村民们正准备欢迎新年。他们计划宰杀 N 头猪，以庆祝一整年的辛勤劳作和丰收。每头猪的初始位置位于下标 xi，所有 xi均为偶数，保证没有两端猪初始位置相同。
当猪意识到人类打算宰杀它们时，并非束手就擒。它们会主动移动以探求同伴，遵循以下规则：

• 每头猪以恒定速率朝着最近的另一头猪移动。如有多头猪距离相同，则选择朝着坐标更小的猪移动。所有猪的移动速度相同。
  
• 当两只猪相遇在同一坐标时，它们会融合成一个团体，被视为一头猪。
  

当所有猪聚集在同一坐标点时停止移动。现在村民们想要确定终极猪群聚集简直切坐标位置，请你资助解决这个问题。
输入格式

第一行输入一个整数 N(2≤N≤105)表现猪的数量。
第二行输入 N 个整数 x1,x2,⋯,xN(−109≤xi≤109) 表现每头猪的坐标，保证 x1,x2,⋯xN​ 是偶数，且各不相同。
输出格式

输出一个整数表现答案。
样例输入

1. 5
2. 0 -2 -4 10 2

复制代码

样例输出

1. 3

复制代码

解题要点

•  起首要将坐标从小到大进行排序
  
• 使用少量样例（如4个点），观察找规律
  

AC代码

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 //假设n=4:-2、0、2、4, (从小到大排序)
6.                 //(-2+0)/2=-1,(2+4)/2=3,(-1+3)/2=1
7.                 //也就是(-2+4)/2=1
8.                 int n=scan.nextInt();
9.                 int[] x=new int[n];
10.                 for(int i=0;i<n;i++) {
11.                         x[i]=scan.nextInt();
12.                 }
13.                 Arrays.sort(x);
14.                 System.out.println((x[0]+x[n-1])/2);
15.         }
16. }

复制代码

9.最大比例

题目描述

X 星球的某个大奖赛设了 M 级奖励。每个级别的奖金是一个正整数。
而且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：16,24,36,54，其等比值为：3/2​
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
输入描述

第一行为数字 N(0<N<100)，表现接下的一行包含 N 个正整数
第二行 N 个正整数 Xi​(Xi​<109)，用空格分开。每个整数表现调查到的或人的奖金数额
输出描述

一个形如 A/B 的分数，要求 A、B 互质。表现可能的最大比例系数 测试数据保证了输入格式正确，而且最大比例是存在的。
输入输出样例

   输入

1. 3
2. 1250 200 32

复制代码

   输出

1. 25/4

复制代码

解题要点

• 求最大公约数gcd：long gcd(a,b)：return b==0?a:gcd(b,a%b)
  

AC代码 

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 int n=scan.nextInt();
6.                 long[] x=new long[n];
7.                 for(int i=0;i<n;i++) {
8.                         x[i]=scan.nextLong();
9.                 }
10.                 Arrays.sort(x);
11.                 long minx=Long.MAX_VALUE;
12.                 long miny=Long.MAX_VALUE;
13.                 for(int i=0;i+1<n;i++) {
14.                         if(x[i]!=x[i+1]) {
15.                                 long gg=gcd(x[i],x[i+1]);
16.                                 miny=Math.min(x[i+1]/gg, miny);
17.                                 minx=Math.min(x[i]/gg, minx);
18.                         }
19.                 }
20.                 System.out.println(miny+"/"+minx);
21.         }
22.         public static long gcd(long a,long b) {
23.                 return b==0?a:gcd(b,a%b);
24.         }
25. }

复制代码

10.特殊日期

问题描述

对于一个日期，我们可以盘算出年份的各个数位上的数字之和，也可以分别盘算月和日的各位数字之和。叨教从 1900 年 1 月 1日至 9999 年 12 月 31 日，总共有多少天，年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
例如，2022年 11月 13日满足要求，因为 2+0+2+2=(1+1)+(1+3)。
请提交满足条件的日期的总数量。
答案提交

这是一道效果填空的题，你只需要算出效果后提交即可。本题的效果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解题要点

• 4,6,9,11-30天（剩下31天，2月闰年29，非闰年28）。
  
• 对四位数y进行分解时是这样的：y/1000+y/100%10+y/10%10+y%10（不断取末了一位）
  
• 判断闰年：if( (y%4==0&&y%100!=0) || (y%400==0) )，如果成立则是闰年
  

AC代码

1. import java.util.*;
2. public class exercise1{
3.         public static Scanner scan=new Scanner(System.in);
4.         public static void main(String[] args) {
5.                 int ans=0;
6.                 int[] month= {0,31,28,31,30,31,30,31,31,30,31,30,31};
7.                 for(int y=1900;y<=9999;y++) {
8.                         for(int m=1;m<=12;m++) {
9.                                 int maxd=month[m];
10.                                 if(m==2&&check(y))maxd+=1;
11.                                 for(int d=1;d<=maxd;d++) {
12.                                         if((y/1000+y/100%10+y/10%10+y%10)==(m/10+m%10+d/10+d%10)) {
13.                                                 ans++;
14.                                         }
15.                                 }
16.                         }
17.                 }
18.                 System.out.println(ans);
19.         }
20.         public static boolean check(int y) {
21.                 if((y%4==0&&y%100!=0)||(y%400==0)) {
22.                         return true;
23.                 }
24.                 return false;
25.         }
26. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。