蓝桥杯2013JAVA_B省赛真题详解

最新推荐文章于 2022-05-25 20:33:26 发布
最新推荐文章于 2022-05-25 20:33:26 发布
阅读量606 收藏 6
点赞数 6
分类专栏： 蓝桥杯 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45756224/article/details/104784174
版权

1.世纪末的星期，枚举每个世纪末，判断是否为星期天 Calendar
2.马虎的算式 枚举每个位上的数字，组合判断
3.振兴中华 找重复中的变化，找边界
4.黄金连分数 1.理解问题等价于斐波那契的n/n+1的比值， 2. n要多少才足够 3.怎么处理很大的数和精度要求很高的浮点数

5.有理数类 分数通分与约分
6.三部排序 快排（三指针区间法）

7.错误票据 输入比较特殊 ， 排序 迭代（获取断号和重号），输出
8.幸运数 模拟筛选过程，动态数组的应用
9带分数 1-9用递归做全排列 对每一个排列都枚举 + 和 / 的位置 然后进行检查
10 连号区间数 枚举所有区间 检查这个区间是够连号（最大-最小）

文章目录

第一题：世纪末的星期

题目描述

曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。
还有人称今后的某个世纪末的12月31日，如果是星期一则会…
有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!
于是，“谣言制造商”又修改为星期日…
1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
请回答该年份（只写这个4位整数，不要写12月31等多余信息）

解题思路

Calendar类 水题 无编程思维 Excel也可以

import java.util.Calendar;

/**
 * @author sjf
 * @date 2020/3/9 14:08
 */
public class demo01世纪末的星期 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        for (int i = 1999; i <3999; i+=100) {
            c.set(i, 11, 31);  // 0 代表 一月 11 代表 十二月
            if (c.get(Calendar.DAY_OF_WEEK) == 1) {  // 星期日为 1  星期一为 2
                System.out.println(c.get(Calendar.YEAR));
                System.out.println(c.get(Calendar.DAY_OF_WEEK));
            }
        }
    }
}

第二题：马虎的算式

题目描述

小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。
有一次，老师出的题目是：36 x 495 = ?
他却给抄成了：396 x 45 = ?
但结果却很戏剧性，他的答案竟然是对的！！
因为 36 * 495 = 396 * 45 = 17820
类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
答案直接通过浏览器提交。
注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。

解题思路

填空题 枚举！


/**
 * @author sjf
 * @date 2020/3/9 14:35
 */
public class demo02马虎的算式 {
    public static void main(String[] args) {
        int count = 0;
        for (int a = 1; a <= 9; a++) {
            for (int b = 1; b <= 9; b++) {
                if(b!=a)
                for (int c = 1; c <= 9; c++) {
                    if(c!=a&&c!=b)
                    for (int d = 1; d <= 9 ; d++) {
                        if(d!=a&&d!=b&&d!=c)
                        for (int e = 1; e <= 9; e++) {
                            if(e!=a&&e!=b&&e!=c&&e!=d){
                                if((a*10+b)*(c*100+d*10+e)==(a*100+d*10+b)*(c*10+e))
                                    count++;
                            }
                        }
                    }
                }
            }
        }
        System.out.println(count);
    }
}

第三题：振兴中华

题目描述

小明参加了学校的趣味运动会，其中的一个项目是：跳格子。

从我做起振
我做起振兴
做起振兴中
起振兴中华
振兴中华

比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。

要求跳过的路线刚好构成“从我做起振兴中华”这句话。

请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
答案是一个整数，请通过浏览器直接提交该数字。

注意：不要提交解答过程，或其它辅助说明类的内容。

解题思路

dfs 两个方向（下，右） 不用回溯的 水题

/**
 * @author sjf
 * @date 2020/3/9 14:43
 */
public class demo03振兴中华 {
    static char[][] map = new char[4][5];
    static int ans;
    static int next[][] = {{1,0},{0,1}};
    public static void main(String[] args) {

        String[] s={"从我做起振",
                    "我做起振兴",
                    "做起振兴中",
                    "起振兴中华"};
        for (int i = 0; i <4 ; i++) {
            map[i] = s[i].toCharArray();
        }

        dfs(0,0);

        System.out.println(ans);
        
    }

    public static void dfs(int x, int y){

        int tx,ty;
        if(x==3 && y==4){
            ans++;
            return;
        }

        for (int i = 0; i <2 ; i++) {
            tx=x+next[i][0];
            ty=y+next[i][1];
            if(tx>=0&&tx<4&&ty>=0&&ty<5){
                dfs(tx,ty);
            }
        }
    }
}

第四题：黄金连分数

题目描述

黄金分割数0.61803… 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。

对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!

言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。

比较简单的一种是用连分数
黄金连分数

这个连分数计算的“层数”越多，它的值越接近黄金分割数。

请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。

小数点后3位的值为：0.618
小数点后4位的值为：0.6180
小数点后5位的值为：0.61803
小数点后7位的值为：0.6180340
（注意尾部的0，不能忽略）

你的任务是：写出精确到小数点后100位精度的黄金分割值。

注意：尾数的四舍五入！ 尾数是0也要保留！

显然答案是一个小数，其小数点后有100位数字，请通过浏览器直接提交该数字。
注意：不要提交解答过程，或其它辅助说明类的内容。

解题思路

1.100位小数，所以要用 java中的大数 BigInteger 和 BigDecimal
2.对这个连分数需要看出来规律，看一下然后发现是斐波那契数列的比
1/1 1/2 2/3 3/5 5/8 8/13 …
这道题对大数的操作有帮助 值得研究
同时有一个细节需要注意
后100位小数稳定 需要求解 101位小数
等到 101位小数稳定时，再进行四舍五入（大数操作，代码里面注释着）

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;

/**
 * @author sjf
 * @date 2020/3/9 14:56
 */
 
//double  无法保留100位小数 BigInteger
public class demo04黄金连分数 {

    public static void main(String[] args) {


        BigInteger a1 = new BigInteger("1");
        BigInteger a2 = new BigInteger("1");

        for (int i = 0; i <300 ; i++) {
            BigInteger a3= a1.add(a2);
            a1=a2;
            a2=a3;
        }

        //整数转浮点数 得设置一个位数
        //做除法 得设置 RoundingMode. HALF_UP 这就是四舍五入 最常用的
        BigDecimal ans = new BigDecimal(a1,110).divide(new BigDecimal(a2,110), RoundingMode.HALF_UP);


        System.out.println(ans.toString().substring(0,103));

        //这已经是 101 位 很精确的黄金分割数了
        //0.61803398874989484820458683436563811772030917980576286213544862270526046281890244970720720418939113748
        //四舍五入
        //0.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375

    }
}

第五题：有理数类

题目描述

有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。

这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。
/**

  • @author sjf
  • @date 2020/3/9 16:23
    */

public class demo05有理数 {
static class Rational
{
private long ra;
private long rb;

private long gcd(long a, long b){
if(b==0) return a;
return gcd(b,a%b);
}

public Rational(long a, long b){
ra = a;
rb = b;
long k = gcd(ra,rb);
if(k>1){ //需要约分
ra /= k;
rb /= k;
}
}
// 加法
public Rational add(Rational x){
return new Rational((rax.rb)+(x.rarb), rbx.rb); //填空位置
}
// 乘法
public Rational mul(Rational x){
return new Rational(rax.ra, rb*x.rb);
}
public String toString(){
if(rb==1) return “” + ra;
return ra + “/” + rb;
}
}

public static void main(String[] args) {
Rational a = new Rational(1,3);
Rational b = new Rational(1,6);
Rational c = a.add(b);
System.out.println(a + “+” + b + “=” + c);

}
}

请分析代码逻辑，并推测划线处的代码，通过网页提交
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

解题思路

虽然是一道填空题 但也不是平常的水题

分析出来 ra rb的值 代数进去运行一遍 结果还是小学学到的通分

/**
 * @author sjf
 * @date 2020/3/9 16:23
 */

public class demo05有理数 {
    static class Rational
    {
        private long ra;
        private long rb;

        private long gcd(long a, long b){
            if(b==0) return a;
            return gcd(b,a%b);
        }

        public Rational(long a, long b){
            ra = a;
            rb = b;
            long k = gcd(ra,rb);
            if(k>1){ //需要约分
                ra /= k;
                rb /= k;
            }
        }
        // 加法
        public Rational add(Rational x){
            return new Rational((ra*x.rb)+(x.ra*rb), rb*x.rb);  //填空位置
        }
        // 乘法
        public Rational mul(Rational x){
            return new Rational(ra*x.ra, rb*x.rb);
        }
        public String toString(){
            if(rb==1) return "" + ra;
            return ra + "/" + rb;
        }
    }

    public static void main(String[] args) {
        Rational a = new Rational(1,3);
        Rational b = new Rational(1,6);
        Rational c = a.add(b);
        System.out.println(a + "+" + b + "=" + c);

    }
}

第六题：三部排序

题目描述

一般的排序有许多经典算法，如快速排序、希尔排序等。

但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。

比如，对一个整型数组中的数字进行分类排序：

使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!!

以下的程序实现了该目标。

static void sort(int[] x)
{
int p = 0;
int left = 0;
int right = x.length-1;

while(p<=right){
if(x[p]<0){
int t = x[left];
x[left] = x[p];
x[p] = t;
left++;
p++;
}
else if(x[p]>0){
int t = x[right];
x[right] = x[p];
x[p] = t;
right–;
}
else{
_________________________; //代码填空位置
}
}
}

如果给定数组：
25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0
则排序后为：
-3,-2,-16,-5,0,0,0,21,19,33,25,16,18,25

请分析代码逻辑，并推测划线处的代码，通过网页提交
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

水题
答案： p++;

第七题：错误票据

题目描述

某涉密单位下发了某种票据，并要在年终全部收回。

每张票据有唯一的ID号。全年所有票据的ID号是连续的，但ID的开始数码是随机选定的。

因为工作人员疏忽，在录入ID号的时候发生了一处错误，造成了某个ID断号，另外一个ID重号。

你的任务是通过编程，找出断号的ID和重号的ID。

假设断号不可能发生在最大和最小号。

要求程序首先输入一个整数N(N<100)表示后面数据行数。
接着读入N行数据。
每行数据长度不等，是用空格分开的若干个（不大于100个）正整数（不大于100000）
每个整数代表一个ID号。

要求程序输出1行，含两个整数m n，用空格分隔。
其中，m表示断号ID，n表示重号ID

例如：
用户输入：
2
5 6 8 11 9
10 12 9

则程序输出：
7 9

再例如：
用户输入：
6
164 178 108 109 180 155 141 159 104 182 179 118 137 184 115 124 125 129 168 196
172 189 127 107 112 192 103 131 133 169 158
128 102 110 148 139 157 140 195 197
185 152 135 106 123 173 122 136 174 191 145 116 151 143 175 120 161 134 162 190
149 138 142 146 199 126 165 156 153 193 144 166 170 121 171 132 101 194 187 188
113 130 176 154 177 120 117 150 114 183 186 181 100 163 160 167 147 198 111 119

则程序输出：
105 120

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

解题思路

此题是对输入进行一个好的处理
解决方法就是利用 Scanner类里面的 hasNext（）；有效的处理了换行符

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/9 16:51
 */

public class demo07错误票据 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        in.nextLine();
        int[] num = new int[10000];
        int count = 0;// 计数器
        int dh_id = 0;// 断号id
        int cf_id = 0;// 重读id
        /**
         * 有效的处理了输入格式 把数据直接转换到一个数组中
         */
        for (int i = 0; i < N; i++) {
            Scanner sc = new Scanner(in.nextLine());
            while (sc.hasNext())  //这个作用就是啥呢？  就是 遇到回车 就跳出了
                num[count++] = sc.nextInt();
        }
        // 排序
        Arrays.sort(num, 0, count);
        // 查断号
        for (int i = 0; i < count - 1; i++) {
            if (num[i + 1] - num[i] != 1 && num[i] != num[i + 1]) {// 两个号之间不连续
                dh_id = num[i] + 1;
                break;
            }
        }
        // 查重复
        for (int i = 0; i < count - 1; i++) {
            if(num[i]==num[i+1]) {
                cf_id = num[i];break;
            }
        }
        System.out.println(dh_id + " " + cf_id);
    }
}

第八题：幸运数

题目描述

幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。

首先从1开始写出自然数1,2,3,4,5,6,…

1 就是第一个幸运数。
我们从2这个数开始。把所有序号能被2整除的项删除，变为：

1 _ 3 _ 5 _ 7 _ 9 …

把它们缩紧，重新记序，为：

1 3 5 7 9 … 。这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, …

此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,…)

最后剩下的序列类似：

1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, …

本题要求：

输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
程序输出 位于m和n之间的幸运数的个数（不包含m和n）。

例如：
用户输入：
1 20
程序输出：
5

例如：
用户输入：
30 69
程序输出：
8

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

解题思路

这肯定用 ArrayList 的动态特性
这道题做好这几点：
找到幸运数
遍历数组进行删除（这样处理不恰当，看代码）
按题目要求输出合法的幸运数

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

/**
 * @author sjf
 * @date 2020/3/9 20:36
 */

public class demo08幸运数 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> array = new ArrayList<>();
        int n=0,m=0;
        n=sc.nextInt();
        m=sc.nextInt();

		// 2 和其他幸运数不太一样 先处理一波
        for (int i = 1; i <m ; i++) {
            if(i%2!=0)
            array.add(i);
        }

        //System.out.println(array);
        int xy = 1;
        while (xy<array.size()) {
            ArrayList<Integer> array1 = new ArrayList<>();  //不能边删边遍历 只能接收
            for (int i = 0; i < array.size(); i++) {
                int temp = array.get(xy);
                if ((i + 1) % temp != 0)
                    array1.add(array.get(i));
            }
            xy++;  //下标向后走就可找到新的幸运数
            array = array1;
        }

        for (int i = 0; i <array.size() ; i++) {
            if(array.get(i)<=n) {
                array.remove(i);
                i=-1;
            }
        }

        //System.out.println(array);
        System.out.println(array.size());
    }
}

第九题：带分数

题目描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714

还可以表示为：100 = 82 + 3546 / 197

注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。

类似这样的带分数，100 有 11 种表示法。

题目要求：
从标准输入读入一个正整数N (N<1000*1000)
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！

例如：
用户输入：
100
程序输出：
11

再例如：
用户输入：
105
程序输出：
6

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

解题思路 ：
首先 是一个9的全排列 然后再枚举 “ / ” 的位置，整体说没什么技巧性的东西，熟悉的搜索的话，很快就能做出来 看熟练程度吧

import java.util.Scanner;

/**
 * 
 * @author sjf666
 * 
 * 2020年4月13日下午3:46:03
 */


//根据题意 这是9的全排列然后通过枚举 " / " 的位置来举出符合题意的形式
public class Main {

	static int[] fp = new int[9];
	static int[] book = new int[10];
	static int ans;
	static int n;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		n = sc.nextInt();

		dfs(0);

		System.out.println(ans);
	}

	
	//进行全排列
	public static void dfs(int step) {
		
		if(step == 9) {
			if(check()) 
				ans++;
			return;
		}
			
		for(int i =1;i<=9;i++) {
			if(book[i] == 0) {	
				fp[step] = i;
				book[i] = 1;
				dfs(step+1);
				book[i] = 0;
			}	
		}
		
	}
	
	public static boolean check() {
		
		int t = n;
		int numCnt = 0;
		while(t != 0) {
			numCnt++;
			t/=10;
		}
		
		
		
		for(int i = 0; i < numCnt-1; i++) {
			int sum = 0 , sums = 1;
			int temp = i;
			while(temp>=0) {
				sum+=fp[temp]*sums;
				sums*=10;
				temp--;
			}
			// " / "的位置
			for(int j = i+4; j<9;j++) {
				//计算
				int fz=0,fm=0,fzs=1,fms=1;
				for(int k = 8; k > i;k--) {
					if(k <= j) {
						fz+=fp[k]*fzs;
						fzs*=10;
					}
					else {
						fm+=fp[k]*fms;
					    fms*=10;
					}
				}
				//整数
				if(fz!=0 && fm!=0 && fz/fm == (float)fz/fm && fz/fm < n) {
					if(sum+fz/fm == n)
						return true;
					else
						return false;
				}
				
			}
		}
		return false;
	}
}

第十题：连号区间数

题目描述

小明这些天一直在思考这样一个奇怪而有趣的问题：

在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：

如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。
当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。

输入格式：
第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。
第二行是N个不同的数字Pi(1 <= Pi <= N)， 表示这N个数字的某一全排列。

输出格式：
输出一个整数，表示不同连号区间的数目。

示例：
用户输入：
4
3 2 4 1

程序应输出：
7

用户输入：
5
3 4 2 5 1

程序应输出：
9

解释：
第一个用例中，有7个连号区间分别是：[1,1], [1,2], [1,3], [1,4], [2,2], [3,3], [4,4]
第二个用例中，有9个连号区间分别是：[1,1], [1,2], [1,3], [1,4], [1,5], [2,2], [3,3], [4,4], [5,5]

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

解题思路

首先理解好题意
然后这就是遍历数组 截取不同长度的子串然后进行判断是否符合题意

import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/10 20:12
 */

/*
理解一下题
对 3 2 4 1
3 ->[1,1] 3 2 ->[1,2] 3 2 4 ->[1,3] 3 2 4 1 -> [1,4]
2 ->[2,2] 2 4 不可 2 4 1 不可
4 ->[3,3] 4 1 不可
1 ->[4,4]
ok
 */

public class demo10连号区间数 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] a = new int[N];
        int count=0;
        for (int i = 0; i <a.length ; i++) {
            a[i] = sc.nextInt();
        }

        for (int begin = 0; begin <N ; begin++) {
            int min = a[begin]; int max = a[begin];
            for (int end = begin; end <N; end++) {
                /*
                针对 连号区间 3 4 5 6 你会发现 最大值减去最小值+1 == length
                利用这个特性 大可不必把数字储存下来再排序（既浪费空间又浪费时间）
                只需 记录下来这段区间的最小值和最大值 做差然后比较 okok
                */
                if(a[end]<min)
                    min = a[end];
                if(a[end]>max)
                    max = a[end];
                if(begin==end)
                    count++;
                else if(max-min==end-begin)
                    count++;
            }
        }

        System.out.println(count);
    }
}
OpenYS
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
2013年蓝桥杯JavaB组真题
03-16
2013年蓝桥杯JavaB组真题
2018年省赛第九届蓝桥杯真题Java B组
04-01
【标题】"2018年省赛第九届蓝桥杯真题Java B组"是针对一项编程竞赛的真题集，主要针对Java语言的B组参赛者。蓝桥杯是一项国内知名的编程竞赛，旨在检验学生的算法设计和编程能力，尤其在解决实际问题上的应用。该...
2013年第四届蓝桥杯试题（Java本科B组）
Java识堂，一个有干货的微信公众号
03-18 1855
1.标题: 世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日，如果是星期一则会.... 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!  于是，“谣言制造商”又修改为星期日...... 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末
蓝桥杯省赛2013年Java组B组
galesaur_wcy
02-24 417
标题: 世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日，如果是星期一则会.... 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 于是，“谣言制造商”又修改为星期日...... 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年...
2013年蓝桥杯省赛java B组
一只蜗牛
10-06 566
涉及知识点 大数类（第四题）、日历类（第一题）、输入（第七题） 大数类 日历类 输入 in.next() 从缓冲区接收字符遇到空格后停止。 相当于 cin 和 scanf in.nextLine() 从缓冲区接收字符，并且接收空格，遇到换行才停止，并且会自动舍弃换行。 相当于 gets() in.hasNext()的返回值是bool值，作用是当在缓冲区内扫描到字符时，会返回true， 否则会发生阻塞，等待数据输入。例如： 每次输入三个整数，输出三数之和。 import java.util.Scanner;
2013蓝桥杯JavaB组
TTTianxin的博客
02-17 217
（1）第一题： 解法1：使用Calendar类 //使用默认时区和语言环境获得一个日历 Calendar cal = Calendar.getInstance(); //赋值年月日时分秒常用的6个值，注意月份从0开始，所以取月份要+1 System.out.println("年"+cal.get(Calendar.YEAR)); System.out.println("月份"+(cal.get(C...
2018年4月1日蓝桥杯省赛第九届蓝桥杯真题JAVA(C组)
04-04
【标题】2018年4月1日的“蓝桥杯”省赛是第九届蓝桥杯编程竞赛的一部分，重点考察的是JAVA语言在问题解决和算法实现中的应用。这一赛事面向C组参赛者，意味着它针对的是具有一定基础的编程学习者。 【描述】这个...
蓝桥杯java历年真题及答案整理41-56.pdf
最新发布
05-09
蓝桥杯比赛，蓝桥杯全国软件和信息技术专业人才大赛，C语言，Python，嵌入式，题库，历年真题，历年真题答案，历届试题，真题详解，蓝桥杯比赛算法题。蓝桥杯比赛竞赛资料。
蓝桥杯历年真题及答案详解+基础入门训练题
03-12
里面包含了蓝桥杯历年真题以及答案详解，有129道，都是比较典型的一些题目，都附有答案详解，本人参见过第十届蓝桥杯比赛，我是学java的所以试题都是java相关的，初次之外还另有100多到基础训练题，可以练练手。...
蓝桥杯java历年真题及答案整理(共129道题目及答案).doc
05-09
蓝桥杯比赛，蓝桥杯全国软件和信息技术专业人才大赛，C语言，Python，嵌入式，题库，历年真题，历年真题答案，历届试题，真题详解，蓝桥杯比赛算法题。蓝桥杯比赛竞赛资料。
第四届 蓝桥杯 竞赛试题题目 C/C++高职高专组
05-05
第四届“蓝桥杯”全国软件专业人才设计与创业大赛选拔赛 C/C++高职高专组 1、题目标题: 猜年龄 美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。 一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说： “我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。” 请你推算一下，他当时到底有多年轻。 通过浏览器，直接提交他那时的年龄数字。 　　　注意：不要提交解答过程，或其它的说明文字。 　　　 　　　 　　　 　　　 　　　 2、标题: 马虎的算式 　　　 　　　 　　　 小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。 　　　 　　　 有一次，老师出的题目是：36 x 495 = ? 　　　 　　　 他却给抄成了：396 x 45 = ? 　　　 　　　 但结果却很戏剧性，他的答案竟然是对的！！ 　　　 　　　 因为 36 * 495 = 396 * 45 = 17820 　　　 　　　 类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54 　　　 　　　 假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0） 　　　 　　　 能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？ 　　　 　　　 　　　请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。 　　　 　　　满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。 　　　 　　　 　　　答案直接通过浏览器提交。 　　　注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。 　　　 　　　 3、标题: 振兴中华 　　　 　　　 小明参加了学校的趣味运动会，其中的一个项目是：跳格子。 　　　 　　　 地上画着一些格子，每个格子里写一个字，如下所示：（也可参见p1.jpg） 　　　 　　　从 我 做 起 振 　　　我 做 起 振 兴 　　　做 起 振 兴 中 　　　起 振 兴 中 华 　　　 　　　 　　　 比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。 　　　 　　　 　　　 要求跳过的路线刚好构成“从我做起振兴中华”这句话。 　　　 　　　 请你帮助小明算一算他一共有多少种可能的跳跃路线呢？ 　　　 　　　答案是一个整数，请通过浏览器直接提交该数字。 　　　注意：不要提交解答过程，或其它辅助说明类的内容。 　　　a=从 　　　b=我 　　　c=做 　　　d=起 　　　e=振 　　　f=兴 　　　g=中 　　　h=华 　　　 　　　 　　　 　　　 　　　 4、标题: 幻方填空 　　　 　　　 幻方是把一些数字填写在方阵中，使得行、列、两条对角线的数字之和都相等。 　　　 　　　 欧洲最著名的幻方是德国数学家、画家迪勒创作的版画《忧郁》中给出的一个4阶幻方。 　　　 　　　 他把1,2,3,...16 这16个数字填写在4 x 4的方格中。 　　　 　　　 如图p1.jpg所示，即： 　　　 　　　16 ? ? 13 　　　? ? 11 ? 　　　9 ? ? * 　　　? 15 ? 1 　　　 　　　 表中有些数字已经显露出来，还有些用?和*代替。 　　　 　　　 请你计算出? 和 * 所代表的数字。并把 * 所代表的数字作为本题答案提交。 　　　 　　　 　　　答案是一个整数，请通过浏览器直接提交该数字。 　　　注意：不要提交解答过程，或其它辅助说明类的内容。 　　　 　　　 5、题目标题：公约数公倍数 　　　 　　　 我们经常会用到求两个整数的最大公约数和最小公倍数的功能。 　　　 　　　 下面的程序给出了一种算法。 　　　 　　　 函数 myfunc 接受两个正整数a,b 　　　 　　　 经过运算后打印出 它们的最大公约数和最小公倍数。 　　　 　　　 此时，调用 myfunc(15,20) 　　　 　　　将会输出： 　　　3 　　　60 　　　 　　　// 交换数值 　　　void swap(int *a,int *b) 　　　{ 　　　 int temp; 　　　 temp=*a; 　　　 *a=*b; 　　　 *b=temp; 　　　} 　　　 　　　void myfunc(int a, int b) 　　　{ 　　　 int m,n,r; 　　　 if(a<b) swap(&a,&b); 　　　 m=a;n=b;r=a%b; 　　　 while(r!=0) 　　　 { 　　　 a=b;b=r; 　　　 r=a%b; 　　　 } 　　　 printf("%d\n",b); // 最大公约数 　　　 printf("%d\n", ____________________________________); // 最小公倍数 　　　} 　　　 　　　 　　　请分析代码逻辑，并推测划线处的代码，通过网页提交。 　　　注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！ 　　　 　　　 6、标题：三部排序 　　　 　　　 一般的排序有许多经典算法，如快速排序、希尔排序等。 　　　 　　　 但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。 　　　 　　　 比如，对一个整型数组中的数字进行分类排序： 　　　 　　　 使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!! 　　　 　　　 以下的程序实现了该目标。 　　　 　　　 其中x指向待排序的整型数组，len是数组的长度。 　　　 　　　void sort3p(int* x, int len) 　　　{ 　　　 int p = 0; 　　　 int left = 0; 　　　 int right = len-1; 　　　 　　　 while(p<=right){ 　　　 if(x[p]<0){ 　　　 int t = x[left]; 　　　 x[left] = x[p]; 　　　 x[p] = t; 　　　 left++; 　　　 p++; 　　　 } 　　　 else if(x[p]>0){ 　　　 int t = x[right]; 　　　 x[right] = x[p]; 　　　 x[p] = t; 　　　 right--; 　　　 } 　　　 else{ 　　　 __________________________; //填空位置 　　　 } 　　　 } 　　　 　　　} 　　　 　　　 如果给定数组： 　　　 25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0 　　　 0 ,18,-2,0,16,-5,33,21,0,19,-16,25,-3,25 　　　 　　　 则排序后为： 　　　 -3,-2,-16,-5,0,0,0,21,19,33,25,16,18,25 　　　 　　　 　　　 　　　请分析代码逻辑，并推测划线处的代码，通过网页提交 　　　注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！ 　　　 　　　 7、标题：核桃的数量 　　　 　　　 小张是软件项目经理，他带领3个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是： 　　　 　　　 1. 各组的核桃数量必须相同 　　　 2. 各组内必须能平分核桃（当然是不能打碎的） 　　　 3. 尽量提供满足1,2条件的最小数量（节约闹革命嘛） 　　　 　　　程序从标准输入读入： 　　　a b c 　　　a,b,c都是正整数，表示每个组正在加班的人数，用空格分开（a,b,c<30） 　　　 　　　程序输出： 　　　一个正整数，表示每袋核桃的数量。 　　　 　　　例如： 　　　用户输入： 　　　2 4 5 　　　 　　　程序输出： 　　　20 　　　 　　　再例如： 　　　用户输入： 　　　3 1 1 　　　 　　　程序输出： 　　　3 　　　 　　　 　　　 　　　资源约定： 　　　峰值内存消耗（含虚拟机） < 64M 　　　CPU消耗 < 1000ms 　　　 　　　 　　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。 　　　 　　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 　　　 　　　注意: main函数需要返回0 　　　注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 　　　注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。 　　　 　　　提交时，注意选择所期望的编译器类型。 　　　 　　　 8、题目标题：打印十字图 　　　 　　　 小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示(可参见p1.jpg) 　　　 　　　 $$$$$$$$$$$$$ 　　　 $ $ 　　　 $$$ $$$$$$$$$ $$$ 　　　 $ $ $ $ 　　　 $ $$$ $$$$$ $$$ $ 　　　 $ $ $ $ $ $ 　　　 $ $ $$$ $ $$$ $ $ 　　　 $ $ $ $ $ $ $ 　　　 $ $ $ $$$$$ $ $ $ 　　　 $ $ $ $ $ $ $ 　　　 $ $ $$$ $ $$$ $ $ 　　　 $ $ $ $ $ $ 　　　 $ $$$ $$$$$ $$$ $ 　　　 $ $ $ $ 　　　 $$$ $$$$$$$$$ $$$ 　　　 $ $ 　　　 $$$$$$$$$$$$$ 　　　 　　　 　　　 对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。 　　　 　　　 为了能准确比对空白的数量，程序要求对行中的空白以句点（.）代替。 　　　 　　　输入格式： 　　　一个正整数 n (n<30) 表示要求打印图形的层数 　　　 　　　输出： 　　　对应包围层数的该标志。 　　　 　　　例如： 　　　用户输入： 　　　1 　　　程序应该输出： 　　　..$$$$$.. 　　　..$...$.. 　　　$$$.$.$$$ 　　　$...$...$ 　　　$.$$$$$.$ 　　　$...$...$ 　　　$$$.$.$$$ 　　　..$...$.. 　　　..$$$$$.. 　　　 　　　再例如： 　　　用户输入： 　　　3 　　　程序应该输出： 　　　..$$$$$$$$$$$$$.. 　　　..$...........$.. 　　　$$$.$$$$$$$$$.$$$ 　　　$...$.......$...$ 　　　$.$$$.$$$$$.$$$.$ 　　　$.$...$...$...$.$ 　　　$.$.$$$.$.$$$.$.$ 　　　$.$.$...$...$.$.$ 　　　$.$.$.$$$$$.$.$.$ 　　　$.$.$...$...$.$.$ 　　　$.$.$$$.$.$$$.$.$ 　　　$.$...$...$...$.$ 　　　$.$$$.$$$$$.$$$.$ 　　　$...$.......$...$ 　　　$$$.$$$$$$$$$.$$$ 　　　..$...........$.. 　　　..$$$$$$$$$$$$$.. 　　　 　　　请仔细观察样例，尤其要注意句点的数量和输出位置。 　　　 　　　 　　　资源约定： 　　　峰值内存消耗 < 64M 　　　CPU消耗 < 1000ms 　　　 　　　 　　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。 　　　 　　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 　　　 　　　注意: main函数需要返回0 　　　注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 　　　注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。 　　　 　　　提交时，注意选择所期望的编译器类型。 　　　 　　　 　　　 　　　 9、标题：带分数 　　　 　　　 100 可以表示为带分数的形式：100 = 3 + 69258 / 714 　　　 　　　 还可以表示为：100 = 82 + 3546 / 197 　　　 　　　 注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。 　　　 　　　 类似这样的带分数，100 有 11 种表示法。 　　　 　　　题目要求： 　　　从标准输入读入一个正整数N (N<1000*1000) 　　　程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。 　　　注意：不要求输出每个表示，只统计有多少表示法！ 　　　 　　　 　　　例如： 　　　用户输入： 　　　100 　　　程序输出： 　　　11 　　　 　　　再例如： 　　　用户输入： 　　　105 　　　程序输出： 　　　6 　　　 　　　 　　　资源约定： 　　　峰值内存消耗 < 64M 　　　CPU消耗 < 3000ms 　　　 　　　 　　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。 　　　 　　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 　　　 　　　注意: main函数需要返回0 　　　注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 　　　注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。 　　　 　　　提交时，注意选择所期望的编译器类型。 　　　 　　　 　　　 　　　 10、标题：剪格子 　　　 　　　 如图p1.jpg所示，3 x 3 的格子中填写了一些整数。 　　　 　　　 我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是60。 　　　 　　　 本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。 　　　 如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。 　　　 如果无法分割，则输出 0 　　　 　　　程序输入输出格式要求： 　　　 　　　程序先读入两个整数 m n 用空格分割 (m,n<10) 　　　表示表格的宽度和高度 　　　接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000 　　　程序输出：在所有解中，包含左上角的分割区可能包含的最小的格子数目。 　　　 　　　 　　　例如： 　　　用户输入： 　　　3 3 　　　10 1 52 　　　20 30 1 　　　1 2 3 　　　 　　　则程序输出： 　　　3 　　　 　　　再例如： 　　　用户输入： 　　　4 3 　　　1 1 1 1 　　　1 30 80 2 　　　1 1 1 100 　　　 　　　则程序输出： 　　　10 　　　 　　　(参见p2.jpg) 　　　 　　　 　　　资源约定： 　　　峰值内存消耗 < 64M 　　　CPU消耗 < 5000ms 　　　 　　　 　　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。 　　　 　　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 　　　 　　　注意: main函数需要返回0 　　　注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 　　　注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。 　　　 　　　提交时，注意选择所期望的编译器类型。 　　　 　　　 　　　
2013年蓝桥杯省赛JavaB题解
the blog of Lee
03-16 388
真题下载地址 需要2013年蓝桥杯JavaB组真题的可以在评论下留一下邮箱 目录 一、标题: 世纪末的星期 二、标题: 马虎的算式 三、标题: 振兴中华 四、标题: 黄金连分数 五、标题：有理数类 六、标题：三部排序 七、标题：错误票据 八、标题：幸运数 九、带分数 十、标题：连号区间数 一、标题: 世纪末的星期 使用GregorianCalendar类...
2013蓝桥杯Java B组省赛真题题解（持续更新）
黄小黄的博客
05-25 802
蓝桥杯真题题解
【2013年蓝桥杯Java-B组省赛题解】
Mxeron的博客
02-08 870
2013Java-B组省赛一、世纪末的星期（Calender类）二、马虎的算式（暴力循环）三、振兴中华（DFS搜索）四、黄金连分数（BigDecimal类）五、六为填空题跳过七、错误票据（注意输入、部分排序）（排序）八、幸运数（模拟）九、带分数（全排列、搜索）十、连号区间数（模拟） 题目主要考察对java特殊类class的掌握（Calender、BigDecimal），考察按照给定题目意思，模拟题目的能力，这里的模拟可能需要排序、搜索的帮助。未涉及DP。 一、世纪末的星期（Calender类） 标题: 世纪
第四届蓝桥杯省赛(Java B)
A0_Han的博客
02-27 239
1 标题: 世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日，如果是星期一则会… 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 于是，“谣言制造商”又修改为星期日… 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？ 请回答...
2013 第四届蓝桥杯 Java B组真题整理（附答案）
mcp3128
03-28 3731
1.世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日，如果是星期一则会....有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 于是，“谣言制造商”又修改为星期日......1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？请回答...
蓝桥杯2013年JavaB组省赛（解析+代码）
Peanut的博客
03-08 1364
第一题：世纪末的星期 题目描述 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日，如果是星期一则会… 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 于是，“谣言制造商”又修改为星期日… 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年） 的12月31日正好是星期天（即星期日）？ ...
蓝桥杯2013年JavaB组
My Blog
01-09 860
文章目录世纪末的星期马虎的算式振兴中华振兴中华优化I振兴中华优化II黄金连分数待更新 世纪末的星期 package Contest_2013; import java.util.Calendar; /** * * 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 * * 还有人称今后的某个世纪末的12月31日，如果是星期一则会.... * * 有趣的是，任...
小明是个急性子，上小学的时候经常吧老师写在黑板上的题目抄错 有一次，老师出的题目是：36x495=? 他却给抄成了：396x45=？ 但是结果很戏剧性，他的 答案是对的 因为36*495 = 39
林中有神君
03-07 1403
package day01; /** 小明是个急性子，上小学的时候经常吧老师写在黑板上的题目抄错 有一次，老师出的题目是：36x495=? 他却给抄成了：396x45=？ 但是结果很戏剧性，他的 答案是对的 因为36*495 = 396*45 = 17820 类似这样巧的情况可能还有很多，比如27*594 = 297*54 假设abcde代表1到9不同的5个数字（各不相同的数字） 能满足ab*cde=abd*ce这样的算式一共有多少种 */ public class _马虎的算式_枚举
蓝桥杯十一届b省赛真题
09-08
蓝桥杯十一届B省赛真题包含多个题目，主要考察参赛选手对编程的理解和应用能力。其中涉及到的题目类型有算法设计、编程实现以及各类数据结构的应用。 在算法设计方面，参赛选手需要通过分析问题特点，选择合适的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值