21. 古堡算式
/*
福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：
ABCDE * ? = EDCBA
他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”
华生：“我猜也是！”
于是，两人沉默了好久，还是没有算出合适的结果来。
请你利用计算机的优势，找到破解的答案。
把 ABCDE 所代表的数字写出来。
答案写在“解答.txt”中，不要写在这里！
*/
public class TDemo02_two {
public static void main(String[] args){
for(int i=10000;i<100000;i++){
int a = i/10000;
int b = i%10000/1000;
int c = i%10000%1000/100;
int d = i%10000%1000%100/10;
int e = i%10;
if(a==b||a==c||a==d||a==e||b==c||b==d||b==e||c==d||c==e||d==e){
continue;
}
int y = e*10000+d*1000+c*100+b*10+a;
if(y%i==0){
System.out.println(i+"*"+y/i+"="+y);
}
}
}
}
运行结果：
21978*4=87912
22. 微生物增殖
/*
假设有两种微生物 X 和 Y
X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。
一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。
现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。
如果X=10，Y=90 呢？
本题的要求就是写出这两种初始条件下，60分钟后Y的数目。
题目的结果令你震惊吗？这不是简单的数字游戏！真实的生物圈有着同样脆弱的性质！也许因为你消灭的那只 Y 就是最终导致 Y 种群灭绝的最后一根稻草！
请忍住悲伤，把答案写在“解答.txt”中，不要写在这里！
*/
package Question20_29;
import java.util.Scanner;
public class Question22MustRemember {
public static void calculate(int primaryNumX,int primaryNumY,int timesOfMinute) {
int numX=primaryNumX,numY=primaryNumY;
for (int i = 2; i <=timesOfMinute*2; i++) {
if(numY<=0){
numY=0;
break;
}
if(i%2==0){
numY-=primaryNumX;// 当为整数分钟时,最初数目的生物X将进食同等数目的生物Y
}
else if(i%2==1){
numY-=(numX-primaryNumX); //当为半数分钟的奇数倍时,由最初的生物X增值产生的生物X将进食同等数目的生物Y
}
if(i%6==0){
numX*=2; //三分钟的整数倍,生物X增值一倍
}
if(i%4==0){
numY*=2; //两分钟的整数倍,生物Y增值一倍
}
}
System.out.println(numY);
}
public static void main(String[] args) {
calculate(10, 89, 60);
calculate(10, 90, 60);
// Scanner scanner=new Scanner(System.in);
// int numX=scanner.nextInt(),numY=scanner.nextInt();
// System.out.println(numX+" "+numY);
}
}
运行结果：
-979369984
94371840
94371840
23. 输入信用卡号码
/*
当你输入信用卡号码的时候，有没有担心输错了而造成损失呢？其实可以不必这么担心，
因为并不是一个随便的信用卡号码都是合法的，它必须通过Luhn算法来验证通过。
该校验的过程：
1、从卡号最后一位数字开始，逆向将奇数位(1、3、5等等)相加。
2、从卡号最后一位数字开始，逆向将偶数位数字，先乘以2（如果乘积为两位数，则将其减去9），再求和。
3、将奇数位总和加上偶数位总和，结果应该可以被10整除。
例如，卡号是：5432123456788881
则奇数、偶数位（用红色标出）分布：5432123456788881
奇数位和=35
偶数位乘以2（有些要减去9）的结果：1 6 2 6 1 5 7 7，求和=35。
最后35+35=70 可以被10整除，认定校验通过。
请编写一个程序，从键盘输入卡号，然后判断是否校验通过。通过显示：“成功”，否则显示“失败”。
比如，用户输入：356827027232780
程序输出：成功
*/
package Question20_29;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Question23 {
public static String judge(String s) {
int count=1;
int sum=0;
for (int i = s.length()-1; i >=0 ; i--,count++) {
if(count%2==1){
sum+=(s.charAt(i)-'0');
}else {
sum+=(s.charAt(i)-'0')*2>=10?(s.charAt(i)-'0')*2-9:(s.charAt(i)-'0')*2;
}
}
if(sum%10==0){
return "成功";
}else {
return "失败";
}
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String s=scanner.nextLine();
System.out.println(judge(s));
}
}
运行结果：
输入卡号:5432123456788881
成功
24. 输入日期
/*
从键盘输入一个日期，格式为yyyy-M-d
要求计算该日期与1949年10月1日距离多少天
例如：
用户输入了：1949-10-2
程序输出：1
用户输入了：1949-11-1
程序输出：31
*/
package Question20_29;
import java.util.Scanner;
public class Question24MustRemember {
public static int dayOfYear[]={365,366};//平年365天,闰年366天
public static int dayOfMonth[][]={
{0,31,28,31,30,31,30,31,31,30,31,30,31},
{0,31,29,31,30,31,30,31,31,30,31,30,31}
};
public static int dayOfYearIndex(int year){ //根据是否是闰年来给出dayOfYear的数组的下标
if((year%4==0&&year%100!=0)||year%400==0){
return 1;
}
return 0;
}
public static int dayApartFromTheBrginOfYear(int year,int month,int day){//计算month月day日是year年的第几天
int days=day;
for (int i = 1; i < month; i++) {
days+=dayOfMonth[dayOfYearIndex(year)][i];
}
return days;
}
public static int apartDays(String startDayString,String endDayString ) {
String s1[]=startDayString.split("-");
String s2[]=endDayString.split("-");
int days=0;
int flag;
int startYear=Integer.parseInt(s1[0]);
int endYear=Integer.parseInt(s2[0]);
int startMonth=Integer.parseInt(s1[1]);
int endMonth=Integer.parseInt(s2[1]);
int startDay=Integer.parseInt(s1[2]);
int endDay=Integer.parseInt(s2[2]);
for (int i = startYear; i < endYear; i++) {
days+=dayOfYear[dayOfYearIndex(i)];
}
days+=dayApartFromTheBrginOfYear(endYear,endMonth,endDay);
days-=dayApartFromTheBrginOfYear(startYear,startMonth,startDay);
return days;
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String startDayString="1949-10-01";
String endDayString=scanner.nextLine();
System.out.println(apartDays(startDayString, endDayString));
}
}
运行结果：
输入日期格式为:(1949-10-2)
输入第一个日期:1949-10-2
输入第二个日期:1949-11-2
1949-10-2 到 1949-11-2
距离31天
25. 顺时针螺旋填入
/*
从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如：
输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
*/
package Question20_29;
import java.util.Scanner;
public class Question25 {
public static void print(int[][] array) {
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length; j++) {
System.out.printf("%4d",array[i][j]);
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int array[][]=new int[n][n];
int startIndex=0,endIndex=n-1,count=1,e=0;
while (e<=n/2) {
for (int i = startIndex; i <= endIndex; i++) {
array[e][i]=count++;
}
for (int i = startIndex+1; i <= endIndex; i++) {
array[i][n-1-e]=count++;
}
for (int i = endIndex-1; i>=startIndex; i--) {
array[n-1-e][i]=count++;
}
for (int i = endIndex-1; i>startIndex; i--) {
array[i][e]=count++;
}
startIndex++;
endIndex--;
e++;
}
print(array);
}
}
运行结果：
输入一个整数:4
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
自己写的,用到的控制变量比较多,所以程序读起来容易混乱!
整体思路: (外圈实现:
1. 从(左->右)填充第一行
2.从(上->下)填充右侧一列
3.从(右->左)填充最后一行
4.从(下->上)填充左侧一列
只要最外圈能做出来,内圈同理,调整变量就可以了)
方法二:
public class Demo08_two {
public static void show(int[][] m) {
for (int[] x : m) {
for (int y : x) {
System.out.print(y + "\t");
}
System.out.println("");
}
}
public static void helix(int n, int b, int[][] a) {
int i;
int j;
int k;
for (i = 0; i < n / 2; i++) {
for (j = i; j < n - i; j++)
/* 四个循环按不同的方向进行 */
a[i][j] = ++b;
for (k = i + 1, j--; k < n - i; k++)
a[k][j] = ++b;
for (j = --k, j--; j >= i; j--)
a[k][j] = ++b;
for (k--; k > i; k--)
a[k][i] = ++b;
}
if (n % 2 != 0) /* 如果是单数的话，要加上最大的那个数放在中间 */
a[i][i] = ++b;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int i, j, k, n, b = 0;
System.out.print("输入一个整数:");
n = scan.nextInt();
int[][] a = new int[n][n];
helix(n, b, a);
show(a);
}
}
运行结果：
输入一个整数:4
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
26. Playfair密码
/*
* 一种Playfair密码变种加密方法如下：首先选择一个密钥单词（称为pair）（字母不重复，且都为小写字母），
* 然后与字母表中其他字母一起填入至一个5x5的方阵中，填入方法如下：
1.首先按行填入密钥串。
2.紧接其后，按字母序按行填入不在密钥串中的字母。
3.由于方阵中只有25个位置，最后剩下的那个字母则不需变换。
如果密钥为youandme，则该方阵如下：
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
在加密一对字母时，如am，在方阵中找到以这两个字母为顶点的矩形（红色字体）：
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
这对字母的加密字母为该矩形的另一对顶点，如本例中为ob。
请设计程序，使用上述方法对输入串进行加密，并输出加密后的串。
另外有如下规定：
1、一对一对取字母，如果最后只剩下一个字母，则不变换，直接放入加密串中；
2、如果一对字母中的两个字母相同，则不变换，直接放入加密串中；
3、如果一对字母中有一个字母不在正方形中"如z"，则不变换，直接放入加密串中；
4、如果字母对出现在方阵中的同一行或同一列，如df或hi，则只需简单对调这两个字母，即变换为fd或ih；
5、如果在正方形中能够找到以字母对为顶点的矩形，假如字母对为am，则该矩形的另一对顶点字母中，
与a同行的字母应在前面，在上例中应是ob；同样若待变换的字母对为ta，则变换后的字母对应为wo；
6、本程序中输入串均为小写字母，并不含标点、空格或其它字符。
解密方法与加密相同，即对加密后的字符串再加密，将得到原始串。
要求输入形式如下：
从控制台输入两行字符串，第一行为密钥单词（长度小于等于25），第二行为待加密字符串（长度小于等于50），
两行字符串末尾都有一个回车换行符，并且两行字符串均为小写字母，不含其它字符。
在标准输出上输出加密后的字符串。
例如，若输入：
youandme
welcometohangzhou
则表示输入的密钥单词为youandme，形成的正方形如上所示；待加密字符串为welcometohangzhou。
在正方形中可以找到以第一对字母we为顶点的矩形，对应另一对顶点字母为vb，因此加密后为vb，
同理可找到与字母对lc,et,oh,ho对应的顶点字母对。而字母对om位于上述正方形中的同一列，
所以直接以颠倒这两个字母来加密，即为mo，字母对an同理。字母对gz中的z不在上述正方形中，
因此原样放到加密串中。最后剩一个字母u也原样输出。
因此输出的结果为：
vbrmmomvugnagzguu
vbrmmomvugnagzguu
vbrmmomvugnagzguu
要求考生把所有类写在一个文件中。调试好后，存入与考生文件夹下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。请不要使用package语句。
另外，源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。
*/
package Question20_29;
import java.util.Scanner;
import java.util.Vector;
public class Question26 {
public static char initArray(char[][] array, String pair) {
Vector<Character>vector=new Vector<Character>();
for (char i = 'a'; i <='z'; i++) {
vector.add(i);
}
for (int i = 0; i < pair.length(); i++) {
vector.remove((Character)pair.charAt(i));
array[i/5][i%5]=pair.charAt(i);
}
for (int i = 0,j=pair.length() ; i < vector.size()-1; i++,j++) {
array[j/5][j%5]=vector.elementAt(i);
}
return vector.elementAt(vector.size()-1);
}
public static String passwordAfterChange(char[][] array,String password,char unUsedch) {
StringBuffer sb=new StringBuffer();
for (int i = 0; i < password.length(); i+=2) {
if(i+1<password.length()){
if(password.charAt(i)==unUsedch||password.charAt(i+1)==unUsedch){//如果一对字母中有一个字母不在正方形中"如z"，则不变换，直接放入加密串中
sb.append(password.charAt(i));
sb.append(password.charAt(i+1));
}else if (password.charAt(i)==password.charAt(i+1)) {//如果一对字母中的两个字母相同，则不变换，直接放入加密串中
sb.append(password.charAt(i));
sb.append(password.charAt(i+1));
}else {
int ch1i=0,ch1j=0,ch2i=0,ch2j = 0;
for (int j = 0; j < array.length; j++) {
for (int j2 = 0; j2 < array.length; j2++) {
if(array[j][j2]==password.charAt(i)){
ch1i=j;ch1j=j2;
}else if(array[j][j2]==password.charAt(i+1)){
ch2i=j;ch2j=j2;
}
}
}
if(ch1i==ch2i||ch1j==ch2j){//如果字母对出现在方阵中的同一行或同一列，如df或hi，则只需简单对调这两个字母，即变换为fd或ih
sb.append(password.charAt(i+1));
sb.append(password.charAt(i));
}else {
sb.append(array[ch1i][ch2j]);
sb.append(array[ch2i][ch1j]);
}
}
}else {//一对一对取字母，如果最后只剩下一个字母，则不变换，直接放入加密串中
sb.append(password.charAt(i));
}
}
return sb.toString();
}
public static void main(String[] args) {
char array[][]=new char[5][5];
Scanner scanner = new Scanner(System.in);
String pair = scanner.nextLine();
String password=scanner.nextLine();
char unUsedch=initArray(array, pair);
System.out.println(passwordAfterChange(array, password, unUsedch));
}
}
运行结果：
输入密钥单词:youandme
输入待加密字符:welcometohangzhou
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
加密结果:vbrmommvugnagzguu
解密结果:welcometohangzhou
27. 金额组合
/*
某财务部门结账时发现总金额不对头。很可能是从明细上漏掉了某1笔或几笔。
如果已知明细账目清单，能通过编程找到漏掉的是哪1笔或几笔吗？
如果有多种可能，则输出所有可能的情况。
我们规定：用户输入的第一行是：有错的总金额。
接下来是一个整数n，表示下面将要输入的明细账目的条数。
再接下来是n行整数，分别表示每笔账目的金额。
要求程序输出：所有可能漏掉的金额组合。每个情况1行。金额按照从小到大排列，中间用空格分开。
比如：
用户输入：
6
5
3
2
4
3
1
表明：有错的总金额是6；明细共有5笔。
此时，程序应该输出：
1 3 3
1 2 4
3 4
为了方便，不妨假设所有的金额都是整数；每笔金额不超过1000，金额的明细条数不超过100。
*/
package Question20_29;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Vector;
import java.util.concurrent.PriorityBlockingQueue;
import javax.swing.text.AbstractDocument.BranchElement;
public class Question27 {
public static String elementOfPriorityBlockingQueue(int array[],boolean used[]) {
PriorityBlockingQueue<Integer>priorityBlockingQueue=new PriorityBlockingQueue<Integer>();
for (int i = 0; i < used.length; i++) {
if(used[i]==true){
priorityBlockingQueue.add(array[i]);
}
}
StringBuffer sb=new StringBuffer();
while (!priorityBlockingQueue.isEmpty()) {
sb.append(priorityBlockingQueue.poll());
}
return sb.toString();
}
public static void exeForward(PriorityBlockingQueue<String>priorityBlockingQueue,int array[],boolean used[],int index,int sum,int tSum) {
if(sum>tSum){
return;
}
if(sum==tSum){
String string=elementOfPriorityBlockingQueue(array, used);
if(!priorityBlockingQueue.contains(string)){
priorityBlockingQueue.add(string);
}
return;
}
if(index<=array.length-1){
for (int i = 0; i <=1; i++) {
used[index]=(i==0?false:true);
sum+=array[index]*i;
exeForward(priorityBlockingQueue,array, used, index+1, sum, tSum);
sum-=array[index]*i;
used[index]=(i==1?false:true);
}
}else {
return;
}
}
public static void main(String[] args) {
int tSum;
int n;
Vector<Integer>vector=new Vector<Integer>();
Scanner scanner=new Scanner(System.in);
PriorityBlockingQueue<String>priorityBlockingQueue=new PriorityBlockingQueue<String>();
tSum=scanner.nextInt();
n=scanner.nextInt();
int array[]=new int[n];
boolean used[]=new boolean[n];
tSum*=(-1);
for (int i = 0; i < n; i++) {
array[i]=scanner.nextInt();
tSum+=array[i];
}
exeForward(priorityBlockingQueue,array, used, 0, 0, tSum);
while (!priorityBlockingQueue.isEmpty()) {
String string=priorityBlockingQueue.poll();
for (int i = 0; i < string.length(); i++) {
System.out.print(string.charAt(i));
if(i!=string.length()-1){
System.out.print(" ");
}
}
System.out.println();
}
}
}
运行结果：
6
5
3
2
4
3
1
输出结果:
3 4
1 3 3
1 2 4
28. 拼出漂亮的表格
/*
* 在中文Windows环境下，控制台窗口中也可以用特殊符号拼出漂亮的表格来。
比如：
┌─┬─┐
│ │ │
├─┼─┤
│ │ │
└─┴─┘
其实，它是由如下的符号拼接的：
左上 = ┌
上 = ┬
右上 = ┐
左 = ├
中心 = ┼
右 = ┤
左下= └
下 = ┴
右下 = ┘
垂直 = │
水平 = ─
本题目要求编写一个程序，根据用户输入的行、列数画出相应的表格来。
例如用户输入：
3 2
则程序输出：
┌─┬─┐
│ │ │
├─┼─┤
│ │ │
├─┼─┤
│ │ │
└─┴─┘
用户输入：
2 3
则程序输出：
┌─┬─┬─┐
│ │ │ │
├─┼─┼─┤
│ │ │ │
└─┴─┴─┘
要求考生把所有类写在一个文件中。调试好后，存入与考生文件夹下对应题号的“解答.txt”中即可。相关的工程文件不要拷入。请不要使用package语句。
另外，源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。
*/
package Question20_29;
import java.util.Scanner;
public class Question28 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int hang=scanner.nextInt(),lie=scanner.nextInt();
for (int i = 0; i < hang; i++) {
if(i==0){
System.out.print("┌─");
for (int j = 0; j < lie-1; j++) {
System.out.print("┬─");
}
System.out.println("┐");
for (int j = 0; j < lie; j++) {
System.out.print("│ ");
}
System.out.println("│");
}else {
System.out.print("├─");
for (int j = 0; j < lie-1; j++) {
System.out.print("┼─");
}
System.out.println("┤");
for (int j = 0; j < lie; j++) {
System.out.print("│ ");
}
System.out.println("│");
}
}
System.out.print("└─");
for (int j = 0; j < lie-1; j++) {
System.out.print("┴─");
}
System.out.println("┘");
//System.out.print("┌");System.out.print("─");System.out.print("┬");System.out.print("─");System.out.print("┐");
}
}
运行结果：
请输出两个数,行和列 ,例: 3 4
3 4
┌─┬─┬─┬─┐
│ │ │ │ │
├─┼─┼─┼─┤
│ │ │ │ │
├─┼─┼─┼─┤
│ │ │ │ │
└─┴─┴─┴─┘
29. 迷宫问题
/*
迷宫问题
对于走迷宫，人们提出过很多计算机上的解法。深度优先搜索、广度优先搜索是使用最广的方法。生活中，人们更愿意使用“紧贴墙壁，靠右行走”的简单规则。
下面的代码则采用了另一种不同的解法。它把走迷宫的过程比做“染色过程”。
假设入口点被染为红色，它的颜色会“传染”给与它相邻的可走的单元。
这个过程不断进行下去，如果最终出口点被染色，则迷宫有解。
仔细分析代码中的逻辑，填充缺少的部分。把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
*/
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
class Cell{ // 单元格
int row; // 哪行
int col; // 哪列
Cell from; // 开始点
public Cell(int row,int col,Cell from){
this.row = row;
this.col = col;
this.from = from;
}
}
public class T04 {
static char[][] maze = {
{'#','#','#','#','B','#','#','#','#','#','#','#'},
{'#','#','#','#','.','.','.','.','#','#','#','#'},
{'#','#','#','#','.','#','#','#','#','.','.','#'},
{'#','.','.','.','.','#','#','#','#','#','.','#'},
{'#','.','#','#','#','#','#','.','#','#','.','#'},
{'#','.','#','#','#','#','#','.','#','#','.','#'},
{'#','.','#','#','.','.','.','.','.','.','.','#'},
{'#','.','#','#','.','#','#','#','.','#','.','#'},
{'#','.','.','.','.','#','#','#','.','#','.','#'},
{'#','#','.','#','.','#','#','#','.','#','.','A'},
{'#','#','.','#','#','#','.','.','.','#','#','#'},
{'#','#','#','#','#','#','#','#','#','#','#','#'}
};
// 显示迷宫
public static void show(){
for(int i=0;i<maze.length;i++){
for(int j=0;j<maze[i].length;j++){
System.out.print(" "+maze[i][j]);
}
System.out.println();
}
}
// 染色
public static Cell colorCell(Set<Cell> from,Set<Cell> desc){
Iterator<Cell> iter = from.iterator();
while(iter.hasNext()){
Cell a = iter.next();
Cell c[] = new Cell[4];
c[0] = new Cell(a.row-1,a.col,a); // 向上走
c[1] = new Cell(a.row+1,a.col,a); // 向下走
c[2] = new Cell(a.row,a.col-1,a); // 向左走
c[3] = new Cell(a.row,a.col+1,a); // 向右走
for(int i=0;i<4;i++){
if(c[i].row<0 || c[i].row>=maze.length) continue;
if(c[i].col<0 || c[i].col>=maze[0].length) continue;
char x = maze[c[i].row][c[i].col]; // 取得单元格对应字符
if(x=='B') return a;
if(x=='.'){
maze[c[i].row][c[i].col] = '?'; // 染色
desc.add(c[i]);
}
}
}
return null;
}
//
public static void resolve(){
Set<Cell> set = new HashSet<Cell>();
set.add(new Cell(9,11,null));
for(;;){
Set<Cell> set1 = new HashSet<Cell>();
// 出口 a.from.from.from.....<-(set.get(0).from)==null<-入口
Cell a = colorCell(set,set1);
if(a!=null){ // 找到解
System.out.println("找到解!");
while(a!=null){ // 当前a里包含a.from 一直往前推
maze[a.row][a.col] = '+'; // 染色路径
a = a.from;
}
break;
}
if(set1.isEmpty()){ // 遍历所以一直到没有路走,这时 set1为空
System.out.println("无解!");
break;
}
set = set1; // 向里边
}
}
public static void main(String[] args){
show();
resolve();
show();
}
}
运行结果：
# # # # B # # # # # # #
# # # # . . . . # # # #
# # # # . # # # # . . #
# . . . . # # # # # . #
# . # # # # # . # # . #
# . # # # # # . # # . #
# . # # . . . . . . . #
# . # # . # # # . # . #
# . . . . # # # . # . #
# # . # . # # # . # . A
# # . # # # . . . # # #
# # # # # # # # # # # #
找到解!
# # # # B # # # # # # #
# # # # + . . . # # # #
# # # # + # # # # ? ? #
# + + + + # # # # # ? #
# + # # # # # ? # # ? #
# + # # # # # ? # # ? #
# + # # + + + + + + + #
# + # # + # # # ? # + #
# + + + + # # # ? # + #
# # ? # ? # # # ? # + +
# # ? # # # ? ? ? # # #
# # # # # # # # # # # #
30. 数字黑洞
/*
任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到
一个最大的数：65432，一个最小的数23456。
求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962,75933, 63954, 61974]这个循环圈。
请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。
其中5位数全都相同则循环圈为[0]，这个可以不考虑。循环圈的输出格式仿照：
[82962,75933, 63954, 61974]其中数字的先后顺序可以不考虑。
*/
package Question30_39;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Question30TooDifficultMustRemember{
public static int MaxSubMin(int n) {
StringBuffer sb=new StringBuffer(""+n);
while (sb.length()<5) {
sb.insert(0, '0');
}
char ch[]=(sb.toString()).toCharArray();
Arrays.sort(ch);
int max=(ch[4]-'0')*10000+(ch[3]-'0')*1000+(ch[2]-'0')*100+(ch[1]-'0')*10+ch[0]-'0';
int min=(ch[0]-'0')*10000+(ch[1]-'0')*1000+(ch[2]-'0')*100+(ch[3]-'0')*10+ch[4]-'0';
return max-min;
}
public static Set<Integer> blackHole(int n) {
Set<Integer> set=new LinkedHashSet<Integer>();
set.add(n);
while(true){
n=MaxSubMin(n);
if(set.add(n)==false){
Set<Integer>tSet=new LinkedHashSet<Integer>();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
Integer integer = (Integer) iterator.next();
if(integer==n){
break;
}else {
tSet.add(integer);
}
}
set.removeAll(tSet);
break;
}
}
return set;
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
// int n=scanner.nextInt();
Set<Set<Integer>>set=new LinkedHashSet<>();
for (int i = 10000; i < 100000; i++) {
set.add(blackHole(i));
}
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
Set<Integer> set2 = (Set<Integer>) iterator.next();
System.out.println(set2);
}
}
}
运行结果：
[0]
[74943, 62964, 71973, 83952]
[63954, 61974, 82962, 75933]
[53955, 59994]
31. 基因牛
/*
张教授采用基因干预技术成功培养出一头母牛，三年后，这头母牛每年会生出1头母牛，
生出来的母牛三年后，又可以每年生出一头母牛。如此循环下去，请问张教授n年后有多少头母牛?
以下程序模拟了这个过程，请填写缺失的代码。
*/
import java.util.ArrayList;
import java.util.List;
class Cow{
private int age;
public Cow afterYear(){
age++;
return age > 2 ? new Cow() : null; // 填空
}
public static void showTotalCowNum(int n){
List<Cow> list = new ArrayList<Cow>();
list.add(new Cow());
for (int i = 0; i < n; i++) {
int cowCount = list.size();
for (int j = 0; j < cowCount; j++){
Cow cow = list.get(j).afterYear();
if (cow != null){
cow.afterYear(); // 填空
list.add(cow);
}
}
}
System.out.println(n + "年后，共有：" + list.size());
}
}
class Demo05{
public static void main(String[] args){
Cow.showTotalCowNum(13);
}
}
运行结果：
13年后，共有：233
32. 最近距离
/*
已知平面上的若干点的位置，存入一个List中。现在需要计算所有这些点中，
距离最近的两个点间的最小距离。请补全缺失的代码。
把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
*/
import java.util.ArrayList;
import java.util.List;
class MyPoint{
private double x; // 横坐标
private double y; // 纵坐标
public MyPoint(double x, double y){
this.x = x;
this.y = y;
}
public static double distance(MyPoint p1, MyPoint p2){
double dx = p1.x - p2.x;
double dy = p1.y - p2.y;
return Math.sqrt(dx*dx + dy*dy);
}
/*
lst中含有若干个点的坐标
返回其中距离最小的点的距离
*/
public static double getMinDistance(List<MyPoint> lst){
if(lst==null || lst.size()<2) return Double.MAX_VALUE;
double r = Double.MAX_VALUE;
MyPoint p0 = lst.remove(0);
for(int i=0; i<lst.size(); i++){
MyPoint p = lst.get(i);
double d = MyPoint.distance(p0,p);
if(d<r) r = d; // 填空
}
double d2 = getMinDistance(lst);
return d2 < r ? d2 : r;
}
}
class Demo04{
public static void main(String[] args){
List<MyPoint> list = new ArrayList<MyPoint>() ;
list.add(new MyPoint(31,4));
list.add(new MyPoint(1,2));
list.add(new MyPoint(1,1));
list.add(new MyPoint(1,4));
System.out.println(MyPoint.getMinDistance(list));
}
}
运行结果：
1.0
33. 字符串反转
/*
我们把“cba”称为“abc”的反转串。
求一个串的反转串的方法很多。下面就是其中的一种方法，代码十分简洁（甚至有些神秘），
请聪明的你通过给出的一点点线索补充缺少的代码。
把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
*/
public class Demo03 {
public static String reverseString(String s){
if(s.length()<2||s==null) return s;
return reverseString(s.substring(1))+s.charAt(0);
}
public static void main(String[] args){
String s = "123456";
String ss = reverseString(s);
System.out.println(ss);
}
}
运行结果：
654321
34. 孪生素数
/*
所谓孪生素数指的就是间隔为 2 的相邻素数，它们之间的距离已经近得不能再近了，
就象孪生兄弟一样。最小的孪生素数是 (3, 5)，
在 100 以内的孪生素数还有 (5, 7), (11, 13), (17, 19), (29, 31),
(41, 43), (59, 61) 和 (71, 73)，总计有 8 组。
但是随着数字的增大，孪生素数的分布变得越来越稀疏，寻找孪生素数也变得越来越困难。
那么会不会在超过某个界限之后就再也不存在孪生素数了呢？
孪生素数有无穷多对！这个猜想被称为孪生素数猜想，至今没有被严格证明。
但借助于计算机我们确实可以找到任意大数范围内的所有孪生素数对。
下面的代码求出了正整数n以内（不含n）的所有孪生素数对的个数。
比如，当n=100的时候，该方法返回8。试补全缺少的代码。
把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
*/
class Demo02{
// 判断是否是素数
public static boolean isPrime(int x){
for(int i=2; i<=x/2; i++){
if(x%i==0) return false;
}
return true;
}
// 是否是孪生素数
public static int twinPrimeNum(int n){
int sum = 0;
for(int i=2; i<n; i++){
if(isPrime(i) && isPrime(i+2) && (i+2)<=n) sum++;
}
return sum; // 返回个数
}
public static void main(String[] args){
int n = 1000;
System.out.println(twinPrimeNum(n));
}
}
35. 圆周率
/*
我国古代数学家对圆周率方面的研究工作，成绩是突出的。三国时期的刘徽、南北朝时期的祖冲之都在这个领域取得过辉煌战绩。
有了计算机，圆周率的计算变得十分容易了。如今，人们创造了上百种方法求π的值。其中比较常用且易于编程的是无穷级数法。
π/4 = 1 – 1/3 + 1/5 – 1/7 + 1/9 - …
是初学者特别喜欢的一个级数形式，但其缺点是收敛太慢。
π/2 = 1 + 1/3 +1/3*2/5 + 1/3*2/5*3/7 + 1/3*2/5*3/7*4/9 + …
是收敛很快的一个级数方法。下面的代码演示了用这种方法计算π值。请填写缺失的代码部分。
把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
*/
public class Demo01 {
public static void main(String[] args){
double x = 1;
double y = 1;
int a = 1;
int b = 3;
while(y>1e-15){
y = y*a/b;<span style="white-space:pre"> </span>// 填空
x += y;
a++;
b += 2;
}
System.out.println(x*2);
}
}
36. 泊松分酒
/*
泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。
有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。
有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。
在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。
有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。
要求你只用3个容器操作，最后使得某个容器中正好有6升油。
下面的列表是可能的操作状态记录：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每行3个数据，分别表示12，8，6升容器中的油量
第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，...
当然，同一个题目可能有多种不同的正确操作步骤。
本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，
和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。
如果没有可能实现，则输出：“不可能”。
例如，用户输入：
12,8,5,12,0,0,6
用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，
最后一个数是要求得到的油量（放在哪个容器里得到都可以）
则程序可以输出（答案不唯一，只验证操作可行性）：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每一行表示一个操作过程中的油量状态。
注意：
请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！
请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。
请不要使用package语句。
源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。
*/
package Question30_39;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question36TooDifficultMustRemember {
public static List<Integer> distribute(List<Integer> capacityList,List<Integer> oilSizeList,int where,int to) {
List<Integer>tList =new ArrayList<Integer>();
tList.addAll(oilSizeList);
if(oilSizeList.get(where)==0){
return null;
}else if (oilSizeList.get(where)>=capacityList.get(to)-oilSizeList.get(to)) {
tList.set(to, capacityList.get(to));
tList.set(where, oilSizeList.get(where)-(capacityList.get(to)-oilSizeList.get(to)));
return tList;
}else if(oilSizeList.get(where)<=capacityList.get(to)-oilSizeList.get(to)){
tList.set(to, oilSizeList.get(to)+oilSizeList.get(where));
tList.set(where, 0);
return tList;
}
return null;
}
public static boolean exeForward(Set<List<Integer>>set,List<Integer> capacityList,List<Integer> oilSizeList,int NeedOilSize) {
// for (List<Integer> list : set) {
// System.out.print(list+" ");
// }
// System.out.println();
for (Integer integer : oilSizeList) {
if(integer==NeedOilSize){
for (List<Integer> list : set) {
// System.out.print(list+" ");
// System.out.print(list.size()+" ");
for (Iterator iterator = list.iterator(); iterator
.hasNext();) {
Integer integer2 = (Integer) iterator.next();
System.out.print(integer2);
if(iterator.hasNext()){
System.out.print(",");
}else {
System.out.print("\n");
}
}
}
return true;
}
}
Vector<List<Integer>>vector=new Vector<List<Integer>>();
vector.add(distribute(capacityList, oilSizeList, 0, 1));
vector.add(distribute(capacityList, oilSizeList, 0, 2));
vector.add(distribute(capacityList, oilSizeList, 1, 0));
vector.add(distribute(capacityList, oilSizeList, 1, 2));
vector.add(distribute(capacityList, oilSizeList, 2, 0));
vector.add(distribute(capacityList, oilSizeList, 2, 1));
for (int i = 0; i < vector.size(); i++) {
if(vector.get(i)!=null){
if(set.add(vector.get(i))){
if(exeForward(set, capacityList, vector.get(i), NeedOilSize)==true){
return true;
}
set.remove(vector.get(i));
}
}
}
return false;
}
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
Set<List<Integer>>set=new LinkedHashSet<List<Integer>>();
List<Integer>tList=new ArrayList<Integer>();
for (int i = 0; i < 3; i++) {
tList.add(0);
}
List<Integer> capacityList=new ArrayList<>(tList);
List<Integer> oilSizeList=new ArrayList<>(tList);
int NeedOilSize;
String ts=scanner.nextLine();
String tss[]=ts.split("\\,");
for (int i = 0; i < capacityList.size(); i++) {
capacityList.set(i, Integer.parseInt(tss[i]));
}
int totalOil=0;
for (int i = 0; i < capacityList.size(); i++) {
oilSizeList.set(i, Integer.parseInt(tss[i+3]));
totalOil+=Integer.parseInt(tss[i+3]);
}
NeedOilSize=Integer.parseInt(tss[6]);
if(NeedOilSize>totalOil){
System.out.println("不可能");
return;
}
boolean posible=false;
for (int i = 0; i < capacityList.size(); i++) {
if(capacityList.get(i)>NeedOilSize){
posible=true;
break;
}
}
if(posible==false){
System.out.println("不可能");
return;
}
exeForward(set, capacityList, oilSizeList, NeedOilSize);
}
}
运行结果：
输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6
12,8,5,12,0,0,6
12 0 0
4 8 0
4 3 5
9 3 0
9 0 3
1 8 3
1 6 5
记录数:(7)
37. 矩形的关系。
/*
在编写图形界面软件的时候，经常会遇到处理两个矩形的关系。
如图【1.jpg】所示，矩形的交集指的是：两个矩形重叠区的矩形，当然也可能不存在（参看【2.jpg】）。
两个矩形的并集指的是：能包含这两个矩形的最小矩形，它一定是存在的。
本题目的要求就是：由用户输入两个矩形的坐标，程序输出它们的交集和并集矩形。
矩形坐标的输入格式是输入两个对角点坐标，注意，不保证是哪个对角，
也不保证顺序（你可以体会一下，在桌面上拖动鼠标拉矩形，4个方向都可以的）。
输入数据格式：
x1,y1,x2,y2
x1,y1,x2,y2
数据共两行，每行表示一个矩形。每行是两个点的坐标。x坐标在左，y坐标在右。
坐标系统是：屏幕左上角为(0,0)，x坐标水平向右增大；y坐标垂直向下增大。
要求程序输出格式：
x1,y1,长度,高度
x1,y1,长度,高度
也是两行数据，分别表示交集和并集。如果交集不存在，则输出“不存在”
前边两项是左上角的坐标。后边是矩形的长度和高度。
例如，用户输入：
100,220,300,100
150,150,300,300
则程序输出：
150,150,150,70
100,100,200,200
例如，用户输入：
10,10,20,20
30,30,40,40
则程序输出：
不存在
10,10,30,30
*/
import java.awt.Rectangle;
import java.util.Scanner;
public class Demo13_Rectang {
public static Rectangle getRec(Rectangle[] rec){
Scanner scan = new Scanner(System.in);
String s = scan.nextLine();
String[] ss = s.split(",");
int x1 = Integer.parseInt(ss[0]);
int y1 = Integer.parseInt(ss[1]);
int x2 = Integer.parseInt(ss[2]);
int y2 = Integer.parseInt(ss[3]);
// 如果（x1,y1）（x2,y2）分别在（左上，右下，右上，左下）时
return new Rectangle(Math.min(x1, x2),Math.min(y1, y2),
Math.abs(x2-x1),Math.abs(y2-y1));
}
public static void op(Rectangle[] rec){
Rectangle r,rr;
if(rec[0].intersects(rec[1])){
r = rec[0].intersection(rec[1]); // 交集
System.out.println(r.x+","+r.y+","+r.width+","+r.height);
}else{
System.out.println("不存在");
}
rr = rec[0].union(rec[1]); // 并集
System.out.println(rr.x+","+rr.y+","+rr.width+","+rr.height);
}
public static void main(String[] args){
Rectangle rec[] = new Rectangle[2];
rec[0] = getRec(rec); // 第一个矩形
rec[1] = getRec(rec); // 第二个矩形
op(rec); // 输出 交集 和 并集
}
}
运行结果1：
100,220,300,100
150,150,300,300
150,150,150,70
100,100,200,200
运行结果2：
10,10,20,20
30,30,40,40
不存在
10,10,30,30
38. 测量到的工程数据
/*
[12,127,85,66,27,34,15,344,156,344,29,47,....]
这是某设备测量到的工程数据。
因工程要求，需要找出最大的5个值。
一般的想法是对它排序，输出前5个。但当数据较多时，这样做很浪费时间。
因为对输出数据以外的数据进行排序并非工程要求，即便是要输出的5个数字，
也并不要求按大小顺序，只要找到5个就可以。
以下的代码采用了另外的思路。考虑如果手里已经抓着5个最大数，再来一个数据怎么办呢？
让它和手里的数据比，如果比哪个大，就抢占它的座位，让那个被挤出来的再自己找位子,....
请分析代码逻辑，并推测划线处的代码。
答案写在 “解答.txt” 文件中
注意：只写划线处应该填的内容，划线前后的内容不要抄写。
*/
import java.util.*;
public class Demo11_B23 {
public static List<Integer> max5(List<Integer> lst) {
if (lst.size() <= 5)
return lst;
int a = lst.remove(lst.size() - 1); // 填空
List<Integer> b = max5(lst);
for (int i = 0; i < b.size(); i++) {
int t = b.get(i);
if (a > t) {
lst.set(i, a); // 填空
a = t;
}
}
return b;
}
public static void main(String[] args) {
List<Integer> lst = new Vector<Integer>();
lst.addAll(Arrays.asList(12, 127, 85, 66, 27, 34, 15, 344, 156, 344,
29, 47));
System.out.println(max5(lst));
}
}
运行结果：
[344, 344, 156, 127, 85]
39. 南北朝时
/*
* 南北朝时，我国数学家祖冲之首先把圆周率值计算到小数点后六位，比欧洲早了1100年！
* 他采用的是称为“割圆法”的算法，实际上已经蕴含着现代微积分的思想。
如图【1.jpg】所示，圆的内接正六边形周长与圆的周长近似。
多边形的边越多，接近的越好！我们从正六边形开始割圆吧。
如图【2.jpg】所示，从圆心做弦的垂线，可把6边形分割为12边形。
该12边形的边长a'的计算方法很容易利用勾股定理给出。
之后，再分割为正24边形，....如此循环会越来越接近圆周。
之所以从正六边开始，是因为此时边长与半径相等，便于计算。取半径值为1，开始割圆吧！
以下代码描述了割圆过程。
程序先输出了标准圆周率值，紧接着输出了不断分割过程中多边形边数和所对应的圆周率逼近值。
*/
public class Demo10_B21
{
public static void main(String[] args)
{
System.out.println("标准 " + Math.PI);
double a = 1;
int n = 6;
for(int i=0; i<10; i++)
{
double b = Math.sqrt(1-(a/2)*(a/2));
a = Math.sqrt((1-b)*(1-b) + (a/2)*(a/2));
n = n*2; //填空
System.out.println(n + " " + n*a/2 ); // 填空
}
}
}
运行结果：
标准 3.141592653589793
12 3.105828541230249
24 3.1326286132812378
48 3.1393502030468667
96 3.14103195089051
192 3.1414524722854624
384 3.141557607911858
768 3.1415838921483186
1536 3.1415904632280505
3072 3.1415921059992717
6144 3.1415925166921577
40. 数字的值返回
/*
以下的静态方法实现了：把串s中第一个出现的数字的值返回。
如果找不到数字，返回-1
例如：
s = "abc24us43" 则返回2
s = "82445adb5" 则返回8
s = "ab" 则返回-1
*/
public class Demo09_FirstNum {
public static int getFirstNum(String s)
{
if(s==null || s.length()==0) return -1;
char c = s.charAt(0);
if(c>='0' && c<='9') return c-'0'; //填空
return getFirstNum(s.substring(1)); //填空
}
public static void main(String[] args){
String s = "abc24us43";
System.out.println(getFirstNum(s));
}
}
运行结果：
2
664
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
