目录
第 1 题：特殊日期
问题描述
对于一个日期，我们可以计算出年份的各个数位上的数字之和，也可以分别计算月和日的各位数字之和。请问从 1900 年 1 月 1 日至 9999 年 12 月 31 日，总共有多少天，年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
例如，2022 年 11 月 13 日满足要求，因为 2+0+2+2=(1+1)+(1+3) 。
请提交满足条件的日期的总数量。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
运行限制
- 最大运行时间：1s
- 最大运行内存: 256M
代码：
package 第十四届蓝桥杯三月真题刷题训练.day13;
import java.util.Arrays;
/**
* @author yx
* @date 2023-03-16 12:36
*/
public class 特殊日期 {
static int[] pinYear=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
static int[] runYear=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
static int ans=0;
public static void main(String[] args) {
for (int i = 1900; i <=9999 ; i++) {
int temp[];
if(isRunYear(i)){
temp= Arrays.copyOf(runYear,13);
}else {
temp= Arrays.copyOf(pinYear,13);
}
int count3=0;
char[] temp3=(i+"").toCharArray();
int length=temp3.length;
for (int l = 0; l < length; l++) {
count3+=(temp3[l]-'0');
}
for (int j = 1; j <= 12; j++) {
int count2=0;
char[] temp2=(j+"").toCharArray();
length=temp2.length;
for (int l = 0; l < length; l++) {
count2+=(temp2[l]-'0');
}
for (int k = 1; k <= temp[j]; k++) {
int count1=0;
char[] temp1=(k+"").toCharArray();
length=temp1.length;
for (int l = 0; l < length; l++) {
count1+=(temp1[l]-'0');
}
if(count1+count2==count3){
ans++;
System.out.println(i+" "+j+" "+k);
}
}
}
}
System.out.println(ans);
}
static boolean isRunYear(int n){
if(n%400==0||(n%4==0&&n%100!=0)){
return true;
}
return false;
}
}
思路：
（1）定义两个数组，一个是闰年的的每个月的天数，一个是平年的每个月的天数
（2）接下俩直接暴力遍历就完事儿了
第 2 题：重合次数
问题描述
在同一天中, 从上午 6 点 13 分 22 秒到下午 14 点 36 分 20 秒, 钟表上的 分针和秒针一共重合了多少次?
注意时针、分针、秒针都围绕中心敳匀速运动。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。
运行限制
- 最大运行时间：1s
- 最大运行内存: 512M
代码：
package 第十四届蓝桥杯三月真题刷题训练.day13;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
/**
* @author yx
* @date 2023-03-16 13:25
*/
public class 重合次数 {
static PrintWriter out =new PrintWriter(System.out);
static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer in=new StreamTokenizer(ins);
/**
* 输入
* in.nextToken()
* int a= (int)in.nval;
*
* 输出
* out.print();
* out.flush();
*/
public static void main(String[] args) {
int h=6;
int m=13;
int s=22;
int ans=0;
while (true){
if(h==14&&m==36&&s==20){
System.out.println(ans);
return;
}
s++;
if(m==s)ans++;
if(s==60){
m++;//60s等于1min
s=0;
if(m==60){//60min=1h
h++;
m=0;
}
}
}
}
}
第 3 题：左移右移
问题描述
小蓝有一个长度为 N 的数组, 初始时从左到右依次是 1,2,3,…N
之后小蓝对这个数组进行了 M 次操作, 每次操作可能是以下 2 种之一:
左移 x, 即把 x 移动到最左边。
右移 x, 即把 x 移动到最右边。
请你回答经过 MM 次操作之后, 数组从左到右每个数是多少?
输入格式
第一行包含 2 个整数, N 和 M 。
以下 M 行每行一个操作, 其中 “L x "表示左移 x,"Rx "表示右移 x 。
输出格式
输出 NN 个数, 代表操作后的数组。
样例输入
5 3 L 3 L 2 R 1样例输出
2 3 4 5 1样例说明
样例中的数组变化如下:
[1,2,3,4,5]→[3,1,2,4,5]→[2,3,1,4,5]→[2,3,4,5,1]
评测用例规模与约定
对于 50% 的评测用例, 1≤N,M≤10000.
对于 100% 的评测用例, 1≤N,M≤200000,1≤x≤N.
运行限制
- 最大运行时间：3s
- 最大运行内存: 512M
代码：
package 第十四届蓝桥杯三月真题刷题训练.day13;
/**
* @author yx
* @date 2023-03-16 16:33
*/
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
/**
* @author yx
* @date 2023-03-16 16:02
*/
public class 左移右移 {
static PrintWriter out =new PrintWriter(System.out);
static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer in=new StreamTokenizer(ins);
/**
* 输入
* in.nextToken()
* int a= (int)in.nval;
*
* 输出
* out.print();
* out.flush();
*/
static class Node implements Comparable<Node>{
int power;
int value;
Node(int power,int value){
this.power=power;
this.value=value;
}
@Override
public int compareTo(Node o) {
if(this.power>o.power){//按照权值排序
return 1;
}else {
return -1;
}
}
}
public static void main(String[] args) throws IOException {
in.nextToken();
int N=(int) in.nval;
in.nextToken();
int M=(int) in.nval;
Node[] nums=new Node[N];
for (int i = 0; i < N; i++) {
//初始权值定义和value一样大
Node node = new Node(i+1,i+1);
nums[i]=node;
}
int start=0;
int end=N+1;
for (int i = 0; i < M; i++) {
String[] strings=ins.readLine().split(" ");
int temp=Integer.parseInt(strings[1]);
//值对应的是temp，下标对应的是temp-1
if(strings[0].equals("L")){
nums[temp-1].power=start;
start--;
}else {
nums[temp-1].power=end;
end++;
}
}
Arrays.sort(nums);
for (int i = 0; i < N; i++) {
out.print(nums[i].value+" ");
}
out.flush();
}
}
思路：
- （1）首先我们对每一组数据看成一个对象，里面有两个元素一个是power即权值，一个是value即它的真实值，初始化时power等于value的大小
- （2）我们自定义一个类，封装这两个属性，并且对其进行重写其排序方法，让其按照power的值来进行排序
- （3）关于权值power，如果左移我们让其的power等于（start）并且对start进行一次减减操作，保证下一次左移的数据被赋上的权值更小，权值越小越先输出（即靠左）
- （4）同理，如果右移我们让其power=（end），并且对end进行加加操作，保证下一次右移的数据其被赋上的权值更大，权值越大越后输出（即靠右）
- （5）对于没有操作的数据，其权值就为原来的大小即value值，将其按value的大小顺序输出
3531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
