蓝桥杯18年B组

最新推荐文章于 2023-04-08 23:37:03 发布
最新推荐文章于 2023-04-08 23:37:03 发布
阅读量372 收藏
点赞数 1
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WORLD_NO_ONE/article/details/106503987
版权 
public class Main_1 {//第几天

	/**
	 * 第几天 2000年1月1日，是那一年的第1天， 那么，2000年5月4日，是那一年的第几天？ 注意:需要提交的是一个整数，不要填写任何多余内容
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(31 + 29 + 31 + 30 + 4);
	}

}


public class Main_2 {// 方格计数

	/**
	 * 我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。 你能计算出这个圆里有多少个完整的小方格吗？
	 * 
	 * 注意：需要提交的是一个整数，不要填写任何多余内容。
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 方法1
		int r = 0;
		for (int i = 1; i <= 1000; i++) {
			for (int j = 1; j <= 1000; j++) {
				if (i * i + j * j <= 1000 * 1000)
					r++;
			}
		}
		System.out.println(r * 4);
		// 方法2
		int n = 1000;
		int y = n;
		int ans = 0;
		for (int x = 1; x <= n; x++) {
			while (x * x + y * y > n * n && y > 0)
				y--;
			ans += y;
		}
		System.out.println(ans * 4);
	}

}


import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.math.BigInteger;

public class Main_3 {

	/**
	 * 复数幂 题目：设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。 求 (2+3i)^123456 等于多少？
	 * 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
	 * 
	 * 答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2
	 * 写成: -5+12i， (2+3i)^5 的写成: 122-597i 注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
	 * 
	 * 
	 * 
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BigInteger two = BigInteger.valueOf(2);
		BigInteger three = BigInteger.valueOf(3);
		BigInteger a = BigInteger.valueOf(2);
		BigInteger b = BigInteger.valueOf(3);
		BigInteger aa = null;
		BigInteger bb = null;
		for (int i = 0; i < 123455; i++) {
			aa = a.multiply(two).subtract(b.multiply(three));
			bb = a.multiply(three).add(b.multiply(two));
			a = aa;
			b = bb;
		}
		try {
			System.setOut(new PrintStream(new File("E:\\新建文本文档.txt")));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(aa + (bb.compareTo(BigInteger.ZERO) < 0 ? "-" : "+")
				+ bb + "i");

	}

}


public class Main_4 {

	/**
	 * 测试次数 题目描述 x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
	 * 各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
	 * 
	 * x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
	 * 
	 * 如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。 特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
	 * 如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
	 * 
	 * 为了减少测试次数，从每个厂家抽样3部手机参加测试。
	 * 
	 * 某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
	 * 
	 * 请填写这个最多测试次数。
	 * 
	 * 注意：需要填写的是一个整数，不要填写任何多余内容。
	 * 
	 * @param args
	 */
	static final int n = 1000;
	static int[] f1 = new int[n + 1];
	static int[] f2 = new int[n + 1];
	static int[] f3 = new int[n + 1];

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i = 1; i <= n; i++) {
			f1[i] = i;
		}
		for (int i = 1; i <= n; i++) {
			int ans = Integer.MAX_VALUE;
			for (int j = 1; j <= i; j++) {
				int _max = 1 + Math.max(f2[i - j], f1[j - 1]);
				ans = Math.min(ans, _max);
			}
			f2[i] = ans;
		}
		for (int i = 1; i <= n; i++) {
			int ans = Integer.MAX_VALUE;
			for (int j = 1; j <= i; j++) {
				int _max = 1 + Math.max(f3[i - j], f2[j - 1]);
				ans = Math.min(ans, _max);
			}
			f3[i] = ans;
		}
		System.out.println(f3[n]);
	}

}


import java.util.Random;

public class Main_5 {

	/**
	 * @param args
	 */
	public static int quickSelect(int a[], int l, int r, int k) {
		Random rand = new Random();
		int p = rand.nextInt(r - l + 1) + l;
		int x = a[p];
		int tmp = a[p];
		a[p] = a[r];
		a[r] = tmp;
		int i = l, j = r;
		while (i < j) {
			while (i < j && a[i] < x)
				i++;
			if (i < j) {
				a[j] = a[i];
				j--;
			}
			while (i < j && a[j] > x)
				j--;
			if (i < j) {
				a[i] = a[j];
				i++;
			}
		}
		a[i] = x;
		p = i;
		if (i - l + 1 == k)// (1)说明到底了
			return a[i];
		if (i - l + 1 < k)
			return quickSelect(a, i + 1, r, k - i + l - 1); // 填空
		// qsort(a, i + 1, right);
		// (3)先试试k，
		// (4)再考虑：k要移动到等于（i - l + 1），试试k-(i - l + 1)
		else
			// i - l + 1 > k
			return quickSelect(a, l, i - 1, k);// (2)qsort(a, left, i -
												// 1);对上了，k不变
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = { 1, 4, 2, 8, 5, 7 };
		System.out.println(quickSelect(a, 0, 5, 4));
	}

}


import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Scanner;

public class Main_6 {

	/**
	 * 题目描述 给定三个整数数组 A = [A1, A2, … AN], B = [B1, B2, … BN], C = [C1, C2, … CN]，
	 * 请你统计有多少个三元组(i, j, k) 满足：
	 * 
	 * 1 <= i, j, k <= N 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，否则按无效代码处理。
	 * ———————————————— 版权声明：本文为CSDN博主「南 墙」的原创文章，遵循CC 4.0
	 * BY-SA版权协议，转载请附上原文出处链接及本声明。
	 * 原文链接：https://blog.csdn.net/a1439775520/article/details/97613304
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		long ans = 0;
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] a = new int[n];
		int[] b = new int[n];
		int[] c = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
		}
		for (int i = 0; i < n; i++) {
			b[i] = sc.nextInt();
		}
		for (int i = 0; i < n; i++) {
			c[i] = sc.nextInt();
		}
		Arrays.sort(a);
		Arrays.sort(b);
		Arrays.sort(c);
		int p = 0;
		int q = 0;
		for (int i = 0; i < n; i++) {
			while (p < n && a[p] < b[i])
				p++;
			while (q < n && c[q] <= b[i])
				q++;
			ans += 1L * p * (n - q);
		}
		System.out.println(ans);
	}

}


import java.util.Scanner;

public class Main_7 {

	/**
	 * 例如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
	 * 
	 * 【输出样例】 3
	 * 
	 * 资源约定： 峰值内存消耗（含虚拟机）< 256M CPU消耗 < 1000ms
	 * 
	 * 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
	 * 
	 * 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 不要使用package语句。不要使用jdk1.7及以上版本的特性。
	 * 主类的名字必须是：Main，否则按无效代码处理。例如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
	 * 
	 * 【输出样例】 3
	 * 
	 * 资源约定： 峰值内存消耗（含虚拟机）< 256M CPU消耗 < 1000ms
	 * 
	 * 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
	 * 
	 * 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 不要使用package语句。不要使用jdk1.7及以上版本的特性。
	 * 主类的名字必须是：Main，否则按无效代码处理。
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		long x = sc.nextLong(), y = sc.nextLong();
		long d = 0;
		long n = 0;
		if (y > 0 && Math.abs(x) <= y) {
			n = y;
			d = y - x + 2 * y;
		} else if (x > 0 && Math.abs(y) <= x) {
			n = x;
			d = y + x;
		} else if (y <= 0 && x >= y - 1 && x <= -y) {
			n = -y;
			d = -(-y - x);
		} else if (x < 0 && y >= x + 1 && y <= -x) {
			n = -x - 1;
			d = -(y - x - 1 - 2 * x - 1);
		}
		System.out.println(sum(1L, 2 * n, 1) * 2 - d);
	}

	private static long sum(long a0, long n, int d) {
		// TODO Auto-generated method stub
		return (2 * a0 + (n - 1) * d) * n / 2;
	}

}


import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.SortedSet;
import java.util.TreeSet;

public class Main_8 {
	static class R {
		int ts, td;
	}

	/**
	 * 日志统计 小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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，否则按无效代码处理。
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), d = sc.nextInt(), k = sc.nextInt();
		R[] rs = new R[n];
		for (int i = 0; i < n; i++) {
			R r = new R();
			r.ts = sc.nextInt();
			r.td = sc.nextInt();
			rs[i] = r;
		}
		// 匿名内部类定义排序器
		Arrays.sort(rs, new Comparator<R>() {
			public int compare(R r1, R r2) {
				return r1.ts - r2.ts;
			}
		});
		// 用于给id计数
		Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
		// 用于存储答案（各个id），因为要求答案输出有序，这里直接用
		SortedSet<Integer> answers = new TreeSet<Integer>();
		// 尺取法
		int j = 0;
		for (int i = 0; i < n; ++i) {
			while (j < n && rs[j].ts - rs[i].ts < d) {
				int td = rs[j].td;
				Integer exist = cnt.get(td);
				if (exist != null) {
					cnt.put(td, exist + 1);
				} else {
					cnt.put(td, 1);// id第一次出现
				}
				if (cnt.get(td) >= k)
					answers.add(td);
				j++;
			}
			// （马上i就要更新了）将上一个i对应的id的计数-1
			Integer cntOfI = cnt.get(rs[i].td);
			if (cntOfI != null)
				cnt.put(rs[i].td, cntOfI - 1);
		}
		// 输出各个id
		for (Integer i : answers) {
			System.err.println(i);
		}
	}

}


import java.io.FileNotFoundException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main_9 {

	/**
	 * 
	 * 
	 * 
	 * @param args
	 */
	static int[] dx = { -1, 1, 0, 0 };
	static int[] dy = { 0, 0, -1, 1 };
	// 数据闺蜜
	private static int n;
	// 地图数据
	private static char[][] g;
	// 标记每个格子是否被访问
	private static int[][] mark;
	// 结果：被完全淹没的岛屿的数量
	private static int ans;

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		sc.nextLine();// 读取换行符
		// 初始化地图数据和标记数组
		g = new char[n][n];
		mark = new int[n][n];
		// 读取地图数据
		for (int i = 0; i < n; i++) {
			g[i] = sc.nextLine().toCharArray();
		}
		// 双重循环检测地图上的各个格子。以未被访问的#为起点，做宽搜
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if (g[i][j] == '#' && mark[i][j] == 0) {
					bfs(i, j);
				}
			}
		}
		System.out.println(ans);
	}

	private static void bfs(int x, int y) {
		// TODO Auto-generated method stub
		mark[x][y] = 1;
		int cntOfBlock = 0;// 记录陆地的数量
		int cntOfSwed = 0;// 记录将被淹没的陆地的数量
		Queue<Point> queue = new LinkedList<Point>();
		queue.add(new Point(x, y));
		while (!queue.isEmpty()) {
			Point first = queue.poll();// 弹出头部
			cntOfBlock++;
			boolean swed = false;
			for (int d = 0; d < 4; d++) {
				int nx = first.x + dx[d];
				int ny = first.y + dy[d];
				if (0 <= nx && nx < n && 0 <= ny && ny < n) {
					if (g[nx][ny] == '.')
						swed = true;// 周边有一个。这块陆地就会被淹没，避免重复计数
					if (g[nx][ny] == '#' && mark[nx][ny] == 0) {
						queue.add(new Point(nx, ny));
						mark[nx][ny] = 1;
					}
				}
			}
			if (swed)
				cntOfSwed++;

		}
		if (cntOfBlock == cntOfSwed)
			ans++;
	}

	private static class Point {
		int x, y;

		public Point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

}


import java.util.Scanner;

public class Main_10 {

	/**
	 * 题目描述 我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
	 * 每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。
	 * 
	 * 假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？
	 * 
	 * 例如对于N=4有如下3种：
	 * 
	 * 1 / \ 2 3 / 4
	 * 
	 * 1 / \ 3 2 / 4
	 * 
	 * 1 / \ 2 4 / 3
	 * 
	 * 由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。
	 * 
	 * 
	 * 【输入格式】 一个整数N。 对于40%的数据，1 <= N <= 1000 对于70%的数据，1 <= N <= 10000
	 * 对于100%的数据，1 <= N <= 100000
	 * 
	 * 【输出格式】 一个整数表示答案。
	 * 
	 * 【输入样例】 4
	 * 
	 * 【输出样例】 3
	 * 
	 * 
	 * 资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms
	 * 
	 * 
	 * 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
	 * 
	 * 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 不要使用package语句。不要使用jdk1.7及以上版本的特性。
	 * 主类的名字必须是：Main，否则按无效代码处理。
	 * 
	 * 
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		f = new long[n + 5];
		inv = new long[n + 5];
		s = new int[n + 5];
		dp = new long[n + 5];
		f[0] = 1;
		for (int i = 1; i < n + 5; i++) {
			f[i] = f[i - 1] * i % mod;
			inv[i] = mpow(f[i], mod - 2);
		}

		for (int i = n; i >= 1; i--)
			// 类似堆的找孩子
			s[i] = 1 + (2 * i <= n ? s[2 * i] : 0)
					+ (2 * i + 1 <= n ? s[2 * i + 1] : 0);// c[i]<=n所以不用取余

		for (int i = 1; i < n + 5; i++)
			dp[i] = 1;

		for (int i = n; i >= 1; i--)
			if (2 * i + 1 <= n)
				dp[i] = dp[2 * i] * dp[2 * i + 1] % mod
						* C(s[i] - 1, s[i * 2 + 1]) % mod;// C(s[i]-1,s[i*2+1])和C(s[i]-1,s[i*2])都一样,组合对称

		System.out.println(dp[1]);
	}

	static int n;
	static long mod = 1000000009;
	static long[] f;
	static long[] inv;
	static int[] s;// 记录该点的孩子节点+自身的总数
	static long[] dp;

	static long C(int n, int m) {
		return f[n] * inv[m] % mod * inv[n - m] % mod;
	}

	static long mpow(long a, long n) {// 快速幂
		if (n == 0 || a == 1)
			return 1;
		long ans = 1;
		while (n != 0) {
			if (n % 2 == 1)
				ans = a * ans % mod;
			a = a * a % mod;
			n >>= 1;
		}

		return ans;
	}

}
一人定乾坤
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝桥杯Java B组历年真题（2013年-2021年）
编程小鹏的博客
03-02 1214
蓝桥杯Java B组历年真题，使用Java语言解决算法题
2022年第十三届蓝桥杯省赛C++B组【真题解析】
热门推荐
qq_17807067的博客
10-06 1万+
2022年第十三届蓝桥杯省赛C++B组【真题解析】
蓝桥杯18年最全算法训练试题181道（含vip试题）
12-04
1.2018年12月整理，题目最新最全（181道）。 2.每个题目都有目录，方便查询。 3.包含所有VIP试题。
蓝桥杯18年B组真题
oulagong的博客
02-21 493
蓝桥杯18年B组真题 问题一：第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 代码 #include<iostream> #include<cstdio> using namespace std; int main(){ //根据题目直接算出来，需要注意2000年是闰年。 //如果是求 某天都某天的话最好构建一个方法判断闰年。 printf("%d",31+29+31+30+
18年蓝桥杯省赛C/C++B组
qq_46653910的博客
10-07 298
这里写目录标题测试次数明码乘积尾零日志统计 测试次数 x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。 各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。 x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。 如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。 特别地，如果手机从第1层扔下去就坏了，则耐摔指
蓝桥杯-排列数
Kid_TH的博客
02-13 1019
蓝桥杯-排列数题目链接使用STL->next_permutation();#include<cstdio> #include<algorithm> #include<iostream> using namespace std; int main() { int count = 0; int n; scanf("%d", &n); string s1 = "012345
2018年第九届蓝桥杯【C++省赛B组】
sunlanchang的博客
04-04 1064
1. 第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 solution 2000年是闰年，2月29天，所以是31+29+31+30+4=125天。 2. 明码 汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。 16点阵的字库把每个汉字看成是16x16个像素...
蓝桥杯2014年C语言B组
s7890987的博客
01-25 284
啤酒和饮料 啤酒每罐2.3元，饮料每罐1.9元。小明买了若干啤酒和饮料，一共花了82.3元。 我们还知道他买的啤酒比饮料的数量少，请你计算他买了几罐啤酒。 思路：循环遍历，注意精度问题，将钱数乘10计算。 因为用小数计算太麻烦了，而且容易出错误 答案是 11 #include<stdio.h> int main() { int a,b; for(a=0;a<40;a++) for(b=1;b<43;b++) { if(a>b) continue; if(a*23+b*19
蓝桥杯B组初赛2019
m0_51172044的博客
03-13 398
出自new oj1462: [蓝桥杯2019初赛]组队1463: [蓝桥杯2019初赛]年号字串 1462: [蓝桥杯2019初赛]组队 作为篮球队教练，你需要从以下名单中选出1 号位至5 号位各一名球员，组成球队的首发阵容。 每位球员担任1号位至5号位时的评分如下表所示。请你计算首发阵容1号位至5号位的评分之和最大可能是多少？ 观察图片，每一列找到最大值然后相加即可。注意一个人只能取一次 1463: [蓝桥杯2019初赛]年号字串 小明用字母A 对应数字1，B 对应2，以此类推，用Z 对应26。对于27以
2018年蓝桥杯省赛B组C++真题
小李的博客
09-19 3263
1. 第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 2. 明码 汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。 16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。 一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。 把每个字节转为2进制表示，1表示墨迹，0表示底色。每行2个字节， 一共16行，布局是： 第1字节，第2字节 第3字节，第4字节 …
2018年4月1日省赛第九届蓝桥杯真题C语言(B组)
04-01
【2018年4月1日省赛第九届蓝桥杯真题C语言(B组)】是一场针对C语言编程能力的竞赛题目集，旨在检验参赛者的编程基础、算法理解以及问题解决能力。蓝桥杯是全国知名的编程竞赛，每年吸引大量在校学生参与，特别是对...
2023第十四届蓝桥杯Java B组个人题解
最新发布
小宇的修炼之路
04-08 1万+
本文是2023年第十四届蓝桥杯Java B组个人题解，有详细的思路分析和Java代码实现，期待和大家一起交流！
2018蓝桥杯决赛之旅
子衿
07-25 2156
    不知不觉都暑假了，近两日在杭州参加了一个特坑的达内培训，上课无聊才想起来补充一下。     emmm，去年学校在北大比赛，今年却是在北京联合大学，还是有点小失落，没时间去一趟。     随行的两位老师都很随和，其中一位气质独特，童心未泯，有种和初中生一起出来玩的感觉QAQ，很有趣。     坐动车从安徽到北京也就六个小时，作为穷孩子，票价和宾馆住宿费很心痛，单人近一千（虽然是学校出）...
备考蓝桥杯（18）方格填数 java实现
Robert_Ln的博客
03-30 516
package pers.robert.lanqiaobei07; /** * 方格填数 如下的10个格子 +--+--+--+ | | | | +--+--+--+--+ | | | | | +--+--+--+--+ | | | | +--+--+--+ （如果显示有问题，也可以参看【图1.jpg】） 填入0~9的数字。要求：连续的两个数字不能相邻。 ...
读题
qq_45805029的博客
02-02 426
由于pat乙级多次读错题，从而发现原来打代码读题这么重要 1看清条件范围的作用域，不要想当然 /*1067 试密码 (20分) 当你试图登录某个系统却忘了密码时，系统一般只会允许你尝试有限多次，当超出允许次数时，账号就会被锁死。本题就请你实现这个小功能。 输入格式： 输入在第一行给出一个密码（长度不超过 20 的、不包含空格、Tab、回车的非空字符串）和一个正整数 N（≤ 10），分别是正确...
蓝桥杯18年省赛真题C/C++
浮生未歇
08-08 1087
18年省赛真题笔记1.第几天1.1思路1.2源码2.明码2.1思路2.2源码3.乘积尾零3.1思路3.2源码4.测试次数 1.第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 1.1思路 简单题，要注意的只有2000是闰年，2月 29天 1.2源码 #include<stdio.h> int main() { printf("%d",31+29+31+30+4); return 0; 2.明
18年12月蓝桥杯校赛
cprimesplus的博客
12-05 1547
前言 昨天下午参加了蓝桥杯校内选拔赛。少些抱怨，不谈别人，只谈自己，我觉得这次校赛的发挥还算正常，大概做出了5/8吧，剩下几道题没时间看了。 第一题 Excel地址 Excel单元格的地址表示很有趣，它使用字母来表示列号。 比如， A表示第1列， B表示第2列， Z表示第26列， AA表示第27列， AB表示第28列， BA表示第53列， … 当然Excel的最大列号是有限度的，所以转换起来不难。...
2018年第九届蓝桥杯省赛C/C++B组题解
仅做个人笔记
04-03 3950
“2018年第九届蓝桥杯省赛C/C++B组”题解目录：1. 第几天2. 明码3. 乘积尾零4. 测试次数5. 快速排序6. 递增三元组7. 螺旋折线8. 日志统计9. 全球变暖10. 乘积最大1. 日期 答案：1252000年的1月1日，是那一年的第1天。那么，2000年的5月4日，是那一年的第几天？方法一：表格下拉方法二：java.util.Calendar 三行代码也可以搞定2. 明码 答案：...
蓝桥杯 2018年省赛真题 (Java 大学C组)
NOW I GOT ONE WAY
10-11 7153
@ 蓝桥杯 2018 年省赛真题 (Java 大学 C 组 ) 先挂上 #1 哪天返回 问题描述 小明被不明势力劫持。后被扔到x星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。 他决定在x星战打工。好心的老板答应包食宿，第1天给他1元钱。 并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。 请计算一下，小明在第几天就能凑够108元，返回地球。 答案提交 要求提交的是一个整数，表示第几天。请不要提交任何多余的内容。 NULL calcCode： 在这里插
蓝桥杯国赛Python B组试题解析
"第十三届蓝桥杯国赛 Python B组试题包含了算法和编程实践的挑战，主要面向大学生参赛者。比赛规则强调了试题的解压、答题方式、提交答案的规范以及评分标准。比赛允许选手多次提交答案，最终以最后一次提交为准，且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值