蓝桥杯2013年B组一套
import java.util.Calendar;
public class Main_1 {
/**
* 世纪末的星期
*
*
* 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。
*
* 还有人称今后的某个世纪末的12月31日，如果是星期一则会....
*
* 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!
*
* 于是，“谣言制造商”又修改为星期日......
*
* 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
*
* 请回答该年份（只写这个4位整数，不要写12月31等多余信息）
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Calendar calendar = Calendar.getInstance();
for (int year = 1999; year < 10000; year += 100) {
calendar.set(calendar.YEAR, year);
calendar.set(calendar.MONTH, 11);// 从零开始数到11为12个月
calendar.set(calendar.DAY_OF_MONTH, 31);
System.out.println(year + " " + calendar.get(calendar.DAY_OF_WEEK));// 获取星期几，在java中,星期日为1，星期六为7
if (calendar.get(calendar.DAY_OF_WEEK) == 1) {
break;
}
}
}
}
public class Main_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 这样的算式一共有多少种呢？
*
*
* 请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
*
* 满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
*
*
* 答案直接通过浏览器提交。 注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum = 0;
for (int a = 1; a < 10; a++) {
for (int b = 1; b < 10; b++) {
if (a != b)
for (int c = 1; c < 10; c++) {
if (c != a && c != b)
for (int d = 1; d < 10; d++) {
if (d != a && d != b && d != c) {
for (int e = 1; e < 10; 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)) {
sum++;
System.out
.printf("(%d * 10 + %d)* (%d* 100 + %d * 10 + %d) == (%d* 100 + %d * 10 + %d)* (%d * 10 +%d )==%d\n",
a,
b,
c,
d,
e,
a,
d,
b,
c,
e,
(a * 10 + b)
* (c
* 100
+ d
* 10 + e));
}
}
}
}
}
}
}
System.out.println(sum);
}
}
public class Main_3 {
/**
* 振兴中华
*
* 小明参加了学校的趣味运动会，其中的一个项目是：跳格子。
*
* 地上画着一些格子，每个格子里写一个字，如下所示：（也可参见p1.jpg）
*
* 从我做起振 我做起振兴 做起振兴中 起振兴中华
*
*
* 比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
*
*
* 要求跳过的路线刚好构成“从我做起振兴中华”这句话。
*
* 请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
*
* 答案是一个整数，请通过浏览器直接提交该数字。 注意：不要提交解答过程，或其它辅助说明类的内容。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int ans = f(0, 0);// 起点
System.out.println(ans);
}
private static int f(int i, int j) {
// TODO Auto-generated method stub
if (i == 3 || j == 4)// 表的边界
return 1;
return f(i + 1, j) + f(i, j + 1);// 两种走法
}
}
import java.math.BigDecimal;
import java.math.BigInteger;
public class Main_4 {
/**
* 黄金连分数
*
*
* 黄金分割数0.61803... 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。
*
* 对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，
* 其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!
*
*
* 言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。
*
* 比较简单的一种是用连分数：
*
* 1 黄金数 = --------------------- 1 1 + ----------------- 1 1 + -------------
* 1 1 + --------- 1 + ...
*
*
*
* 这个连分数计算的“层数”越多，它的值越接近黄金分割数。
*
* 请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。
*
* 小数点后3位的值为：0.618 小数点后4位的值为：0.6180 小数点后5位的值为：0.61803 小数点后7位的值为：0.6180340
* （注意尾部的0，不能忽略）
*
* 你的任务是：写出精确到小数点后100位精度的黄金分割值。
*
* 注意：尾数的四舍五入！ 尾数是0也要保留！
*
* 显然答案是一个小数，其小数点后有100位数字，请通过浏览器直接提交该数字。 注意：不要提交解答过程，或其它辅助说明类的内容。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.ONE;
for (int i = 3; i < 500; i++) {
BigInteger t = b;
b = a.add(b);
a = t;
}
BigDecimal divide = new BigDecimal(a, 110).divide(
new BigDecimal(b, 110), BigDecimal.ROUND_HALF_DOWN);
System.out.println(divide.toPlainString().substring(0, 103));
}// 0.61803398874989484820458683436563811772030917980576286213544862270526046281890244970720720418939113750
}
public class Main_5 {
/**
* 有理数类
*
* 有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。
*
* 这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。
*
* @param args
*/
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(this.ra * x.rb + x.ra * this.rb, this.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) {
// TODO Auto-generated method stub
Rational a = new Rational(1, 3);
Rational b = new Rational(1, 6);
Rational c = a.add(b);
System.out.println(a + "+" + b + "=" + c);
}
}
public class Main_6 {
/**
* 三部排序
*
* 一般的排序有许多经典算法，如快速排序、希尔排序等。
*
* 但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。
*
* 比如，对一个整型数组中的数字进行分类排序：
*
* 使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!!
*
* 以下的程序实现了该目标。 如果给定数组： 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
*
*
*
* 请分析代码逻辑，并推测划线处的代码，通过网页提交 注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！
*
* @param args
*/
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 {
p++; // 代码填空位置
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = { 25, 18, -2, 0, 16, -5, 33, 21, 0, 19, -16, 25, -3, 0 };
sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.printf(arr[i] + " ");
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main_7 {
/**
* 错误票据
*
* 某涉密单位下发了某种票据，并要在年终全部收回。
*
* 每张票据有唯一的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，否则按无效代码处理。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<Integer>();
int N = sc.nextInt();
sc.nextLine();// 换行
for (int i = 0; i < N; i++) {
String line = sc.nextLine();
String[] split = line.split(" ");
for (int j = 0; j < split.length; j++) {
list.add(Integer.parseInt(split[j]));
}
}
Collections.sort(list);
int a = 0, b = 0;
for (int i = 1; i < list.size(); i++) {
if (list.get(i) - list.get(i - 1) == 2) {
a = list.get(i) - 1;
}
if (list.get(i) - list.get(i - 1) == 0) {
b = list.get(i);
}
}
System.out.println(a + " " + b);
}
}
import java.util.Scanner;
public class Main_8 {
/**
* 幸运数
*
* 幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。
*
* 首先从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，否则按无效代码处理。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = 2 * i + 1;
}
int l = 1;
while (true) {
int p = l + 1;
for (int i = l + 1; i < n; i++) {
if ((i + 1) % a[l] == 0) {
} else {
a[p] = a[i];
p++;
}
}
for (int i = 0; i < n; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
l++;
if (a[l] >= n)
break;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= n)
break;
if (a[i] > m)
ans++;
}
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main_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
*
*
* 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
*
* 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
* 注意：主类的名字必须是：Main，否则按无效代码处理。
*
* @param args
*/
static int ans;
private static int N;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
f(arr, 0);
System.out.println(ans);
}
private static void f(int[] arr, int k) {
// TODO Auto-generated method stub
if (k == 9) {
check(arr);
return;
}
for (int i = k; i < arr.length; i++) {
int t = arr[i];
arr[i] = arr[k];
arr[k] = t;
f(arr, k + 1);
t = arr[i];
arr[i] = arr[k];
arr[k] = t;
}
}
private static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.err.println();
}
private static void check(int[] arr) {
// TODO Auto-generated method stub
for (int i = 1; i <= 7; i++) {
int num1 = toInt(arr, 0, i);
if (num1 >= N)
continue;
for (int j = 1; j <= 8 - i; j++) {
int num2 = toInt(arr, i, j);
int num3 = toInt(arr, i + j, 9 - i - j);
if (num2 % num3 == 0 && num1 + num2 / num3 == N) {
ans++;
}
}
}
}
private static int toInt(int[] arr, int pos, int len) {
// TODO Auto-generated method stub
int t = 1;
int ans = 0;
for (int i = pos + len - 1; i >= pos; i--) {
ans += arr[i] * t;
t *= 10;
}
return ans;
}
}
import java.util.Scanner;
public class Main_10 {
/**
* 连号区间数
*
* 小明这些天一直在思考这样一个奇怪而有趣的问题：
*
* 在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，否则按无效代码处理。
*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = sc.nextInt();
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int max = arr[i];
int min = arr[i];
for (int j = 1; j <= n; j++) {
if (arr[j] > max)
max = arr[j];
if (arr[j] < min)
min = arr[j];
if (i == j) {
System.out.printf("[%d,%d]\n", i, j);
ans++;
} else {
if (max - min == j - i) {
System.out.printf("[%d,%d]\n", i, j);
ans++;
}
}
}
}
System.out.println(ans);
}
}