算法题模拟

1.P1089 [NOIP 2004 提高组] 津津的储蓄计划

题目描述

津津的零花钱一直都是自己管理。每个月的月初妈妈给津津 $300$ 元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。

为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上 $20\%$ 还给津津。因此津津制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于 $100$ 元或恰好 $100$ 元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。

例如 $11$月初津津手中还有 $83$ 元，妈妈给了津津 $300$ 元。津津预计$11$月的花销是 $180$ 元，那么她就会在妈妈那里存 $200$ 元，自己留下 $183$ 元。到了 $11$ 月月末，津津手中会剩下 $3$ 元钱。

津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。

现在请你根据 $2004$ 年 $1$ 月到 $12$ 月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到 $2004$ 年年末，妈妈将津津平常存的钱加上 $20\%$ 还给津津之后，津津手中会有多少钱。

输入格式

$12$ 行数据，每行包含一个小于 $350$ 的非负整数，分别表示 $1$ 月到 $12$ 月津津的预算。

输出格式

一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出 $-X$，$X$ 表示出现这种情况的第一个月；否则输出到 $2004$ 年年末津津手中会有多少钱。

注意，洛谷不需要进行文件输入输出，而是标准输入输出。

输入输出样例 #1

输入 #1

290
230
280
200
300
170
340
50 
90 
80 
200
60 

输出 #1

-7 

输入输出样例 #2

输入 #2

290 
230 
280 
200 
300 
170 
330 
50 
90 
80 
200 
60 

输出 #2

1580

题解

按题目意思即可

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int[] a=new int[12];
            for(int i=0;i<12;i++)
                {
                    a[i]=scan.nextInt();
                }
            int cnt=300;
            int r=0;
            int m=0;
            for(int i=0;i<12;i++)
                {
                    if(cnt<a[i])
                    {
                        System.out.print("-"+(i+1));
                        return;
                    }
                    r=cnt-a[i];
                    while(r/100!=0)
                        {
                            r=r-100;
                            m=m+100;
                        }
                    cnt=r+300;
                }
            System.out.print((int)(m*1.2)+r);
        }
    }

2.P1152 欢乐的跳

题目描述

一个 $n$ 个元素的整数数组，如果数组两个连续元素之间差的绝对值包括了 $[1,n-1]$ 之间的所有整数，则称之符合“欢乐的跳”，如数组 $\{1,4,2,3\}$ 符合“欢乐的跳”，因为差的绝对值分别为：$3,2,1$。

给定一个数组，你的任务是判断该数组是否符合“欢乐的跳”。

输入格式

每组测试数据第一行以一个整数 $n(1 \le n \le 1000)$ 开始，接下来 $n$ 个空格隔开的在 $[-10^8,10^8]$ 之间的整数。

输出格式

对于每组测试数据，输出一行若该数组符合“欢乐的跳”则输出 Jolly，否则输出 Not jolly。

输入输出样例 #1

输入 #1

4 1 4 2 3

输出 #1

Jolly

输入输出样例 #2

输入 #2

5 1 4 2 -1 6

输出 #2

Not jolly

说明/提示

$1 \le n \le 1000$

题解

将相邻的差值计算出并存储，将其排序，逐个比对

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int n=scan.nextInt();
            int[] a=new int[n];
            for(int i=0;i<n;i++)
                {
                    a[i]=scan.nextInt();
                }
            int[] v=new int[n-1];
            for(int i=0;i<n-1;i++)
                {
                    v[i]=Math.abs(a[i]-a[i+1]);
                }
            Arrays.sort(v);
            for(int i=0;i<n-1;i++)
                {
                    if(v[i]!=i+1)
                    {
                        System.out.print("Not jolly");
                        return;
                    }
                }
            System.out.print("Jolly");
            
        }
    }

3.P1307 [NOIP 2011 普及组] 数字反转

题目描述

给定一个整数 $N$，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例 2）。

输入格式

一个整数 $N$。

输出格式

一个整数，表示反转后的新数。

输入输出样例 #1

输入 #1

123

输出 #1

321

输入输出样例 #2

输入 #2

-380

输出 #2

-83

说明/提示

【数据范围】

$-1,000,000,000\leq N\leq 1,000,000,000 $。

noip2011 普及组第一题

题解

要判断末尾为0的情况，然后依次取余存到String Builder中即可，注意负数要先取绝对值

java里也有可以直接翻转的

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int N=scan.nextInt();
            StringBuilder sb=new StringBuilder();
            if(N==0)
            {
                System.out.print(0);
                return;
            }
            if(N<0)
            {
                sb.append('-');
                N=Math.abs(N);
            }
            int a=N%10;
            while(a==0)
                {
                    N=N/10;
                    a=N%10;
                }
            sb.append(a);
            N=N/10;
            while(N!=0)
                {
                    int t=N%10;
                    sb.append(t);
                    N=N/10;
                }
            System.out.print(sb.toString());
        }
    }

/*public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        // 将数据存入
        StringBuffer sb=new StringBuffer(br.readLine().trim());
        sb.reverse();   // 反转
        //负号跑到最后
        if(sb.charAt(sb.length()-1)=='-'){
            // 删除负号并且在头插入负号
            sb.delete(sb.length()-1, sb.length());
            sb.insert(0, '-');

        }
        System.out.println(Integer.parseInt(sb.toString()));
    }
*/

4.P8627 [蓝桥杯 2015 省 A] 饮料换购

题目描述

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊 C 型饮料，凭 $3$ 个瓶盖可以再换一瓶 C 型饮料，并且可以一直循环下去(但不允许暂借或赊账)。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的 $n$ 瓶饮料，最后他一共能喝到多少瓶饮料。

输入格式

一个整数 $n$，表示开始购买的饮料数量。（$0<n<10000$）

输出格式

一个整数，表示实际得到的饮料数。

输入输出样例 #1

输入 #1

100

输出 #1

149

输入输出样例 #2

输入 #2

101

输出 #2

151

说明/提示

2015 年蓝桥杯省赛 A 组 H 题。

题解

模拟

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int n=scan.nextInt();
            int ans=0;
            int cnt=0;
            while(n!=0)
                {
                    n--;
                    ans++;
                    cnt++;
                    if(cnt==3)
                    {
                        n++;
                        cnt=0;
                    }
                }
            System.out.print(ans);
        }
    }

5.P10985 [蓝桥杯 2023 国 Python A/Java A] 整数变换

题目背景

Python 选手建议使用 PyPy3 提交本题。

题目描述

小蓝有一个整数 $n$。每分钟，小蓝的数都会发生变化，变为上一分钟的数减去上一分钟的数的各个数位和。

例如，如果小蓝开始时的数为 $23$，则下一分钟变为 $23 - (2 + 3) = 18$，再下一分钟变为 $18 - (1 + 8) = 9$，再下一分钟变为 $9 - 9 = 0$，共经过了 $3$ 分钟变为 $0$。

给定一个正整数，请问这个数多少分钟后变为 $0$。

输入格式

输入一行包含一个整数 $n$。

输出格式

输出一个整数，表示答案。

输入输出样例 #1

输入 #1

23

输出 #1

3

说明/提示

对于 $30\%$ 的评测用例，$1 \le n \le 1000$；

对于 $60\%$ 的评测用例，$1 \le n \le 10^6$；

对于所有评测用例，$1 \le n \le 10^9$。

题解

写一个求数位和的函数，然后在循环中调用

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int n=scan.nextInt();
            int ans=0;
            int nn=1;
            while(nn>0)
                {
                    nn=n-sum(n);
                    n=nn;
                    ans++;
                }
            System.out.print(ans);
            
        }

        public static int sum(int n)
        {
            int sum=0;
            while(n!=0)
                {
                    sum=sum+n%10;
                    n=n/10;
                }
            return sum;
        }
    }

6.P12172 [蓝桥杯 2025 省 Python B] LQ 图形

题目背景

本站蓝桥杯 2025 省赛测试数据均为洛谷自造，与官方数据可能存在差异，仅供学习参考。

题目描述

小蓝要为蓝桥画一个图形。由于小蓝的画图能力有限，他准备用大写字母 Q 画一个 L 形状的字符画。他希望 L 的粗细正好是 $w$ 个字符宽，竖的笔划伸出 $h$ 高（因此图形总共 $h + w$ 高），横的笔划伸出 $v$ 宽（因此图形总共 $v + w$ 宽），要求每个笔划方方正正不能有多余内容。

例如，当 $w = 2, h = 3, v = 4$ 时，图形如下所示：

QQ
QQ
QQ
QQQQQQ
QQQQQQ

给定 $w, h, v$，请帮助小蓝画出这个图形。

输入格式

输入的第一行包含三个正整数 $w, h, v$，相邻整数之间使用一个空格分隔。

输出格式

输出若干行，表示对应的图形。

输入输出样例 #1

输入 #1

3 4 5

输出 #1

QQQ
QQQ
QQQ
QQQ
QQQQQQQQ
QQQQQQQQ
QQQQQQQQ

说明/提示

评测用例规模与约定

对于 $30\%$ 的评测用例，$w = 1$，$1 \leq h, v \leq 20$；

对于 $60\%$ 的评测用例，$1 \leq w, h, v \leq 20$；

对于所有评测用例，$1 \leq w, h, v \leq 100$。

题解

ez

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int w=scan.nextInt();
            int h=scan.nextInt();
            int v=scan.nextInt();
            for(int i=0;i<h;i++)
                {
                    for(int j=0;j<w;j++)
                        {
                            System.out.print('Q');
                        }
                    System.out.println();
                }
            for(int i=0;i<w;i++)
                {
                    for(int j=0;j<v+w;j++)
                        {
                            System.out.print('Q');
                        }
                    System.out.println();
                }
        }
    }

7.P10385 [蓝桥杯 2024 省 A] 艺术与篮球

题目描述

小蓝出生在一个艺术与运动并重的家庭中。
妈妈是位书法家，她希望小蓝能通过练习书法，继承她的艺术天赋，并练就一手好字。爸爸是一名篮球教练，他希望小蓝能通过篮球锻炼身体，培养运动的激情和团队合作的精神。
为了既满足妈妈的期望，又不辜负爸爸的心意，小蓝决定根据日期的笔画数来安排自己的练习。首先，他会将当天的日期按照 YYYYMMDD 的格式转换成一个 $8$ 位数，然后将这 $8$ 位数对应到汉字上，计算这些汉字的总笔画数。如果总笔画数超过 $50$，他就去练习篮球；如果总笔画数不超过 $50$，他就去练习书法。
例如，在 $2024$ 年 $1$ 月 $1$ 日这天，日期可表示为一个 $8$ 位数字 $20240101$，其转换为汉字是“二零二四零一零一”。日期的总笔画数为 $2 + 13 + 2 + 5 + 13 + 1 + 13 + 1 = 50$，因此在这天，小蓝会去练习书法。
以下是汉字的笔画数对照表：

汉字	笔画数	汉字	笔画数
零	$13 $	五	$4$
一	$1$	六	$4$
二	$2$	七	$2$
三	$3$	八	$2$
四	$5$	九	$2$

现在，请你帮助小蓝统计一下，在 $2000$ 年 $1$ 月 $1$ 日到 $2024$ 年 $4$ 月 $13$ 日这段时间内，小蓝有多少天是在练习篮球？

输入格式

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

输出格式

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

题解

直接计算

代码

import java.util.*;

public class Main
    {
        static int[] month={31,28,31,30,31,30,31,31,30,31,30,31};
        static int[] b={13,1,2,3,5,4,4,2,2,2};
        public static void main(String[] args)
        {
            /*int p=0;
            for(int i=2000;i<=2024;i++)
                {
                    loopm:for(int j=1;j<=12;j++)
                        {
                            if(i==2024&&j==5)
                            {
                                break loopm;
                            }
                            if(j==2)
                            {
                                if((i%4==0&&i%100!=0)||(i%400==0))
                                {
                                    loopd1:for(int k=1;k<=29;k++)
                                        {
                                            if(i==2024&&j==4&&k==14)
                                            {
                                                break loopd1;
                                            }
                                            if(sum(i)+sum(j)+sum(k)>50)
                                            {
                                                p++;
                                            }
                                        }
                                }
                                else
                                {
                                    loopd2:for(int k=1;k<=28;k++)
                                        {
                                            if(i==2024&&j==4&&k==14)
                                            {
                                                break loopd2;
                                            }
                                            if(sum(i)+sum(j)+sum(k)>50)
                                            {
                                                p++;
                                            }
                                        }
                                }
                            }
                            else
                            {
                                loopd3:for(int k=1;k<=month[j-1];k++)
                                    {
                                        if(i==2024&&j==4&&k==14)
                                        {
                                            break loopd3;
                                        }
                                        if(sum(i)+sum(j)+sum(k)>50)
                                        {
                                            p++;
                                        }
                                    }
                            }
                            
                        }
                }
            System.out.print(p);*/
            System.out.print(3228);
        }

        /*public static int sum(int n)
        {
            int sum=0;
            if(n<10)
            {
                sum=sum+13;
            }
            while(n!=0)
                {
                    sum=sum+b[(n%10)];
                    n=n/10;
                }
            return sum;
        }*/
    }

8.P12164 [蓝桥杯 2025 省 C/Python A] 2025 图形

题目背景

本站蓝桥杯 2025 省赛测试数据均为洛谷自造，与官方数据可能存在差异，仅供学习参考。

题目描述

小蓝要画一个 $2025$ 图形。图形的形状为一个 $h \times w$ 的矩形，其中 $h$ 表示图形的高，$w$ 表示图形的宽。当 $h = 5, w = 10$ 时，图形如下所示：

2025202520
0252025202
2520252025
5202520252
2025202520

图形的规律是：第一行用 $2025$ 重复填入，第二行开始，每行向左移动一个字符，用 $2025$ 重复填入。给定 $h, w$，请输出对应的图形。

输入格式

输入的第一行包含两个正整数 $h, w$，用一个空格分隔。

输出格式

输出若干行，表示对应的图形。

输入输出样例 #1

输入 #1

4 5

输出 #1

20252
02520
25202
52025

说明/提示

评测用例规模与约定

• 对于 $30\%$ 的评测用例，$h = 1$，$1 \leq w \leq 20$；

• 对于 $60\%$ 的评测用例，$1 \leq h, w \leq 20$；

• 对于所有评测用例，$1 \leq h, w \leq 100$。

题解

是向左移一位不是继续填充

代码

import java.util.*;

public class Main
    {
        static int[] y={2,0,2,5};
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int h=scan.nextInt();
            int w=scan.nextInt();
            int s=0;
            for(int i=0;i<h;i++)
                {
                    s=i%4;
                    StringBuilder sb=new StringBuilder();
                    for(int j=0;j<w;j++)
                        {
                            sb.append(y[s]);
                            s++;
                            if(s==4)
                            {
                                s=0;
                            }
                        }
                    System.out.println(sb.toString());
                }
        }
    }

9.P12365 [蓝桥杯 2022 省 Python B] 纸张尺寸

题目描述

在 ISO 国际标准中定义了 A0 纸张的大小为 $1189 \ \text{mm} \times 841\ \text{mm}$, 将 A0 纸沿长边对折后为 A1 纸, 大小为 $841\ \text{mm} \times 594 \ \text{mm}$, 在对折的过程中长度直接取下整 (实际裁剪时可能有损耗)。将 A1 纸沿长边对折后为 A2 纸, 依此类推。

输入纸张的名称, 请输出纸张的大小。

输入格式

输入一行包含一个字符串表示纸张的名称, 该名称一定是 A0、A1、A2、A3、A4、A5、A6、A7、A8、A9 之一。

输出格式

输出两行, 每行包含一个整数, 依次表示长边和短边的长度。

输入输出样例 #1

输入 #1

A0

输出 #1

1189
841

输入输出样例 #2

输入 #2

A1

输出 #2

841
594

题解

按题意即可，其中要用Math.floor向下取整并且取整

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            String line=scan.next();
            int n=line.charAt(1)-'0';
            int l=1189;
            int w=841;
            if(n==0)
            {
                System.out.println(1189);
                System.out.print(841);
                return;
            }
            for(int i=0;i<n;i++)
                {
                    int t=w;
                    w=(int)Math.floor(l/2);
                    l=t;
                }
            System.out.println(l);
            System.out.print(w);
            
        }
    }

10.P12170 [蓝桥杯 2025 省 Python B] 攻击次数

题目背景

本站蓝桥杯 2025 省赛测试数据均为洛谷自造，与官方数据可能存在差异，仅供学习参考。

【2025-04-13 13:05】本题题目有歧义，根据多数用户理解我们修改了数据，目前洛谷数据判定为：$3$ 个英雄只要能攻击就一起攻击。如果 $3$ 个英雄只能选择能攻击的中攻击最高的，答案为 $181$。

题目描述

小蓝正在玩一个游戏，游戏中小蓝要控制自己的三个英雄来攻击一个敌人。敌人初始的血量为 $2025$。

小蓝的第一个英雄攻击力恒定，每回合攻击 $5$ 的血量。

小蓝的第二个英雄拥有一些技能，奇数回合触发，攻击 $15$ 的血量，偶数回合攻击 $2$ 的血量。

小蓝的第三个英雄拥有一些道具，当回合数除以 $3$ 的余数为 $1$ 时攻击 $2$ 的血量；当回合数除以 $3$ 的余数为 $2$ 时攻击 $10$ 的血量；当回合数除以 $3$ 的余数为 $0$ 时攻击 $7$ 的血量。

游戏从第 $1$ 回合开始。不考虑敌人对小蓝英雄的攻击，敌人的血量也仅受攻击的影响。如果敌人的血量小于等于零，则游戏结束。

请问到第几回合游戏结束？

输入格式

无

输出格式

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

题解

ez

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            int hp=2025;
            int hh=0;
            while(hp>0)
                {
                    hp=hp-5;
                    if(hh%2==0)
                    {
                        hp=hp-2;
                    }
                    else
                    {
                        hp=hp-15;
                    }
                    if(hh%3==1)
                    {
                        hp=hp-2;
                    }
                    else if(hh%3==2)
                    {
                        hp=hp-10;
                    }
                    else
                    {
                        hp=hp-7;
                    }
                    hh++;
                }
            System.out.print(hh);
        }
    }

11.P8722 [蓝桥杯 2020 省 AB3] 日期识别

题目描述

小蓝要处理非常多的数据, 其中有一些数据是日期。

在小蓝处理的日期中有两种常用的形式：英文形式和数字形式。

英文形式采用每个月的英文的前三个字母作为月份标识，后面跟两位数字表示日期，月份标识第一个字母大写，后两个字母小写, 日期小于 $10$ 时要补前导 $0$。$1$ 月到 $12$ 月英文的前三个字母分别是 Jan、Feb、Mar、Apr、May、Jun、Jul、Aug、Sep、Oct、Nov、Dec。

数字形式直接用两个整数表达，中间用一个空格分隔，两个整数都不写前 导 0。其中月份用 $1$ 至 $12$ 分别表示 $1$ 月到 $12$ 月。

输入一个日期的英文形式, 请输出它的数字形式。

输入格式

输入一个日期的英文形式。

输出格式

输出一行包含两个整数，分别表示日期的月和日。

输入输出样例 #1

输入 #1

Feb08

输出 #1

2 8

输入输出样例 #2

输入 #2

Oct18

输出 #2

10 18

说明/提示

蓝桥杯 2020 第三轮省赛 AB 组 F 题。

题解

if这一块

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            String line=scan.next();
            char[] n=line.toCharArray();
            if(n[0]=='J')
            {
                if(n[1]=='a')
                {
                    System.out.print(1+" ");
                }
                else
                {
                    if(n[2]=='n')
                    {
                        System.out.print(6+" ");
                    }
                    else
                    {
                        System.out.print(7+" ");
                    }
                }
            }
            if(n[0]=='F')
            {
                System.out.print(2+" ");
            }
            if(n[0]=='M')
            {
                if(n[2]=='r')
                {
                    System.out.print(3+" ");
                }
                else
                {
                    System.out.print(5+" ");
                }
            }
            if(n[0]=='A')
            {
                if(n[2]=='r')
                {
                    System.out.print(4+" ");
                }
                else
                {
                    System.out.print(8+" ");
                }
            }
            if(n[0]=='S')
            {
                System.out.print(9+" ");
            }
            if(n[0]=='O')
            {
                System.out.print(10+" ");
            }
            if(n[0]=='N')
            {
                System.out.print(11+" ");
            }
            if(n[0]=='D')
            {
                System.out.print(12+" ");
            }

            if(n[3]=='0')
            {
                System.out.print(n[4]);
            }
            else
            {
                System.out.print(n[3]);
                System.out.print(n[4]);
            }
        }
    }

12.P10899 [蓝桥杯 2024 省 C] 劲舞团

题目描述

小蓝最近迷上了一款名为“劲舞团”的游戏，具体来说，只要按照游戏中给出的键位提示依次按出对应的键位，游戏人物便可以跟随节奏跳舞。对于连续的 $K$ 次正确敲击，如果任意连续的两次敲击间间隔时间都小于等于 $1\texttt s$，那么我们称这是一次 $K$ 连击。现在给出一局小蓝的游戏记录文件，log.txt 中记录了 $N$ 条记录，每条记录有三个字段，依次为正确的敲击字符、小蓝打出的字符、打出字符的时间对应的毫秒时间戳。现在请你计算下最长的 $K$ 连击是多少，你只需要输出 $K$ 的值。

输入格式

为了方便评测，输入数据已替换为 log.txt。在洛谷评测时，你可以从标准输入读取 log.txt，也可以从下发文件中下载。

输出格式

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

题解

共2000行数据。最终连击数+1

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            char[] r=new char[2000];
            char[] s=new char[2000];
            long[] t=new long[2000];
            for(int i=0;i<2000;i++)
                {
                    r[i]=scan.next().charAt(0);
                    s[i]=scan.next().charAt(0);
                    t[i]=scan.nextLong();
                }
            int ans=0;
            int cnt=0;
            for(int i=1;i<2000;i++)
                {
                    if(r[i]==s[i]&&t[i]-t[i-1]<=1000)
                    {
                        cnt++;
                    }
                    else
                    {
                        ans=Math.max(cnt,ans);
                        cnt=0;
                    }
                }
            System.out.print(ans+1);
        }
    }

13.P8623 [蓝桥杯 2015 省 B] 移动距离

题目描述

X 星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为 $1,2,3, \cdots $ 。

当排满一行时，从下一行相邻的楼往反方向排号。

比如：当小区排号宽度为 $6$ 时，开始情形如下：

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

我们的问题是：已知了两个楼号 $m$ 和 $n$，需要求出它们之间的最短移动距离。（不能斜线方向移动）

输入格式

输入为 $3$ 个整数 $w,m,n$，空格分开，都在 $1$ 到 $10000$ 范围内。

$w$ 为排号宽度，$m,n$ 为待计算的楼号。

输出格式

要求输出一个整数，表示 $m$ 与 $n$ 两楼间最短移动距离。

输入输出样例 #1

输入 #1

6 8 2

输出 #1

4

输入输出样例 #2

输入 #2

4 7 20

输出 #2

5

说明/提示

时限 1 秒, 256M。

蓝桥杯 2015 年省赛 B 组 H 题。

题解

从1开始遍历到最小的一个位置，并且记录当前位置，接着继续遍历到最大的位置。其中单数为正向，偶数为反向

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int w=scan.nextInt();
            int m=scan.nextInt();
            int n=scan.nextInt();

            int x=0;
            int y=1;
            int nx=0;
            int ny=0;
            
            if(n>m)
            {
                int t=m;
                m=n;
                n=t;
            }
            for(int i=1;i<=m;i++)
                {
                    if(y%2==1)
                    {
                        x++;
                        if(x>w)
                        {
                            x=w;
                            y++;
                        }
                    }
                    else
                    {
                        x--;
                        if(x<1)
                        {
                            x=1;
                            y++;
                        }
                    }
                    if(i==n)
                    {
                        nx=x;
                        ny=y;
                    }
                }
            System.out.print(Math.abs(nx-x)+Math.abs(ny-y));
        }
    }

14.P8665 [蓝桥杯 2018 省 A] 航班时间

题目描述

小 h 前往美国参加了蓝桥杯国际赛。小 h 的女朋友发现小 h 上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。

小 h 对超音速飞行感到十分恐惧。仔细观察后发现飞机的起降时间都是当地时间。由于北京和美国东部有 $12$ 小时时差，故飞机总共需要 $14$ 小时的飞行时间。

不久后小 h 的女朋友去中东交换。小 h 并不知道中东与北京的时差。但是小 h 得到了女朋友来回航班的起降时间。小 h 想知道女朋友的航班飞行时间是多少。

对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。

输入格式

从标准输入读入数据。

一个输入包含多组数据。

输入第一行为一个正整数 $T$，表示输入数据组数。

每组数据包含两行，第一行为去程的起降时间，第二行为回程的起降时间。

起降时间的格式如下

h1:m1:s1 h2:m2:s2

或

h1:m1:s1 h3:m3:s3 (+1)

或

h1:m1:s1 h4:m4:s4 (+2)

表示该航班在当地时间 h1 时 m1 分 s1 秒起飞，

第一种格式表示在当地时间 当日 h2 时 m2 分 s2 秒降落

第二种格式表示在当地时间 次日 h3 时 m3 分 s3 秒降落。

第三种格式表示在当地时间 第三天 h4 时 m4 分 s4 秒降落。

对于此题目中的所有以 h:m:s 形式给出的时间, 保证（$0\le h\le23$，$0\le m,s\le59$）.

输出格式

输出到标准输出。

对于每一组数据输出一行一个时间 hh:mm:ss，表示飞行时间为 hh 小时 mm 分 ss 秒。

注意，当时间为一位数时，要补齐前导零。如三小时四分五秒应写为 03:04:05。

输入输出样例 #1

输入 #1

3
17:48:19 21:57:24
11:05:18 15:14:23
17:21:07 00:31:46 (+1)
23:02:41 16:13:20 (+1)
10:19:19 20:41:24
22:19:04 16:41:09 (+1)

输出 #1

04:09:05
12:10:39
14:22:05

说明/提示

保证输入时间合法，飞行时间不超过 $24$ 小时。

题解

去程时间=飞行时间+时差

回程时间=飞行时间−时差

相加得飞行时间就是$\frac{启程时间+返程时间}2$

主要是数据的获取

代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = Integer.parseInt(sc.nextLine());

        while (T-- > 0) {
            String go = sc.nextLine();    // 去程
            String back = sc.nextLine();  // 回程

            int t1 = getTime(go);
            int t2 = getTime(back);

            int ans = (t1 + t2) / 2;

            int h = ans / 3600;
            int m = (ans % 3600) / 60;
            int s = ans % 60;

            System.out.printf("%02d:%02d:%02d\n", h, m, s);
        }
    }

    static int getTime(String line) {
        String[] parts = line.split(" ");
        int start = toSecond(parts[0]);
        int end = toSecond(parts[1]);

        int day = 0;
        if (parts.length == 3) {
            day = parts[2].charAt(2) - '0';   
        }

        end += day * 24 * 3600;
        return end - start;
    }

    static int toSecond(String time) {
        String[] t = time.split(":");
        int h = Integer.parseInt(t[0]);
        int m = Integer.parseInt(t[1]);
        int s = Integer.parseInt(t[2]);
        return h * 3600 + m * 60 + s;
    }
}

15.P8738 [蓝桥杯 2020 国 C] 天干地支

题目描述

古代中国使用天干地支来记录当前的年份。

天干一共有十个，分别为：甲（jiǎ）、乙（yǐ）、丙（bǐng）、丁（dīng）、戊（wù）、己（jǐ）、庚（gēng）、辛（xīn）、壬（rén）、癸（guǐ）。

地支一共有十二个，分别为：子（zǐ）、丑（chǒu）、寅（yín）、卯（mǎo）、辰（chén）、巳（sì）、午（wǔ）、未（wèi）、申（shēn）、酉（yǒu）、戌（xū）、亥（hài）。

将天干和地支连起来，就组成了一个天干地支的年份，例如：甲子。2020 年是庚子年。

每过一年，天干和地支都会移动到下一个。例如 2021 年是辛丑年。

每过 60 年，天干会循环 6 轮，地支会循环 5 轮，所以天干地支纪年每 60年轮回一次。例如 1900 年，1960 年，2020 年都是庚子年。

给定一个公元纪年的年份，请输出这一年的天干地支年份。

输入格式

输入一行包含一个正整数，表示公元年份。

输出格式

输出一个拼音，表示天干地支的年份，天干和地支都用小写拼音表示（不表示声调），之间不要加入任何多余的字符。

输入输出样例 #1

输入 #1

2020

输出 #1

gengzi

说明/提示

对于所有评测用例，输入的公元年份为不超过 $9999$ 的正整数。

蓝桥杯 2020 年国赛 C 组 F 题。

题解

把数字控制在2020到2080中，然后循环即可

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            String[] t={"jia","yi","bing","ding","wu","ji","geng","xin","ren","gui"};
            String[] d={"zi","chou","yin","mao","chen","si","wu","wei","shen","you","xu","hai"};
            Scanner scan=new Scanner(System.in);
            int y=scan.nextInt();
            while(y<2020)
                {
                    y=y+60;
                }
            while(y>2080)
                {
                    y=y-60;
                }
            int tt=6;
            int dd=0;
            for(int i=0;i<y-2020;i++)
                {
                    tt++;
                    dd++;
                    if(tt==10)
                    {
                        tt=0;
                    }
                    if(dd==12)
                    {
                        dd=0;
                    }
                }
            System.out.print(t[tt]+d[dd]);
        }
    }

16.P8748 [蓝桥杯 2021 省 B] 时间显示

题目描述

小蓝要和朋友合作开发一个时间显示的网站。在服务器上，朋友已经获取了当前的时间，用一个整数表示，值为从 1970 年 1 月 1 日 00:00:00 到当前时刻经过的毫秒数。

现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要 显示出时分秒即可，毫秒也不用显示，直接舍去即可。

给定一个用整数表示的时间，请将这个时间对应的时分秒输出。

输入格式

输入一行包含一个整数，表示时间。

输出格式

输出时分秒表示的当前时间, 格式形如 $\mathrm{HH}: \mathrm{MM}: \mathrm{SS}$, 其中 $\mathrm{HH}$ 表示时, 值 为 $0$ 到 $23, \mathrm{MM}$ 表示分。值为 $0$ 到 $59$。$\mathrm{SS}$ 表示秒, 值为 $0$ 到 $59$。时、分、秒不足两位时补前导 0 。

输入输出样例 #1

输入 #1

46800999

输出 #1

13:00:00

输入输出样例 #2

输入 #2

1618708103123

输出 #2

01:08:23

说明/提示

对于所有评测用例, 给定的时间为不超过 $10^{18}$ 的正整数。

蓝桥杯 2021 第一轮省赛 B 组 F 题。

题解

1s等于1000ms，所以先除1000，然后分别算出小时，分钟，秒即可，最后要补0

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            long t=scan.nextLong();
            t=t/1000;
            System.out.printf("%02d:%02d:%02d",t%(24*60*60)/(60*60),t%(60*60)/60,t%60);
        }
    }

17.P9421 [蓝桥杯 2023 国 B] 班级活动

题目描述

小明的老师准备组织一次班级活动。班上一共有 $n$ 名（$n$ 为偶数）同学，老师想把所有的同学进行分组，每两名同学一组。为了公平，老师给每名同学随机分配了一个 $n$ 以内的正整数作为 id，第 $i$ 名同学的 id 为 $a_i$。

老师希望通过更改若干名同学的 id 使得对于任意一名同学 $i$，有且仅有另一名同学 $j$ 的 id 与其相同（$a_i = a_j$）。请问老师最少需要更改多少名同学的 id？

输入格式

输入共 $2$ 行。

第一行为一个正整数 $n$。

第二行为 $n$ 个由空格隔开的整数 $a_1, a_2, \cdots, a_n$。

输出格式

输出共 $1$ 行，一个整数。

输入输出样例 #1

输入 #1

4
1 2 2 3

输出 #1

1

说明/提示

样例说明

仅需要把 $a_1$ 改为 $3$ 或者把 $a_4$ 改为 $1$ 即可。

评测用例规模与约定

• 对于 $20\%$ 的数据，保证 $n \le 10^3$。

• 对于 $100\%$ 的数据，保证 $n \le 10^5$。

第十四届蓝桥杯大赛软件赛决赛 C/C++ 大学 B 组 C 题

题解

分别统计缺的和多的总人数，如果多的人数多，直接输出人数。如果是缺的人数多，则输出$sum1+\frac{sum2-sum1}2$

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int n=scan.nextInt();
            int[] a=new int[n];
            int[] cnt=new int[n+1];
            for(int i=0;i<n;i++)
                {
                    a[i]=scan.nextInt();
                    cnt[a[i]]++;
                }
            int sum1=0;
            int sum2=0;
            for(int i=1;i<n+1;i++)
                {
                    if(cnt[i]>2)
                    {
                        sum1=sum1+cnt[i]-2;
                    }
                    if(cnt[i]<2)
                    {
                        sum2=sum2+cnt[i];
                    }
                    
                }
            if(sum1>sum2)
            {
                System.out.print(sum1);
            }
            else
            {
                System.out.print(sum1+(sum2-sum1)/2);
            }
            
        }
    }

18.P10906 [蓝桥杯 2024 国 B] 合法密码

题目描述

小蓝正在开发自己的 OJ 网站。他要求网站用户的密码必须符合以下条件：

1. 长度大于等于 $8$ 个字符，小于等于 $16$ 个字符。

2. 必须包含至少 $1$ 个数字字符和至少 $1$ 个符号字符。

例如 lanqiao2024!、+-*/0601、8((>w<))8 都是合法的密码。

而 12345678、##**##**、abc0!#、lanqiao20240601!? 都不是合法的密码。

请你计算以下的字符串中，有多少个子串可以当作合法密码？只要两个子串的开头字符和末尾字符在原串中的位置不同，就算作不同的子串。

字符串为：

kfdhtshmrw4nxg#f44ehlbn33ccto#mwfn2waebry#3qd1ubwyhcyuavuajb#vyecsycuzsmwp31ipzah#catatja3kaqbcss2th

输入格式

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

输出格式

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

题解

三层循环，主要是Character.isDigit判断数字，!Character.isLetterOrDigit判断非数字和字母

代码

import java.util.*;

public class Main
    {
        public static void main(String[] args)
        {
            String line="kfdhtshmrw4nxg#f44ehlbn33ccto#mwfn2waebry#3qd1ubwyhcyuavuajb#vyecsycuzsmwp31ipzah#catatja3kaqbcss2th";
            char[] str=line.toCharArray();
            int ans=0;
            for(int i=0;i<str.length;i++)
                {
                    for(int j=i;j<str.length;j++)
                        {
                            if(j-i+1<=16&&j-i+1>=8)
                            {
                                int d=0;
                                int c=0;
                                for(int k=i;k<=j;k++)
                                    {
                                        if(Character.isDigit(str[k]))
                                        {
                                            d=1;
                                        }
                                        if (!Character.isLetterOrDigit(str[k])) 
                                        {
                                            c=1;
                                        }
                                    }
                                if(d==1&&c==1)
                                {
                                    ans++;
                                }
                            }
                        }
                }
            System.out.print(ans);
        }
    }

19.P11001 [蓝桥杯 2024 省 Python B] 连连看

题目描述

小蓝正在和朋友们玩一种新的连连看游戏。在一个 $n \times m$ 的矩形网格中，每个格子中都有一个整数，第 $i$ 行第 $j$ 列上的整数为 $A_{i,j}$。玩家需要在这个网格中寻找一对格子 $(a,b)$ 和 $(c,d)$ 使得这两个格子中的整数 $A_{a,b}$ 和 $A_{c,d}$ 相等，且它们的位置满足 $|a-c| = |b-d| > 0$。请问在这个 $n \times m$ 的矩形网格中有多少对这样的格子满足条件。

输入格式

输入的第一行包含两个正整数 $n$ 和 $m$，用一个空格分隔。

接下来是 $n$ 行，第 $i$ 行包含 $m$ 个正整数 $A_{i,1}, A_{i,2}, \dots, A_{i,m}$，相邻整数之间用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。

输入输出样例 #1

输入 #1

3 2 
1 2 
2 3 
3 2

输出 #1

6

说明/提示

一共有以下 6 对格子：$(1,2)−(2,1)$，$(2,2)−(3,1)$，$(2,1)−(3,2)$，$(2,1)−(1,2)$，$(3,1)−(2,2)$，$(3,2)−(2,1)$。

数据范围

对于 $20\%$ 的评测用例，$1 \leq n, m \leq 50$；

对于所有评测用例，$1 \leq n, m \leq 1000$，$1 \leq A_{i,j} \leq 1000$。

题解

统计对角线上相等的

代码

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        
        int n = fs.nextInt();
        int m = fs.nextInt();
        
        int[][] a = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                a[i][j] = fs.nextInt();
            }
        }
        
        long ans = 0;

        // 统计 \ 对角线：i - j = d
        for (int d = -(m - 1); d <= n - 1; d++) {
            int[] cnt = new int[1001];
            for (int i = 0; i < n; i++) {
                int j = i - d;
                if (j >= 0 && j < m) {
                    cnt[a[i][j]]++;
                }
            }
            for (int x = 1; x <= 1000; x++) {
                ans += (long) cnt[x] * (cnt[x] - 1);
            }
        }

        // 统计 / 对角线：i + j = s
        for (int s = 0; s <= n + m - 2; s++) {
            int[] cnt = new int[1001];
            for (int i = 0; i < n; i++) {
                int j = s - i;
                if (j >= 0 && j < m) {
                    cnt[a[i][j]]++;
                }
            }
            for (int x = 1; x <= 1000; x++) {
                ans += (long) cnt[x] * (cnt[x] - 1);
            }
        }

        System.out.println(ans);
    }

    // 快读
    static class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr = 0, len = 0;

        FastScanner(InputStream is) {
            in = is;
        }

        private int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }

        int nextInt() throws IOException {
            int c;
            do {
                c = read();
            } while (c <= ' ');

            int sign = 1;
            if (c == '-') {
                sign = -1;
                c = read();
            }

            int val = 0;
            while (c > ' ') {
                val = val * 10 + c - '0';
                c = read();
            }
            return val * sign;
        }
    }
}

20.P12340 [蓝桥杯 2025 省 AB/Python B 第二场] 旗帜

题目描述

小蓝要画一个 LANQIAO 图形，并把这个图形做成一个旗帜。图形的形状为一个 $h \times w$ 的矩形，其中 $h$ 表示图形的高，$w$ 表示图形的宽。当 $h = 5, w = 10$ 时，图形如下所示：

LANQIAOLAN
ANQIAOLANQ
NQIAOLANQI
QIAOLANQIA
IAOLANQIAO

图形的规律是：第一行用 LANQIAO 重复填入，第二行开始，每行向左移动一个字符，用 LANQIAO 重复填入。

小蓝需要把图形中的每个字母都剪出来，以粘贴到旗帜上，他想知道，给定图形的高和宽，图形中有多少个 A。

输入格式

输入的第一行包含两个正整数 $h, w$，用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。

输入输出样例 #1

输入 #1

5 10

输出 #1

14

说明/提示

评测用例规模与约定

• 对于 $30\%$ 的评测用例，$h = 1$，$1 \leq w \leq 20$；

• 对于 $60\%$ 的评测用例，$1 \leq h, w \leq 20$；

• 对于所有评测用例，$1 \leq h, w \leq 100$。

题解

和之前的题目相似只是不用输出图形了，只需要统计出现A的次数

代码

import java.util.*;

public class Main
    {
        static char[] y={'L','A','N','Q','I','A','O'};
        public static void main(String[] args)
        {
            Scanner scan=new Scanner(System.in);
            int h=scan.nextInt();
            int w=scan.nextInt();
            int s=0;
            int ans=0;
            for(int i=0;i<h;i++)
                {
                    s=i%7;
                    for(int j=0;j<w;j++)
                        {
                            if(y[s]=='A')
                            {
                                ans++;
                            }
                            s++;
                            if(s==7)
                            {
                                s=0;
                            }
                        }
                }
            System.out.println(ans);
        }
    }