【2023】蓝桥杯练习
单词分析
题目描述
小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组 成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。
现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这 个字母出现的次数。
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
char arr[]=s.toCharArray();
ArrayList arrayList = new ArrayList();
HashSet hashSet = new HashSet();
for (int i = 0; i < arr.length; i++) {
arrayList.add(arr[i]);
hashSet.add(arr[i]);
}
int max=0;
Object max_char=' ';
int num=0;
Object num_char=' ';
for (Object O:hashSet) {
num=Collections.frequency(arrayList,O);
num_char=O;
if (num>max){
max=num;
max_char=num_char;
}
}
System.out.println(max_char);
System.out.println(max);
scanner.close();
}
}修剪灌木
思路：
间隔多少天就张多高
找最大的间隔天数。max{（第二趟的天数序号-第一趟的天数序号），（第三·趟的天数序号-第二趟的）}
import java.util.Scanner;
public class xiujianguanmu {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N=scanner.nextInt();
int arr[]=new int[N];
for (int i = 0; i < N; i++) {
arr[i]=Math.max(2*N-2*(i+1),2*(i+1)-2);
}
for (int i = 0; i < N; i++) {
System.out.println(arr[i]);
}
}
}最大分解
问题描述
给出一个正整数n，求一个和最大的序列a0，a1，a2，……，ap，满足n=a0>a1>a2>……>ap且ai+1是ai的约数，输出a1+a2+……+ap的最大值
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int factor=scanner.nextInt();
ArrayList arr = new ArrayList();
while (true){
factor=max_factor(factor);
arr.add(factor);
if (factor==1){
break;
}
}
int sum=0;
for (int i = 0; i < arr.size(); i++) {
sum=sum+(int)arr.get(i);
}
System.out.println(sum);
scanner.close();
}
public static int max_factor(int a){
int res=-1;
for (int i = a-1; i >=1; i--) {
//res=;
if (a%i==0){
res=i;
break;
}
}
return res;
}
}
礼物（10’代码）
问题描述
JiaoShou在爱琳大陆的旅行完毕，即将回家，为了纪念这次旅行，他决定带回一些礼物给好朋友。
在走出了怪物森林以后，JiaoShou看到了排成一排的N个石子。
这些石子很漂亮，JiaoShou决定以此为礼物。
但是这N个石子被施加了一种特殊的魔法。
如果要取走石子，必须按照以下的规则去取。
每次必须取连续的2*K个石子，并且满足前K个石子的重量和小于等于S，后K个石子的重量和小于等于S。
由于时间紧迫，Jiaoshou只能取一次。
现在JiaoShou找到了聪明的你，问他最多可以带走多少个石子。
package lanqiaobei_;
import java.util.Scanner;
//我不会做QAQ
public class liwu2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//输入
int N=scanner.nextInt();
long s=scanner.nextLong();
long a[] =new long[N];
long arr_sum[]=new long[N+1];
arr_sum[0]=0;
for (int i = 0; i < N; i++) {
a[i]=scanner.nextLong();
arr_sum[i+1]=arr_sum[i]+a[i];
}
//...1
int flage=1;
int k=1;
long sum_l=0;
long sum_r=0;
//...2
while(true){
sum_l=arr_sum[flage+1]-arr_sum[flage+1-k];
sum_r=arr_sum[flage+k+1]-arr_sum[flage+1];
//sum=sum_l+sum_r;
if (sum_l<=s&&sum_r<=s){//满足条件 k+1 直到步长等于flage
k++;
if (k>flage){//k与flage的约束关系 当前flage对应的k的最大值为k_max=flage
flage++;
}
}
else {//不满足条件，flage右移，k不变
flage++;
}
if (flage+k==N){
break;
}
}
System.out.println(2*k);
}
}
天干地支
题目描述
古代中国使用天干地支来记录当前的年份。
天干一共有十个，分别为：甲（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）。
将天干和地支连起来，就组成了一个天干地支的年份，例如：甲子。
20202020 年是庚子年。
每过一年，天干和地支都会移动到下一个。例如 20212021 年是辛丑年。
每过 6060 年，天干会循环 66 轮，地支会循环 55 轮，所以天干地支纪年每 6060 年轮回一次。例如 19001900 年，19601960 年，20202020 年都是庚子年。
给定一个公元纪年的年份，请输出这一年的天干地支年份。
思路：
直接以2020为标准！！
import java.util.Scanner;
public class Main {
public static void main(String arg[]){
// String a1="庚辛壬癸甲乙丙丁戊己";
//String b1="子丑寅卯辰巳午未申酉戌亥";
String[] tiangan1 = {"geng","xin","ren","gui","jia","yi","bing","ding","wu","ji"};
String dizhi1[]={"zi","chou","yin","mao","chen","si","wu","wei","shen","you","xu","hai"};
String[] tiangan2 = {"geng","ji","wu","ding","bing","yi","jia","gui","ren","xin"};
String dizhi2[]={"zi","hai","xu","you","shen","wei","wu","si","chen","mao","yin","chou"};
//input
Scanner scanner = new Scanner(System.in);
int year=scanner.nextInt();
int flage1=0;
int flage2=0;
int res=0;
if (year>=2020){
res=year-2020;
flage1=res%10;
flage2=res%12;
System.out.println(tiangan1[flage1]+dizhi1[flage2]);
}
else {
res=2020-year;
flage1=res%10;
flage2=res%12;
System.out.println(tiangan2[flage1]+dizhi2[flage2]);
}
scanner.close();
}
}
约数个数
1200000 有多少个约数（只计算正约数）。
做完（7），再看（6），感觉这种写法有点傻。。。
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
//在此输入您的代码...
//1200000=2^7+3+5^5
int two0=1;//约束不能被2整除的情况
int two1=7;//约束能被2整除的情况
int th0=1;//约束不能被3整除的情况
int th1=1;//约束能被3整除的情况
int five0=1;//约束不能被5整除的情况
int five1=5;//约束能被5整除的情况
int a=two1*(th1*(five0+five1));
int b=two1*(th0*(five0+five1));
int c=two0*(th1*(five0+five1));
int d=two0*(th0*(five0+five1));
System.out.println(a+b+c+d);//96
}
}阶乘约数
问题描述
请问 100!（100 的阶乘）有多少个正约数。
思路：
100！=1 * 2 * ... * i * ... * 100
先求1-100的质数有哪些
求数字i的质数约数以及约数出现的次数 eg：i=(2^a )*(3^b)
那么i有（（a+1）*(b+1)）个约数
package lanqiaobei_;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
public class jiechengyueshu {
public static void main(String arg[]){
ArrayList list = new ArrayList();
HashSet set = new HashSet();
int N=100;
//寻找1-N的质数----------------
ArrayList factor = new ArrayList();
factor.add(2);
for (int i = 1; i <=N; i++) {
for (int j = 2; j <=i-1 ; j++) {
if (i%j==0){//说明i为合数
break;
}
if (j==i-1&& i%j!=0){
factor.add(i);
}
}
}
//---------------------------
int temp=0;
for (int i = 2; i <=N ; i++) {//计算数字i的质数约数以及个数
for(Object o:factor){
if ((int)o>i){//约束小于等于i
break;
}
temp=i;
while (temp%(int)o==0){
temp=temp/(int)o;
list.add(o);
set.add(o);
}
}
}
long count=1;
long times=1;
for(Object o:set){
times= Collections.frequency(list,o)+1;//当前因子的出现频率+1
count=count*times;
}
System.out.println(count);
}
}
蓝肽子序列
问题描述：
L 星球上的生物由蛋蓝质组成，每一种蛋蓝质由一类称为蓝肽的物资首尾连接成一条长链后折叠而成。
生物学家小乔正在研究 L 星球上的蛋蓝质。她拿到两个蛋蓝质的蓝肽序列，想通过这两条蓝肽序列的共同特点来分析两种蛋蓝质的相似性。
具体的，一个蓝肽可以使用 1 至 5个英文字母表示，其中第一个字母大写，后面的字母小写。一个蛋蓝质的蓝肽序列可以用蓝肽的表示顺序拼接而成。
在一条蓝肽序列中，如果选取其中的一些位置，把这些位置的蓝肽取出，并按照它们在原序列中的位置摆放，则称为这条蓝肽的一个子序列。蓝肽的子序列不一定在原序列中是连续的，中间可能间隔着一些未被取出的蓝肽。
如果第一条蓝肽序列可以取出一个子序列与第二条蓝肽序列中取出的某个子序列相等，则称为一个公共蓝肽子序列。
给定两条蓝肽序列，找出他们最长的那个公共蓝肽子序列的长度
解题基础：最大公共子串的长度
参考博客：http://t.csdn.cn/oy9Ju
package lanqiaobei_;
public class public_zixulie_length {
public static void main(String[] args) {
Solution solution = new Solution();
System.out.println(solution.longestCommonSubsequence("bdcaba","abcbdab"));
}
}
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
String text11="0"+text1;
String text22="0"+text2;
char [] a=text11.toCharArray();
char [] b=text22.toCharArray();
int dp[][]=new int[a.length][b.length];
for (int i = 1; i < a.length; i++) {
for (int j = 1; j 思路：
字符串分段存入字符串类型的数组中
再结合《最长公共子序列》的方法求解
代码 70′
import java.util.Scanner;
public class Main {
public static void main(String arg[]){
Scanner scanner = new Scanner(System.in);
String s1=scanner.next();
String s2=scanner.next();
String s11[]=new String[s1.length()];
String s22[]=new String[s2.length()];
int s11len=function(s1,s11);
int s22len=function(s2,s22);
int dp[][]=new int[s11len][s22len];
for (int i = 1; i < s11len; i++) {
for (int j = 1; j < s22len; j++) {
if (s11[i].equals(s22[j])){
dp[i][j]=dp[i-1][j-1]+1;
}
else {
dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
}
}
}
int a=dp[s11len-1][s22len-1];
System.out.println(a);
scanner.close();
}
//将字符串S1分段，并返回数组元素个数
// 字符串S1=：AbcAbcB 得到数组S11=[null,Abc,Abc,B]
// 数组元素个数为：4
public static int function(String s1,String []s11){
s11[0]=null;
s11[1]=""+s1.charAt(0);
int j = 1;
int s11len=0;
for (int i = 1; i96){//小写
s11[i]=s11[i]+s1.charAt(j);
}
else {//大写
s11[i+1]=""+s1.charAt(j);
j++;
break;
}
}
if (j==s1.length()){
s11len=i+1;
break;
}
}
return s11len;
}
}
数列求值
package lanqiaobei_;
public class shulieqiezhi {
public static void main(String[] args) {
long dp[]=new long[20190324];
dp[0]=1;
dp[1]=1;
dp[2]=1;
long num=10000;
for (int i = 3; i 数字三角形
思路：
import java.util.Scanner;
public class shuzisanjiaoxing {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N=scanner.nextInt();
int[][] value = new int[N][];
int[][] dp = new int[N][];
for (int i = 0; i < N; i++) {
value[i]=new int[i+1];
dp[i]=new int[i+1];
for (int j = 0; j <=i ; j++) {
value[i][j]=scanner.nextInt();
}
}
dp[0][0]=value[0][0];
for (int i = 1; i < N; i++) {
dp[i][0]=dp[i-1][0]+value[i][0];
dp[i][i]=dp[i-1][i-1]+value[i][i];
}
if (N>2){
for (int i = 2; i < N; i++) {
for (int j = 1; j 货物摆放
//啰嗦的代码
import java.util.Arrays;
import java.util.HashSet;
import java.util.Objects;
public class HUOWUBAIFANG {
public static void main(String[] args) {
// ;
long N1=2021041820210418l;
long N2=1;
long N3=1;
int count=0;
HashSet nums = new HashSet<>();
for (int a = 1; a <=Math.sqrt(N1);a++) {//44955998
if (N1%a==0){
N2=N1/a;
for (long b = 1; b <= Math.sqrt(N2); b++) {
if (N2%b==0){
N3=N2/b;
long c=N3;
nums.add(new num(a,b,c));
}
}
}
}
for (num o:nums){
count=count+o.count;
}
System.out.println(count);
}
}
class num{
public long a;
public long b;
public long c;
public long arr[]=new long[3];
public int count;
public num(long a, long b, long c) {
this.a = a;
this.b = b;
this.c = c;
this.count=this.sort();
this.a = arr[0];
this.b = arr[1];
this.c = arr[2];
}
public int sort(){
arr[0]=this.a;
arr[1]=this.b;
arr[2]=this.c;
Arrays.sort(arr);
if (this.a==this.b||this.b==this.c){
return 3;
}
return 6;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
num num = (num) o;
return a == num.a && b == num.b && c == num.c;
}
@Override
public int hashCode() {
return Objects.hash(a, b, c);
}
}
等差素数数列
题目描述：
package lanqiaobei_;
public class dengchasushushulie {
public static void main(String arg[]){
int num=0;
int tolerance=1;
int temp=0;
int flage=0;
int res=0;
for (num = 1; num<=5000; num++) {
temp=num;
if (!Is_prime(num)){
continue;
}
tolerance = 1;
for ( ; tolerance<=1000 ; tolerance++) {
for (int i = 1; i <=9 ; i++) {
temp=num+tolerance*i;
if (!Is_prime(temp)){
break;
}
if (i==9){
flage=1;
res=tolerance;
break;
}
}
if (flage==1){
break;
}
}
if (flage==1){
break;
}
}
System.out.println(res);
}
public static boolean Is_prime(int num){
if (num==1||num==2){
return true;
}
for (int i = 2; i 跳马（BFS）
参考博客：BFS http://t.csdn.cn/lxU2Y
问题描述：
一个8×8的棋盘上有一个马初始位置为(a,b)，他想跳到(c,d)，问是否可以？如果可以，最少要跳几步？
import java.util.*;
public class Main {
public static int dx[]= {1,2,2,1,-1,-2,-2,-1};
public static int dy[]= {2,1,-1,-2,2,1,-1,-2};
public static int[][] mymap=new int [9][9];
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
int c=scan.nextInt();
int d=scan.nextInt();
//graph
position start =new position(a, b);
position end =new position(c, d);
//队列
LinkedList queue=new LinkedList<>();
queue.add(start);
position father=start;
mymap[father.x][father.y]=1;
ArrayList nexts=new ArrayList<>();
while(!queue.isEmpty()){
//父亲节点出队列
father=queue.poll();
//子节点入队列
nexts=Find_next(father);
for(Object son:nexts) {
position son1=(position)son;
if(mymap[son1.x][son1.y]==0)
{
queue.add((position)son1);
mymap[son1.x][son1.y]=mymap[father.x][father.y]+1;
}
}
}
System.out.println(mymap[end.x][end.y]-1);
}
public static ArrayList Find_next(position p) {
ArrayList nexts=new ArrayList<>();
int x=p.x;
int y=p.y;
for(int i=0;i<8;i++) {
if(x+dx[i]>=1&&x+dx[i]<=8&&y+dy[i]>=1&&y+dy[i]<=8)
nexts.add(new position(x+dx[i], y+dy[i]));
}
return nexts;
}
}
class position{
public int x;
public int y;
public position(int a,int b) {
this.x=a;
this.y=b;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "("+x+","+y+")";
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if(this==obj) return true;
if(obj==null) return false;
position p= (position) obj;
return p.x==this.x && p.y==this.y;
}
//@Override
public int hashCode() {
// TODO Auto-generated method stub
return Objects.hash(x,y);
}
}
青蛙跳杯子（BFS）
问题描述：
代码：
import java.util.*;
public class Frogs_jump_into_cups {
public static int [] dx= {-3,-2,-1,1,2,3};
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
String start=scan.next();
String end=scan.next();
//访问set
HashSet visit=new HashSet<>();
HashMap hashMap = new HashMap();
//father
state fatherState=new state(start,0);
//队列
LinkedList queue=new LinkedList<>();
queue.add(fatherState);
visit.add(fatherState);
while(!queue.isEmpty()) {
//父亲状态出队列
fatherState=queue.poll();
//子状态入队列
ArrayList nexts=Next_string(fatherState.s);
for(Object son:nexts) {
String son1=(String) son;
//重复的状态不加入
if (visit.add(new state(son1,fatherState.hop_count+1))) {
hashMap.put(son1,fatherState.hop_count+1);
queue.add(new state(son1,fatherState.hop_count+1));
}
}
}
// System.out.println("------------------visit------------------");
// System.out.println(visit);
// System.out.println("------------------hashMap------------------");
// System.out.println(hashMap);
// System.out.println("------------------最终结果------------------");
System.out.println(hashMap.get(end));
}
public static ArrayList Next_string(String s) {
ArrayList nexts=new ArrayList<>();
//注意 不要改变arr元素的顺序！！！
//1、找*的位置
int location = 0;
char arr[]=s.toCharArray();
location=s.indexOf('*');
//一般情况+*在两端的特殊位置
for (int i = 0; i < dx.length; i++) {
int nextlocation=location+dx[i];
if (nextlocation>=0&&nextlocation 奇数倍数
问题描述：
import java.util.*;
public class Odd_multiple {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1、一定是2019的奇数倍数//Collections.reverse(Split(2019));
int num=0;
ArrayList list=new ArrayList();
int flage=0;
int times=0;
for (int i = 3; ; i=i+2) {
num=2019*i;
list=Split(num);
int j=0;
for(Object o:list) {
j++;
if ((int)o%2==0) {//偶数直接退出内循环开始下一次外循环
break;
}
if (j==list.size()) {
//说明遍历到了最后一个数字 且最后一个数字也是奇数
times=i;
flage=1;
break;
}
}
if (flage==1) {
break;
}
}
System.out.println(2019*times);
}
public static ArrayList Split(int num) {
ArrayList list =new ArrayList();
for(int i=num;i>0;i/=10) {
list.add(i%10);
}
return list;
}
}
时间显示
问题描述：
注意时区！
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
@SuppressWarnings("all")
public class time_show {
public static void main(String[] args) throws ParseException {
// Date d1=new Date();//获取当前系统时间
// System.out.println(d1);//Thu Apr 06 17:07:26 CST 2023
// SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss ");
// SimpleDateFormat sdf2=new SimpleDateFormat("hh:mm:ss");
// String d1s=sdf1.format(d1);
// System.out.println(d1s);//2023-04-06 05:07:26
// Date d2=new Date(99999);
// System.out.println(d2);//Thu Jan 01 08:01:39 CST 1970
// String d2s=sdf1.format(d2);
// System.out.println(d2s);//1970-01-01 08:01:39
Scanner scanner=new Scanner(System.in);
long input=scanner.nextLong();
Date date=new Date(input);
SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss ");
sdf.setTimeZone(TimeZone.getTimeZone("US"));
String dateString=sdf.format(date);
System.out.println(dateString);
scanner.close();
}
}