2021蓝桥杯模拟赛Java C组(四)

public class test1 {
	public static void main(String[] args) {
		int count=0;
		for (int i = 1900; i < 2021; i++) {
			int sum=0;
			for (int j = 1; j < i; j++) {
				if (gcd(j, i)==1) {
					sum++;
				}
				if (sum==i-1) {
					count++;
				}
			}
		}
		System.out.println(count);//16
	}
	public static int  gcd(int a,int b) {
		return b==0?a:gcd(b, a%b);
	}
}

public class test2 {
	public static void main(String[] args) {
		int a=80;
		char b=(char) a;
		System.out.println(b);//P
	}
}

问题描述
Fibonacci序列按照如下公式定义：
　　F[1] = 1
　　F[2] = 1
　　F[i] = F[i-1] + F[i-2] (i>2)
　　前几个 Fibonacci 数为 1, 1, 2, 3, 5, 8, 13, 21。
　　请问，前100个 Fibonacci 数中，有多少个数是 3 的倍数？
思路解析
四个里有一个是3的倍数,写程序的话int装不下,要用long
代码如下

public class test3 {
	public static void main(String[] args) {
		long a=1;
		long b=1;
		int count=0;
		for (int i = 3; i <102 ; i++) {
			long c=0;
			c=a+b;
			a=b;
			b=c;
			if (a%3==0) {
				count++;
			}
		}
		System.out.println(count);//25
	}
}

2021+2020=4041

public class test5 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String n = sc.next();
		String[] str = n.split("");
		int arr[] =new int[str.length];
		for (int i = 0; i < str.length; i++) {
			arr[i]=Integer.parseInt(str[i]);
		}
		int sum=0;
		int len=arr.length-1;
		int i=2;
		while (len>=0) {
			sum+=(Math.pow(2, i-1)%11)*arr[len];
			len--;
			i++;
		}
		
		System.out.println(sum);//213
		// 220的11的倍数220-213+1=8
	}
}

public class test6 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String s = sc.next();
		String[] str = s.split("");
		for (int i = 0; i < str.length; i++) {
			if (i==0) {
				System.out.print(str[i].toUpperCase());
			}else {
				System.out.print(str[i].toLowerCase());
			}
		}
	}
}

思路解析
没什么好说的,一共十种字符串,存到数组再操作就行了
代码如下

public class test6 {
	public static void main(String[] args) {
		int arr[]= {0,1,2,3,4,5,6,7,8,9};
		String str[]= {"-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		String[] st=new String [n];
		for (int i = 0; i < n; i++) {
			int s = sc.nextInt();
			String s1=s+"";
			st[i]=s1;
			
		}
		for (int i = 0; i < st.length; i++) {
			String[] split = st[i].split("");
			
			for (int j = 0; j < split.length; j++) {
				int a = Integer.parseInt(split[j]);
				for (int k = 0; k < 10; k++) {
					if (arr[k]==a) {
						System.out.print(str[k]+" ");
					}
				}
			}
			System.out.println("");
		}
	}
}

public class test8 {
	static int arr[];
	static int arrcy[];
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		arr=new int[n];
		arrcy=new int[n-4];
		for (int i = 0; i < n; i++) {
			arr[i]=sc.nextInt();
		}
		for (int i = 2; i < n-2; i++) {
			arrcy[i-2]=result(i);
		}
		for (int i = 0; i < arrcy.length; i++) {
			System.out.print(arrcy[i]+" ");
		}
	}
	public static int result(int a) {
		int max;
		int min;
		if (arr[a-2]<=arr[a-1]) {
			min=arr[a-2];
			max=arr[a-1];
		}else {
			min=arr[a-1];
			max=arr[a-2];
		}
		for (int i = 0; i < 3; i++) {
			if (arr[a+i]<min) {
				min=arr[a+i];
			}
			if (arr[a+i]>max) {
				max=arr[a+i];
			}
		}
		return max-min;
	}
}

小Hi正在研究一种特殊的栈。这种栈的元素既可以从栈顶出栈，也可以从栈底出栈。(进栈还是只能从栈顶进栈)
　　已知入栈的序列是1~N的一个排列，请你判断出栈序列能否是1, 2, 3, … N?
思路解析
当时不理解题目,以为是全部入栈后再出栈,其实题目的意思是,每个元素入栈后判断是否能出栈,也就是一边入栈,一边出栈,最终判断能否按1-n的顺序出栈,思路写在代码注释
另外check方法使用了递归,不确定是否会超时
代码如下

public class test9 {
	static int start;
	static int end;
	static int k;
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int T = sc.nextInt();
		//用List存储T个数组
		List<int []> ls=new ArrayList<int []>(); 
		for (int i = 0; i < T; i++) {
			int N = sc.nextInt();
			int arr[]=new int[N];
			for (int j = 0; j < N; j++) {
				arr[j]=sc.nextInt();
			}
			ls.add(arr);
		}
		//将List中的各个数组进行处理
		for (int i = 0; i < ls.size(); i++) {
			//start:当前栈中的第一个元素下标
			start=0;
			//end:当前栈中的最后一个元素下标
			end=-1;
			//k:当前应该出栈的元素的值
			k=1;
			//用来处理的数组
			int [] x=new int[ls.get(i).length];
			//依次入栈
			for (int j = 0; j < ls.get(i).length; j++) {
				//入栈完成,end+1;
				end++;
				x[end]=ls.get(i)[j];
				//判断是否需要出栈
				check(x);
			}
			//出栈完成输出结果
			if (end<start) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
				
			}
		}
		
	}
	public static void check (int x[]) {
		
		if (x[start]==k) {
			start++;
			k++;
			//出栈后再次判断
			check(x);
		}
		if (x[end]==k) {
			if (start!=end) {
				end--;
				k++;
				//出栈后再次判断
				check(x);
			}
		}
		return;
	}
}

给定一个序列 (a_1, a_2, …, a_n), 定义序列中的一个递增三元组是指三个下标 i, j, k 对应的三个元素 a_i, a_j, a_k，这三个元素满足 a_i < a_j < a_k。
　　例如序列 (1, 1, 4, 3, 2, 4) 有以下 4 个递增三元组：
　　1. 下标 1, 4, 6 对应的 1, 3, 4；
　　2. 下标 1, 5, 6 对应的 1, 2, 4；
　　3. 下标 2, 4, 6 对应的 1, 3, 4；
　　4. 下标 2, 5, 6 对应的 1, 2, 4。
　　　　注意，可能有下标不同但对应数值相同的三元组，他们应当算成不同的三元组。
　　给定序列，请问序列中一共有多少个不同的递增三元组。
输入格式
　　输入第一行包含一个整数 n，表示序列的长度。
　　第二行包含 n 个整数 a_1, a_2, …, a_n，表示给定的序列。
输出格式
　　输出一行，包含一个整数，表示序列中的递增三元组数量。请注意答案可能很大，可能超过 32 位二进制整数的范围，建议使用 64 位二进制整数。

思路解析
暂时只能想到枚举,会超时
代码如下

public class test10 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		int arr[]=new int[n];
		for (int i = 0; i < n; i++) {
			arr[i]=sc.nextInt();
		}
		long count=0;
		//枚举法
		for (int i = 0; i < n; i++) {
			for (int j = i+1; j < n; j++) {
				for (int j2 = j+1; j2 < n; j2++) {
					if (i<j&&j<j2) {
						if (arr[i]<arr[j]&&arr[j]<arr[j2]) {
							count++;
						}
					}
				}
			}
		}
		System.out.println(count);
		
		
	}
}

输入格式

输入第一行包含三个整数 n, m, k，分别表示序列 A 的长度、序列 B 的长度和公共子序列的长度。
　　第二行包含 n 个整数 a_1, a_2, …, a_n，表示给定的 A 序列。
　　第三行包含 m 个整数 b_1, b_2, …, b_m，表示给定的 B 序列。

输出格式

输出一行，包含一个整数，表示长度为 k 的公共子序列的数量，答案可能很大，请输出答案除以 1000007 的余数。

思路解析
同样是枚举(循环嵌套比较多,debug了一下午)
代码如下

public class test12 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int [] arr1=new int[n];
		int [] arr2=new int[m];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i]=sc.nextInt();
		}		
		for (int i = 0; i < arr2.length; i++) {
			arr2[i]=sc.nextInt();
		}
		
		
		long sum=0;//记录总数
		long count=0;
		int len;
		if (k==1) {
			len=1;
		}else {
			len=arr1.length;
		}
		for (int x = 0; x < len; x++) {
			int b=0;
			for (int i = x; i < arr1.length; i++) {
				for (int j = b; j < arr2.length; j++) {
					//找到一对数字
					if (arr1[i]==arr2[j]) {
						count++;
						//找到一个序列
						if (count==k) {
							sum++;
							//找到后记录,然后count--,继续找后面是否有满足要求的数
							count--;
						}else {
							//记录下标,下次从这里找
							b=j+1;
							break;
						}
					}
				}
			}
			count--;
		}
		System.out.println(sum%1000007);
	}
}

非暴力枚举解法等会了再补
评论区欢迎指正