蓝桥杯2018 JAVA b组省赛

最新推荐文章于 2024-07-18 21:33:10 发布

BanXian Hui

最新推荐文章于 2024-07-18 21:33:10 发布

阅读量72

点赞数

文章标签：蓝桥杯职场和发展

本文链接：https://blog.csdn.net/weixin_64896587/article/details/128516862

版权

1、标题：第几天

2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？

注意：需要提交的是一个整数，不要填写任何多余内容。

解析：方法一：调出日历自己算；

方法二：GregorianCalendar类，date类SimpledateFormat的转化;(提示：“D”)

代码：

答案：125

2、标题：方格计数

如图p1.png所示，在二维平面上有无数个1x1的小方格。

我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？

注意：需要提交的是一个整数，不要填写任何多余内容。

解析：根据圆的对称性解决问题，选取圆的四分之一判断，最后答案*4即可；



import java.util.Scanner;

public class 方格计数 {
	public static void main(String[] args) {System.out.println("   k");
		Scanner scn=new Scanner(System.in);
		int n=scn.nextInt();
		int sum=0;
		for (int i = 1; i <n; i++) {
			for (int j = 1; j <n; j++) {
				if (Math.pow(i, 2)+Math.pow(j, 2)<=Math.pow(1000, 2)) {
					sum+=1;
				}
			}
		}System.out.println(sum*4);
		scn.close();
	}
}

3、标题：复数幂

设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？即(2+3i)的123456次幂，这个数字很大，要求精确表示。

答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i

注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。

解析：这是一个非常大的数，因此要用BigInteger类，后通过printstream类中的print（）方法将控制台的数据通过流的方式转入到目标文件中；

代码：

package caogao;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.math.BigInteger;
import java.util.Scanner;


public class caogao1 {
	
	public static void main(String[] args) throws FileNotFoundException {System.out.println("");
		Scanner scnScanner=new Scanner( System .in);
		PrintStream aPrintStream=new PrintStream("caogao.txt");
	BigInteger aBigInteger=BigInteger.valueOf(2);//实部
	BigInteger bBigInteger=BigInteger.valueOf(3);//虚部
	int c=scnScanner.nextInt();
//System.out.println(rule(aBigInteger, bBigInteger, c));
	String aString=rule(aBigInteger, bBigInteger, c);
	aPrintStream.print(aString);
	aPrintStream.close();
	scnScanner.close();
		
	}
	private static String rule(BigInteger a,BigInteger b,int e) {
		BigInteger cBigInteger=a;//实部
		BigInteger qBigInteger=a;//实部
		BigInteger dBigInteger=b;//虚部
		BigInteger wBigInteger=b;//虚部
		BigInteger gBigInteger=BigInteger.valueOf(0);
	
		String daanString="";
		for (int i = 1; i < e; i++) {
			qBigInteger = cBigInteger.multiply(a).subtract(b.multiply(dBigInteger)) ;
			wBigInteger = a.multiply(dBigInteger).add(b.multiply(cBigInteger));
			cBigInteger=qBigInteger;dBigInteger=wBigInteger;
		}
		daanString=""+cBigInteger+(dBigInteger.compareTo(gBigInteger)==1?"+":"")+dBigInteger+"i";
		return daanString;
	}
			}

4、标题：测试次数

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。

x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。

如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

为了减少测试次数，从每个厂家抽样3部手机参加测试。

某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？

请填写这个最多测试次数。

注意：需要填写的是一个整数，不要填写任何多余内容。

解析，这就是一个扔鸡蛋问题，通过推导我们可以知道他们的动态转移方程，然后用动态规划的方法解决这个问题；

代码：

package caogao;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.lang.invoke.CallSite;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class caogao1 {
	public static void main(String[] args) {                                                         
		int [][] arr=new int[4][1001];
		int sui=0;
		int nosui=0;
//		int Min=Integer.MAX_VALUE;
		for (int i = 0; i < arr[0].length; i++) {
			arr[0][i]=0;
			arr[1][i]=i;
		}
		for (int i = 1; i < arr.length; i++) {
			arr[i][1]=1;
			arr[i][0]=0;
		}
		System.out.println("测试："+arr[0][1]);
//		System.out.println(arr[0].length);
	/*鸡蛋数量*/	for (int i = 2; i < arr.length; i++) {

		/*楼层数*/	 for (int j = 2; j < arr[0].length; j++) {
							int Min=Integer.MAX_VALUE;
			/*遍历*/		for (int j2 = 1; j2 < j; j2++) {
//				动态转移方程：min（max1（碎，没碎），max2（碎，没碎）。。。。。）
							sui=arr[i-1][j2-1]+1;//如果鸡蛋碎了，剩下的鸡蛋（i-1个）就要从下面的j2-1楼层测试取最小值；
							nosui=arr[i][j-j2]+1;//如果鸡蛋没有碎，剩下的鸡蛋（i个）就要从上面的j-j2楼层测试取最小值
							 Integer Max=Math.max(nosui, sui);
							Min=Math.min(Min, Max);
					
				}arr[i][j]=Min;
			} 
			
		}System.out.println(arr[3][1000]);
	}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
			}

6、标题：递增三元组

给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：

1. 1 <= i, j, k <= N
2. Ai < Bj < Ck

【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。

对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

【输出格式】
一个整数表示答案

【输入样例】
3
1 1 1
2 2 2
3 3 3

【输出样例】
27

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理

代码：

package caogao;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class caogao1 {
	
	public static void main(String[] args) {
		List< String> aList=new ArrayList<>();
		Scanner scnScanner=new Scanner( System.in);
		int length=scnScanner.nextInt();
		String daanString=null;
		int [] arr=new int[length];
		int [] brr=new int[length];
		int [] crr=new int[length];
		for (int i = 0; i < crr.length*3; i++) {
			if (i>=0&&i<3) {
				arr[i]=scnScanner.nextInt();
			}else if (i>=3&&i<6) {
				brr[i-3]=scnScanner.nextInt();
			}else if (i>=6&&i<9) {
				crr[i-6]=scnScanner.nextInt();
			}
		}
//		for (int i = 0; i < crr.length; i++) {
//			System.out.println(crr[i]);
//		}
		for (int i = 0; i < crr.length; i++) {
			for (int j = 0; j < crr.length; j++) {
				for (int k = 0; k < crr.length; k++) {
					if (rule(arr, brr, crr, i, j, k)) {
						daanString=i+j+k+"";
						aList.add(daanString);
					}
				}
			}
		}
		System.out.println(aList.size());
		scnScanner.close();
	}
	private static boolean rule( int[] arr,int[] brr,int[] crr, int i,int j,int k) {
		if (arr[i]<brr[j]&&brr[j]<crr[k]) {
			return true;
		}else {
			return false;
		}
		
	}
}

7、标题：螺旋折线

如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。

例如dis(0, 1)=3, dis(-2, -1)=9

给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？

【输入格式】
X和Y

对于40%的数据，-1000 <= X, Y <= 1000
对于70%的数据，-100000 <= X， Y <= 100000
对于100%的数据, -1000000000 <= X, Y <= 1000000000

【输出格式】
输出dis(X, Y)

【输入样例】
0 1

【输出样例】

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

解析：通过推导可以发现代码块中的规律；

代码;

package caogao;

import java.util.Scanner;

public class caogao1 {
	static int x=0;
	static int y=0;
	public static void main(String[] args) {
		Scanner scnScanner=new Scanner(System.in);
		int X=scnScanner.nextInt();
		int Y=scnScanner.nextInt();
		System.out.println(rule(X, Y));
		scnScanner.close();
	}
	private static int rule(int X,int Y) {
		int a=0;
		int b=0;
		int daan=0;
		while (b==0) {
			a++;
			for (int i = 0; i < a; i++) {/* System.out.println("111111"); */
				x=x-1;
				daan++;
				if (x==X&&y==Y) {
					b++;
					break;
				}
			}
			    if (b!=0) {
					break;
				}
				for (int i = 0; i < a; i++) {/* System.out.println("222222"); */
				y=y+1;
				daan++;
				if (x==X&&y==Y) {
					b++;
					break;
				}
			}
			 if (b!=0) {
					break;
				}
			a++;
			for (int i = 0; i <a; i++) {
				/* System.out.println("33333"); */
				x=x+1;
				daan++;
				if (x==X&&y==Y) {
					b++;
					break;
				}
			}
			 if (b!=0) {
					break;
				}
				for (int i = 0; i < a; i++) {/* System.out.println("444444"); */
				y=y-1;
				daan++;
				if (x==X&&y==Y) {
					b++;
					break;
				}
			} if (b!=0) {
				break;
			}
		}
		return daan;
	}
}

8、标题：日志统计

小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：

ts id

表示在ts时刻编号id的帖子收到一个"赞"。

现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。

具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。

给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。

【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。

对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000

【输出格式】
按从小到大的顺序输出热帖id。每个id一行。

【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3

【输出样例】
1
3

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

解析：主要应用树状结构解决问题！

代码：

package _2018_9_b;
import java.util.*;
import java.util.Map.Entry;
public class 日志统计 {
	
	static	Map<Integer, ArrayList<String>> aMap=new HashMap<>();
	static Set<String> Set= new HashSet<>();
	public static void main(String[] args) {System.out.println("");
		Scanner scnScanner=new Scanner(System.in);
		int N = scnScanner.nextInt();
		int D=scnScanner.nextInt();
		int K=scnScanner.nextInt();
		for (int i = 0; i < N; i++) {
			Integer tsInteger=scnScanner.nextInt();
			String idString=scnScanner.next();
			Set.add(idString);
			putRule(tsInteger, idString);
			
		}
	 /*测试
		Set<Entry<Integer, ArrayList<String>>> aSet=aMap.entrySet();
		for (Entry<Integer, ArrayList<String>> element : aSet) {
			System.out.println(element.getKey());
			for (int i = 0; i < element.getValue().size(); i++) {
				System.out.print(element.getValue().get(i)+"\t");
			}System.out.println();
		}*/
		
		rule(D, K);
		for (String string : Set) {
			System.out.println(string);
		}
		scnScanner.close();
	}
//利用map容器构成数据结构（逻辑结构可以理解为树状结构）
	private static void putRule(Integer ts,String id) {
		if (!aMap.containsKey(ts)) {
			ArrayList<String> aList=new ArrayList<>();
			aList.add(id);
			aMap.put(ts,aList);
		}else {
			aMap.get(ts).add(id);
		}
	}
//在树状结构基础上进行数据操作
	private static void rule(int D,int K) {
		Set<Entry<Integer, ArrayList<String>>> aSet=aMap.entrySet();
		//遍历map中所有value的元素并计数
		for (String element0 : Set) {
			int max=Integer.MIN_VALUE;
			for (Entry<Integer, ArrayList<String>> element1 : aSet) {
				int sum=0;
//			System.out.println("------");
				for (Entry<Integer, ArrayList<String>> element2 : aSet) {
					if (element2.getKey()>=element1.getKey()&&element2.getKey()<element1.getKey()+D) {
//					System.out.println(element2.getKey());
						for (int i = 0; i < element2.getValue().size(); i++) {
							if (element2.getValue().get(i).equals(element0)) {
								sum++;
							} 
						}
					}
				}
				//选最大的sum作最终比对值
			max=	Math.max(max, sum);  
				}
//			System.out.println(max);
		if (max<K) {
			Set.remove(element0);
		}
			}
				}
		
}

BanXian Hui

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
蓝桥杯2018 JAVA b组省赛

解析：这是一个非常大的数，因此要用BigInteger类，后通过printstream类中的print（）方法将控制台的数据通过流的方式转入到目标文件中；塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。对于100%的数据，1
复制链接

扫一扫