今天是周四 是自己自习 做之前的课程的总结和消化！
附上这几天的作业 练习 和我自己的答案
Key Point
Java简介
Java技术结构
Java的跨平台特性
JDK、JRE、JVM的关系
JDK的下载及安装
HelloWorld入门程序
关键字
标识符
注释
一、 选择题
1. 下列用来编译Java文件的命令是：
A. javaB. javacC. javadocD. javapE. javah
2. Java文件编译之后产生的文件的拓展名是：
A. .javaB. .javacC. .classD. .batE. .exe
3. 对于Test.class文件而言，能够正确运行出结果的命令是：
A. javac Test.classB. javac TestC. java Test.classD. java TestE. javap Test.class
4. Java程序能够跨平台的基础是：
A. JDKB. JREC. JVMD. SDKE. J2SE
5. 下列说法正确的是：
A. 一个.java文件中只能有一个类
B. class文件的文件名和Java文件的文件名对应
C. 一个Java文件中可以有多个公共类
D. 没有主函数，程序依然能够编译
E. 即使没有主函数，程序也可以运行
6. 下列各项中是Java关键字的是：
A. constB. StringC. SystemD. mainE. finalize
7. 下列各项中可以用作标识符的是：
A. stringB. IntC. S$SD. ___E. cn.tedu.bigdata
8. 下列关于注释的说法正确的是：
A. Java中注释一共只有两种格式：单行注释、多行注释
B. 单行注释之间可以嵌套
C. 多行注释之间不能嵌套
D. 文档注释中的内容可以利用javadoc命令进行提取
E. 文档注释可以嵌套多行注释
1. Java源程序文件的后缀是_____， Java字节码文件的后缀名称是______。
2. Java程序实现可移植性，依靠的是__________。
3. Java语言的三个分支是:______，______，______。
4. 简述Java实现可移植性的基本原理。
5. 简述Java中Path的作用。
6. 简述Java中标识符的组成原则。
7. 如果在一个Java源文件中定义了1个公共类以及三个普通的类，那么编译该Java源文件会产生_个字节码文件。
8. 对于代码:
package cn.tedu.day01;
public class HelloWorld {
public static void main(String[] args){
System.out.println("Hello World !");
}
}
1)假设这个代码在hello.java文件中，那这个程序能否编译通过？为什么？如果不通过应该怎么改？
2)假设这个.java文件放在C:\javafile目录下，该如何运行这个Java文件？
三、 编程题
1. 在屏幕上输出:I Love Java。
Key Point
计算机常量(字面量)
进制及其转换
变量
数据类型及其转换
运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
位运算符
三元运算符
一、 选择题
1. 下列关于计算机常量的说法正确的是：
A. "2"是整数常量
B. 2.0是整数常量
C. '2'是字符常量
D. "2.0"是小数常量
E. '2.0'是小数常量
2. 3.15e2表示的数据是:
A 3.15×2B. 3.15×2-2C. 3.15×22D. 3.15×10-2E. 3.15×102
3. 下列各项可以正确赋值的是：
A. int i = 'a';B. float f = -2;C. byte b = 128;D. double d = 100d;E. char c = 97;
4. 运算符优先级别由高向低排序正确的是：
A. ()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；
B. ()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；
C. ()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；
D. ()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；
E. ()、逻辑运算符、关系运算符、!、算术运算符、赋值运算符
5. 对于下列各项能够正确编译的是：
A. byte b = 5; b = b + 1;B. byte a = 3,b = 5; byte c = a + b;
C. byte b = 127; b ++;D. byte b = 127; b += 3;
E. byte b = 5; b += 'a';
6. 对于下列程序：
public static void main(String[] args){
int a = 3, b = 4, c = 5;
boolean d = a > b && c++ > 4;
System.out.println(c + "," + d);
}
}
的运行结果是：
A. 5,trueB. 5,falseC. 6,trueD. 6,falseE. 编译错误
7. 对于int a = 3,b = 4;下列各项能够正确交换两个数的值的是：
A. int c = a; a = b; b = c;B. a += b; b = a - b; a -= b;
C. a ^= b; b ^= a; a ^= b;D. int c = b; b = a; a = c;
E. int c = a + b; a = c - a; b = c -a;
8. 对于代码：
public class Test {
public static void main(String[] args){
System.out.println(1.0 / 0);
}
}
的运行结果是：
A. 0B. InfinityC. -InfinityD. NaNE. 运行时报错
9. 对于代码：
public class Test {
public static void main(String[] args){
int i = 5;
int j = 2 * i++ + 3 * ++i;
System.out.println(j);
}
}
的运行结果是：
A. 31B. 32C. 33D. 34E. 35
10. 下列说法正确的是：
A. 2 + 3 + "a"的结果是23a
B. 'a' + 2 + 3的结果是a23
C. 2 + 'a' + 3的结果是2a3
D. 2 + 'a'的结果是99
E. "a" + true的结果是atrue
二、 简答题
1. 简述常量与变量的区别
2. 有如下代码：
int b = (a++) + (--a) +(++a);
问执行完之后， b 的结果是多少？
3. 一家商场在举行打折促销，所有商品都进行8 折优惠。一位程序员把这个逻辑写成：
short price = ...; // 先计算出原价
short realPrice = price * 8 / 10; //再计算出打折之后的价格
问：这段代码是否正确？如果正确，假设price 为100，那计算之后的realPrice值为多少？如果不正确，应该怎么改正？
4. 请说明>>与>>>之间的区别。
5. 分别计算7和-9的原码、反码、 补码。
6. 有如下代码：
a = (a>b)?a:b;
请问这段代码完成什么功能。
7. 请最有效率的计算2*8的值。
8. 对于int i = 3, j = 5;请写出能够交换i和j的值的方式并比较各种方式的优劣性。
Key Point
判断结构
if
if-else
if-else-if
选择结构
switch-case
循环结构
while
do-while
for
break和continue
一、 选择题
1. 对于代码：
public class Test {
public static void main(String[] args){
int i = 3;
if(i < 3)
System.out.println("haha");
System.out.println("hehe");
}
}
的输出结果是：
A. hahaB. heheC. haha heheD. hehe hahaE. 编译时报错
2. 对于代码：
public class Test {
public static void main(String[] args){
int i = 0;
while(i<10);
{
System.out.println(i);
i++;
}
}
}
A. 0B. 1C. 10D. 编译报错 E. 没有输出
3. 对于代码：
public class Test {
public static void main(String[] args){
int i = 5;
swich(i){
default:
int y = 5;
case 4:
y += 4;
case 3:
y += 3;
break;
case 2:
y += 2;
case 1:
y += 1;
}
System.out.println(y);
}
}
的运行结果是：
A.15B. 12C. 9D. 5E. 编译时报错
4. 对于代码：
public class Test {
public static void main(String[] args){
Outer:for(int i = 1; i < 3 ; i++) {
Inner:for(int j = 1; j < 3; j++) {
if(j == 2)
continue Outer;
System.out.println(i + “,” + j);
}
}
}
}
的运行结果是：
A. 1,1B. 1,2C. 2,1D. 2,2E. 编译时报错
二、 编程题
1. 读入一个整数，表示一个人的年龄。如果小于6 岁，则输出“儿童”，6 岁到13 岁，输出“少儿”； 14 岁到18 岁，输出“青少年”； 18
岁到35 岁，输出“青年”； 35 岁到50 岁，输出“中年”； 50 岁以上输出“中老年”。
2. 读入一个整数，如果是1~5 之间，则分别输出5 个福娃的名字，否则输出“北京欢迎你”。
3. 读入三个整数，输出这三个整数中最大的一个.
4. 读入一个表示年份的整数，判断这一年是否是闰年。如何判断一个年份是否是闰年：
1)如果这个年份能够被4 整除，且不能被100 整除，则这一年是闰年。例如， 1996 年是闰年，而相应的， 1993 年就不是闰年。
2)如果这个年份能够被100 整除，则这个数必须要能被400 整除，才是闰年。例如， 2000 年是闰年， 1900 年不是闰年。
5. 完成一个简单的计算器程序。程序要求如下：
1)读入两个整数
2) 提示用户选择对这两个整数的操作，即输出
1 ： +
2 ： -
3 ： *
4 ： /
请输入您的选择：
读入用户的选择，输出运算结果。
6. 托运计费问题：
当货物重量小于20公斤的时候，收费5元，大于20公斤小于100公斤的时候超出20公斤的部分按每0.2元每公斤计费，如果超出100公斤的
时候，超出的部分按照每公斤0.15元计算。
读入货物的重量，输出计算之后货物的运费。
7. 读入一个三位数，计算其各位数字之和。例如： 123,各位数字之和为6
8. 计算1+2+3+...+100 的和
9. 计算1+3+5+...+99 的和
10. 读入一个小于10 的整数n，输出它的阶乘n!
11. 求100 以内所有能被3 整除但不能被5 整除的数字的和。
12. “百钱买百鸡”是我国古代的著名数学题。题目这样描述：3文钱可以买1只公鸡，2文钱可以买一只母鸡，1文钱可以买3只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
13. 搬砖问题：36块砖，36人搬，男搬4，女搬3，两个小孩抬1砖，要求一次全搬完，问男、女和小孩各若干？
14. 编程找出四位整数abcd 中满足下述关系的数:(ab+cd)(ab+cd)=abcd
15. 读入一个整数n，输出如下图形:
当输入 n=3时，输出:
当输入n=4时，输出:
16. 输出99 乘法表
17. 求水仙花数。所谓水仙花数，是指一个三位数abc，如果满足a3 + b3 + c3 = abc，则abc是水仙花数。
18. 输入一个整数， 计算它各位上数字的和。（注意：是任意位的整数）
19. 输入一整数A，判断它是否质数。
20. 如果一个数等于其所有因子之和,我们就称这个数为"完数",例如6 的因子为1,2,3,6=1+2+3,6就是一个完数.请编程打印出1000 以内所
有的完数
21. 计算圆周率:中国古代数学家研究出了计算圆周率最简单的办法:PI=4/1-4/3+4/5-4/7+4/9-4/11+4/13-4/15+4/17......这个算式
的结果会无限接近于圆周率的值,我国古代数学家祖冲之计算出,圆周率在3.1415926和3.1415927 之间,请编程计算,要想得到这样的结
果,他要经过多少次加减法运算?
22. 已知：faibonacci（费波那契）数列的前几个数分别为0，1，1，2，3，5……。从第3 项开始，每一项都等于前两项的和。读入一个整数
n，编程求出此数列的前n 项。
23. 一个int 类型的整数由32 个二进制位组成，每个二进制位的值要么为0要么为1。要求读入一个int 类型的整数n，计算它的32 个二进
制位中总共有多少位为1？
一维数组
数组的定义
数组的应用
获取数组元素
获取数组的长度
数组的遍历
获取最值(最大值/最小值)
数组排序
元素查找
数组反转
数组的扩容
数组的内存
二维数组
二维数组的定义
二维数组的使用
二维数组的内存
一、 选择题
1. 下列关于数组的说法正确的是：
A. 在Java中数组的长度是可变的
B. 数组中存储的数据的类型是相同的
C. 数组在进行扩容操作的时候源数组的地址不发生改变
D. int[] arr = new int[3]; arr = new int[10];是将数组的大小扩容到了10且数组中的元素依然保留了下来
E. 数组是存储到栈内存中的。
2. 下列各项中关于数组的定义正确的是：
A. int[][] arr = new int[2][];B. int[2][] arr = new int[][3];
C. int[] arr[] = new int[2][2];D. int arr[][] = new int[3][];
E. int[3][3] arr = new int[][];
3. 已知数组int[] x,y[]都已经初始化，则下列各项能够正确赋值的是：
A. y = x;B. y[0] = x;C. y = x[0];D. y[0] = x[0];E. y[0][0] = x[0];
4. 下列数组的声明有哪些是对的？错的应该怎么修改？
A. int[] a;
B. int a[] = new int[3];
C. int[] a;
a = {1,2,3,4,5};
D. int[] a = new int[3]{1,2,3};
1. 自定义一个整数数组arr，读入一个整数n，如果n在数组中存在，则输出n的下标；如果不存在，则输出-1
2. 已知一个二维数组A表示一个矩阵,求AT.
其中AT表示矩阵A的转置。矩阵转置的含义：表示将一个矩阵的行列互换。例如有下面的矩阵M:
3. 给定一个数组将这个数组中所有元素的顺序进行颠倒
4. 输出杨辉三角
杨辉三角如下：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
......
杨辉三角的特点：
1) 第i行有i个元素
2) 每一行的每一个元素和最后一个元素都是1
3) 除了1之外，每个元素的值都等于上一行同位置的元素以及前一个元素的和。
要求：输入一个数，输出对应的行数
5. 15个猴子围成一圈选大王，依次1-7循环报数，报到7的猴子被淘汰，直到最后一只猴子成为大王。问：哪只猴子会成为大王？
6. 螺旋填数.
读入两个整数m,n，输出一个m行n列的矩阵，这个矩阵是1~m*n这些自然数按照右、下、左、上螺旋填入的结果。
例如读入数字4,5，则输出结果为：
1 2 3 4 5
141516176
132019187
1211109 8
我做的:
one_day
1.B 2.C 3.D 4.C 5.B 6.ABCD 7.D
1..java .class
2.Java虚拟机
3.JavaME JavaSE JavaEE
4.
基于JVM。针对不同的操作系统开发了不同的虚拟机，将java程序交给虚拟机，虚拟机转化为当前操作系统所能理解的指令，然后操作系统再根据指令执行代码。
5.
找到Java的文件路径
6.
可以使用字母（常见语言的基本字符）、数字、_、$，虽然可以使用$,但是尽量减少使用
可以使用中文命名，但是不推荐
不能使用关键字
数字不能开头
区分大小写
见名知意
7.3
8.
(1)不能 类名和文件名不一样 把hello.java 改为HelloWorld.java
(2)可以 cd c:\javafile
然后再 javac 文件名.java
class One_HomeWorke
{
public static void main(String[] args)
{
System.out.println("I Love Java。");
}
}
two_day
1.C
2.E
3.ABDE
4.A
5.CDE
6.B
7.ABCDE
8.B
9.A
10.ADE
1.常量的值一旦初始化就是不可变的 声明之后必须初始化 变量是可变的
2.16
3.
Scanner s=new Scanner(System.in);
double price =s.nextDouble();
double realPrice=price*8/10;
4.>>是右移
如果对正数右移 则左面补0
如果对负数右移 则左面补1
整数越移越小 最小为0
负数越移越大 最大为-1
>>是无符号右移
不论正负 左面都补0
可以把负数变为正数
5.
7：原码=反码=补码=00000000 00000000 00000000 00000111
-9:原码=10000000 00000000 00000000 00000000 00001001
反码=11111111 11111111 11111111 11110110
补码=11111111 11111111 11111111 11110111
6.找出a，b中的较大的
7.2<<3
8.
int i=3,j=5;
(理论来说数值的都可以 但是小数会有失真 )
i=i+j;
j=i-j;
i=i-j;
(正能局限于整数)
i=i^j;
j=i^j;
i=i^j;
(可以是任意的同种类型)
int z=i;
i=j;
j=z;
three_day
1.A 2.A 3.B 4.AC
代码见文件 Test.java
four_day
1.B 2.ACD 3.BE 4.C int[] a={1,2,3,4,5};
代码见文件 Test.java
import java.util.*;
public class Test {
public static void main(String[] args){
/*
1. 读入一个整数，表示一个人的年龄。如果小于6 岁，则输出“儿童”，6 岁到13 岁，输出“少儿”； 14 岁到18 岁，输出“青少年”； 18岁到35 岁，输出“青年”； 35 岁到50 岁，输出“中年”； 50 岁以上输出“中老年”。
2. 读入一个整数，如果是1~5 之间，则分别输出5 个福娃的名字，否则输出“北京欢迎你”。
3. 读入三个整数，输出这三个整数中最大的一个.
4. 读入一个表示年份的整数，判断这一年是否是闰年。如何判断一个年份是否是闰年：
1)如果这个年份能够被4 整除，且不能被100 整除，则这一年是闰年。例如， 1996 年是闰年，而相应的， 1993 年就不是闰年。
2)如果这个年份能够被100 整除，则这个数必须要能被400 整除，才是闰年。例如， 2000 年是闰年， 1900 年不是闰年。
5. 完成一个简单的计算器程序。程序要求如下：
1)读入两个整数
2) 提示用户选择对这两个整数的操作，即输出
1 ： +
2 ： -
3 ： *
4 ： /
请输入您的选择：
读入用户的选择，输出运算结果。
6. 托运计费问题：
当货物重量小于20公斤的时候，收费5元，大于20公斤小于100公斤的时候超出20公斤的部分按每0.2元每公斤计费，如果超出100公斤的时候，超出的部分按照每公斤0.15元计算。读入货物的重量，输出计算之后货物的运费。
7. 读入一个三位数，计算其各位数字之和。例如： 123,各位数字之和为6
8. 计算1+2+3+...+100 的和
9. 计算1+3+5+...+99 的和
10. 读入一个小于10 的整数n，输出它的阶乘n!
11. 求100 以内所有能被3 整除但不能被5 整除的数字的和。
12. “百钱买百鸡”是我国古代的著名数学题。题目这样描述：3文钱可以买1只公鸡，2文钱可以买一只母鸡，1文钱可以买3只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
13. 搬砖问题：36块砖，36人搬，男搬4，女搬3，两个小孩抬1砖，要求一次全搬完，问男、女和小孩各若干？
14. 编程找出四位整数abcd 中满足下述关系的数:(ab+cd)(ab+cd)=abcd
15. 读入一个整数n，输出如下图形:
当输入 n=3时，输出:
*
***
*****
当输入n=4时，输出:
*
***
*****
*******
16. 输出99 乘法表
17. 求水仙花数。所谓水仙花数，是指一个三位数abc，如果满足a^3 + b^3 + c^3= abc，则abc是水仙花数。
18. 输入一个整数， 计算它各位上数字的和。（注意：是任意位的整数）
19. 输入一整数A，判断它是否质数。
20. 如果一个数等于其所有因子之和,我们就称这个数为"完数",例如6 的因子为1,2,3,6=1+2+3,6就是一个完数.请编程打印出1000 以内所有的完数
21. 计算圆周率:中国古代数学家研究出了计算圆周率最简单的办法:PI=4/1-4/3+4/5-4/7+4/9-4/11+4/13-4/15+4/17......这个算式的结果会无限接近于圆周率的值,我国古代数学家祖冲之计算出,圆周率在3.1415926和3.1415927 之间,请编程计算,要想得到这样的结果,他要经过多少次加减法运算?
22. 已知：faibonacci（费波那契）数列的前几个数分别为0，1，1，2，3，5……。从第3 项开始，每一项都等于前两项的和。读入一个整数n，编程求出此数列的前n 项。
23. 一个int 类型的整数由32 个二进制位组成，每个二进制位的值要么为0要么为1。要求读入一个int 类型的整数n，计算它的32 个二进
制位中总共有多少位为1？
*/
/////1/////////
// int n=InputInt();
// String str=n>50?"老年人":(n>35?"中年":(n>18?"青年":(n>14?"青少年":(n>6?"少儿":"儿童"))));
// System.out.println(str);
/////2/////////
// int n=InputInt();
// switch(n)
// {
// case 1:
// System.out.println("老大");
// break;
// case 2:
// System.out.println("老二");
// break;
// case 3:
// System.out.println("老三");
// break;
// case 4:
// System.out.println("老四");
// break;
// case 5:
// System.out.println("老五");
// break;
// default:
// System.out.println("北京欢迎你");
// }
///////3/////////
// int a=InputInt();
// int b=InputInt();
// int c=InputInt();
// int max=a>b?(a>c?a:c):(b>c?b:c);
// System.out.println(max);
/////4/////////
// int year=InputInt();
// String str=(year%400)==0?"闰年":((year%4==0)?"闰年":"平年");
// System.out.println(str);
//////////5/////////
// System.out.println("请输入要计算的第一个数");
// double a=InputNumber();
// System.out.println("请输入要计算的第二个数");
// double b=InputNumber();
// System.out.println("请输入要计算的运算方法（+ - * /）");
// String str=InputString();
// switch(str)
// {
// case "+":
// System.out.println(a+"+"+b+"="+(a+b));
// break;
// case "-":
// System.out.println(a+"-"+b+"="+(a-b));
// break;
// case "*":
// System.out.println(a+"*"+b+"="+(a*b));
// break;
// case "/":
// System.out.println(a+"/"+b+"="+(a/b));
// break;
// default :
// System.out.println("error");
// }
////////////6////////////
// int n=InputInt();
// double money=(n<20)?5:(n<100?(5+(n-20)*0.2):(5+100*0.2+(n-100)*0.15));
// System.out.println(money);
////////////7//////////////
// int n=InputInt();
// int count=10;
// int sum=0;
// while(n/count>10)
// {
// count*=10;
// }
// while(count>0&&n/count<10)
// {
// sum+=n/count;
// n=n-n/count*count;
// count/=10;
// }
// System.out.println(sum);
///////////8//////////////
// int sum=0;
// for(int i=1;i<=100;i++)
// {
// sum+=i;
// }
// System.out.println(sum);
///////////9/////////////
// int sum=0;
// for(int i=1;i<=100;i+=2)
// {
// sum+=i;
// }
// System.out.println(sum);
////////////10////////////
// int n=InputInt();
// int sum=1;
// for(int i=2;i<=n;i++)
// {
// sum*=i;
// }
// System.out.println(sum);
///////////11////////////
// int sum=0;
// for(int i=3;i<=100;i+=3)
// {
// if(i%5!=0)
// {
// sum+=i;
// }
// }
// System.out.println(sum);
//////////12//////////////////
// for(int i=0;i<=33;i++)
// {
// for(int j=0;j<=50;j++)
// {
// int k=(100-i-j);
// if(i*3+j*2+k/3==100)
// {
// System.out.println("公鸡 "+i+"母鸡 "+j+"小鸡 "+k);
// }
// }
// }
//////////13//////////////////
// int z=36;
// for(int i=0;i<=36;i++)
// {
// for(int j=0;j<=36-i;j++)
// {
// for(int k=0;k<=36-i-j;k+=2)
// {
// if(i*4+j*3+k/2*1==36)
// {
// System.out.println(i+" "+j+" "+k);
// }
// }
// }
// }
////////////14/////////////////
// for(int i=1;i<=9;i++)
// {
// for(int j=0;j<=9;j++)
// {
// if(j==i){continue;}
// for(int k=0;k<=9;k++)
// {
// if(k==i||k==j){continue;}
// for(int l=0;l<=9;l++)
// {
// if(l==i||l==j||l==k){continue;}
// int a=i*10+j;
// int b=k*10+l;
// int c=i*1000+j*100+k*10+l;
// if((a+b)*(a+b)==c)
// {
// System.out.println(c);
// }
// }
// }
// }
// }
/////////////15//////////////
// int n = InputInt();
// for(int i=1;i<=n;i++)
// {
// for(int j=((n-i+1)*2-1)/2;j>0;j--)
// {
// System.out.print(" ");
// }
// for(int j=i*2-1;j>0;j--)
// {
// System.out.print("*");
// }
// System.out.print("\n");
// }
////////////16///////////////
// for(int i=1;i<=9;i++)
// {
// for(int j=i;j<=9;j++)
// {
// System.out.printf("%d*%d=%2d ",i,j,i*j);
// }
// System.out.printf("\n");
// }
// for(int i=1;i<=9;i++)
// {
// for(int j=i;j>0;j--)
// {
// System.out.printf("%d*%d=%2d ",i,j,i*j);
// }
// System.out.printf("\n");
// }
//////单个for九九乘法表///////
// for(int i=1,j=1;i<=9;j++)
// {
// System.out.print(j+"*"+i+"="+i*j+"\t");
// if(i==j)
// {
// System.out.print("\n");
// i++;
// j=0;
// }
// }
////////////判断质数////////////
// int n=InputInt();
// if(n<1)
// {
// System.out.println(n+"不是质数！");
// }
// if(n==1)
// {
// System.out.println(n+"既不是质数也不是合数！");
// }
// if(n==2||n==3)
// {
// System.out.println(n+"是质数");
// }
// for(int i=2;i<=n/2;i++)
// {
// if(n%i==0)
// {
// System.out.println(n+"不是质数");
// break;
// }
// if(i==n/2)
// {
// System.out.println(n+"是质数");
// }
// }
//////////17///////////
// for(int i=1;i<=9;i++)
// {
// for(int j=0;j<=9;j++)
// {
// if(j==i){continue;}
// for(int k=0;k<=9;k++)
// {
// if(k==i||k==j){continue;}
// int a=i*i*i;
// int b=j*j*j;
// int c=k*k*k;
// int d=i*100+j*10+k;
// if(a+b+c==d)
// {
// System.out.println(d);
// }
// }
// }
// }
//////////18////////////
// int n=InputInt();
// int count=10;
// int sum=0;
// while(n/count>10)
// {
// count*=10;
// }
// while(count>0&&n/count<10)
// {
// sum+=n/count;
// n=n-n/count*count;
// count/=10;
// }
// System.out.println(sum);
////////////19////////////
// int n=InputInt();
// if(n<1)
// {
// System.out.println(n+"不是质数！");
// }
// if(n==1)
// {
// System.out.println(n+"既不是质数也不是合数！");
// }
// if(n==2||n==3)
// {
// System.out.println(n+"是质数");
// }
// for(int i=2;i<=n/2;i++)
// {
// if(n%i==0)
// {
// System.out.println(n+"不是质数");
// break;
// }
// if(i==n/2)
// {
// System.out.println(n+"是质数");
// }
// }
////////20/////////
// System.out.println("请输入一个数");
// int n=InputInt();
// for(int j=1;j<n;j++)
// {
////遍历1至（n-1）
// int sum=0;
// for(int i=1;i<j;i++)
// {
////找到1至（j-1）内所有的质数 求和
// if(j%i==0)
// {
// sum+=i;
// }
// }
// if(sum==j)
// {
// System.out.println(j+"是一个完数");
// }
// }
/////////21//////////
// double p=0;
// int j=0;
// for(int i=1;i<=100000000;i++)
// {
// if(i%2==1)
// {
// j++;
// if(j%2==1)
// {
// p+=4.0/i;
// }
// else
// {
// p-=4.0/i;
// }
// if(3.1415926<p&&p<3.1415927)
// {
// System.out.println("需要经过"+j+"次运算");
// break;
// }
// }
// }
/////////22/////////
// int n=InputInt();
// int a=0;
// int b=1;
// int sum=0;
// if(n>0)
// {
// sum+=a;
// }
// if(n>1)
// {
// sum+=b;
// }
// if(n>2)
// {
// for(int i=3;i<=n;i++)
// {
// int c=a+b;
// a=b;
// b=c;
// sum+=c;
// }
// }
// System.out.println(sum);
////////质因数////////不能被质数整除就不能被 质数的倍数整除
// int n=InputInt();
// for(int i=2;i<=n;i++)
// {
// if(i==2)
// {
// if(n%i==0)
// System.out.printf("%d ",i);
// }
// else
// {
// for(int j=2;j<=i-1;j++)
// {
// if(i%j==0)
// {
// break;
// }
// if(j==i-1)
// {
// if(n%i==0)
// System.out.printf("%d ",i);
// }
// }
// }
// }
// System.out.println();
// for(int i=2;n!=1;)
// {
// if(n%i==0)
// {
// System.out.println(i);
// n/=i;
// }
// else
// {
// i++;
// }
// }
////////23////////
// int n=InputInt();
// int count=0;
// while(n!=0)
// {
// if((n&1)==1)
// {
// count++;
// }
// n=n>>>1;
// }
// System.out.println(count);
// int m=InputInt();
// int count1=0;
// while(m!=0)
// {
// if(m%2!=0)
// {
// count1++;
// }
// m/=2;
// }
// System.out.println(count1);
/////////////////////////数组////////////////////////////////////
// int n=InputInt();
// int arr[]=new int[n];
// for(int i=1;i<=n;i++)
// {
// arr[i-1]=InputInt();
// }
///////整体以字符串进行输出//////
//System.out.println(Arrays.toString(arr));
//////Arrays.sort(arr) 进行排序//////
// Arrays.sort(arr);
////最大值///////
// int max=arr[0];
// for(int i=1;i<n;i++)
// {
// if(arr[i]>max)
// {
// max=arr[i];
// }
// else
// {
// continue;
// }
// }
// System.out.println(max);
//////下标////////
// max=0;
// for(int i=1;i<n;i++)
// {
// if(arr[i]>arr[max])
// {
// max=i;
// }
// else
// {
// continue;
// }
// }
// System.out.println(arr[max]);
////////冒泡/////////
/////////单重for/////////
// for(int i=1,j=0;i<n-j;i++)
// {
// if(arr[i]<arr[i-1])
// {
// int t=arr[i];
// arr[i]=arr[i-1];
// arr[i-1]=t;
// }
// if(i==n-j-1)
// {
// i=0;
// j++;
// }
// }
/////////双重for////////////
// for(int i=1;i<n;i++)
// {
// for(int j=1;j<=n-i;j++)
// {
// if(arr[j-1]>arr[j])
// {
// int t=arr[j];
// arr[j]=arr[j-1];
// arr[j-1]=t;
// }
// }
// }
/////////////选择排序//////////////
// for(int i=1;i<arr.length;i++)
// {
// for(int j=i;j<arr.length;j++)
// {
// if(arr[i-1]>arr[j])
// {
// int t=arr[j];
// arr[j]=arr[i-1];
// arr[i-1]=t;
// }
// }
// }
// for(int i=1;i<=n;i++)
// {
// System.out.printf(arr[i-1]+" ");
// }
///////////折半/二分查找//////////
// int num=InputInt();
// int left=0;
// int right=n-1;
// int mid=(right+left)/2;
// while(arr[mid]!=num)
// {
// if(num>arr[mid])
// {
// left=mid+1;
// }
// else if(num<arr[mid])
// {
// right=mid-1;
// }
// if(left>right)
// {
// mid=-1;
// break;
// }
// mid=(left+right)/2;
// }
// System.out.println(mid);
///////////反转////////////
// for(int i=0;i<n/2;i++)
// {
// arr[i]=arr[i]+arr[n-i-1];
// arr[n-i-1]=arr[i]-arr[n-i-1];
// arr[i]=arr[i]-arr[n-i-1];
// }
////////快排////////////
/////////遍历////////////
// for(int i=1;i<=n;i++)
// {
// System.out.printf(arr[i-1]+" ");
// }
/*
1. 自定义一个整数数组arr，读入一个整数n，如果n在数组中存在，则输出n的下标；如果不存在，则输出-1
2. 已知一个二维数组A表示一个矩阵,求A的转置.
矩阵转置的含义：表示将一个矩阵的行列互换。
例如有下面的矩阵
1 2 3
4 5 6
转置成
1 4
2 5
3 6
3. 给定一个数组将这个数组中所有元素的顺序进行颠倒
4. 输出杨辉三角
杨辉三角如下：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
......
杨辉三角的特点：
1) 第i行有i个元素
2) 每一行的每一个元素和最后一个元素都是1
3) 除了1之外，每个元素的值都等于上一行同位置的元素以及前一个元素的和。
要求：输入一个数，输出对应的行数
5. 15个猴子围成一圈选大王，依次1-7循环报数，报到7的猴子被淘汰，直到最后一只猴子成为大王。问：哪只猴子会成为大王？
6. 螺旋填数.
读入两个整数m,n，输出一个m行n列的矩阵，这个矩阵是1~m*n这些自然数按照右、下、左、上螺旋填入的结果。
例如读入数字4,5，则输出结果为：
1 2 3 4 5
14 15 16 17 6
13 20 19 18 7
12 11 10 9 8
*/
///////////1///////////
// System.out.println("输入数组中元素的个数");
// int n=InputInt();
// int[] arr=new int[n];
// System.out.println("输入数组中的每一个元素");
// for(int i=0;i<n;i++)
// {
// arr[i]=InputInt();
// }
// System.out.println("输入要查找的元素");
// int num=InputInt();
// for(int i=0;i<n;i++)
// {
// if(num==arr[i])
// {
// System.out.println(i);
// break;
// }
// if(i==n-1)
// {
// System.out.println(-1);
// break;
// }
// }
///////下面是排序之后 二分查找 与本题无关////////
// Arrays.sort(arr);
// System.out.println("输入要查找的元素");
// int num=InputInt();
// int left=0;
// int right=n-1;
// int middle=(left+right)/2;
// while(arr[middle]!=num)
// {
// if(num>arr[middle])
// {
// left=middle+1;
// }
// else if(num<arr[middle])
// {
// right=middle-1;
// }
// if(left>right)
// {
// middle=-1;
// break;
// }
// middle=(left+right)/2;
// }
// System.out.println(middle);
//////////////////2////////////
//////最笨的转置/////
// System.out.println("请分别输入二维矩阵的行和列");
// int n=InputInt();
// int m=InputInt();
// int[][] A=new int[n][m];
// System.out.println("请输入矩阵里的值 一行一行输入");
// for(int i=0;i<n;i++)
// {
// for(int j=0;j<m;j++)
// {
// A[i][j]=InputInt();
// }
// }
// for(int i=0;i<n;i++)
// {
// for(int j=0;j<m;j++)
// {
// System.out.printf("%d ",A[i][j]);
// }
// System.out.printf("\n");
// }
// int[][] B=new int[m][n];
// for(int i=0;i<n;i++)
// {
// for(int j=0;j<m;j++)
// {
// B[j][i]=A[i][j];
// }
// }
// A=B;
// for(int i=0;i<m;i++)
// {
// for(int j=0;j<n;j++)
// {
// System.out.printf("%d ",A[i][j]);
// }
// System.out.printf("\n");
// }
//////////3////////////
// System.out.println("输入数组中元素的个数");
// int n=InputInt();
// int[] arr=new int[n];
// System.out.println("输入数组中的每一个元素");
// for(int i=0;i<n;i++)
// {
// arr[i]=InputInt();
// }
// for(int i=0;i<n;i++)
// {
// System.out.printf("%d ",arr[i]);
// }
// System.out.println();
// for(int i=0;i<n/2;i++)
// {
// arr[i]=arr[n-i-1]+arr[i];
// arr[n-i-1]=arr[i]-arr[n-i-1];
// arr[i]=arr[i]-arr[n-i-1];
// }
// for(int i=0;i<n;i++)
// {
// System.out.printf("%d ",arr[i]);
// }
// System.out.println();
///////////4 (杨辉三角问题)///////////
// int n=InputInt();
// int[][]A=new int[n+1][n+1];
// A[1][1]=1;
// for(int i=2;i<=n;i++)
// {
// for(int j=1;j<=n;j++)
// {
// if(j<=i)
// {
// A[i][j]=A[i-1][j]+A[i-1][j-1];
// }
// else
// {
// break;
// }
// }
// }
// for(int i=1;i<=n;i++)
// {
// for(int j=1;j<=n;j++)
// {
// if(j<=i)
// {
// System.out.printf("%d\t ",A[i][j]);
// }
// }
// System.out.printf("\n");
// }
////////////5 (约瑟夫环问题)//////////////
// System.out.println("请输入一共几只猴子");
// int n=InputInt();
// System.out.println("请输入数到几的猴子被淘汰");
// int m=InputInt();
// int[] monkeys=new int[n];
// for(int i=0;i<n;i++)
// {
// monkeys[i]=i+1;
// }
// int[] monkeys_dead=new int[n];
// int count=0;
// int j=0;
// System.out.println("淘汰顺序:(第一行代表猴子的序号 第二行与之对应的是 是否被淘汰 1为淘汰 0为未被淘汰)");
// for(int i=0;;i++)
// {
// if(monkeys_dead[i%n]==0)
// {
// j++;
// }
// if(j%m==0)
// {
// monkeys_dead[i%n]=1;
// System.out.println(Arrays.toString(monkeys));
// System.out.println(Arrays.toString(monkeys_dead));
// }
// if(j==m*(n-1))
// {
// break;
// }
// }
// for(int i=0;i<n;i++)
// {
// if(monkeys_dead[i]==0)
// {
// System.out.println(monkeys[i]+"号是王");
// }
// }
//////////6////////////
///////////多此一举的。。。。//////////////
// int m=InputInt();
// int n=InputInt();
// int[][]A=new int[m][n];
// int[] fg=new int[1000];
// int temp=0;
// for(int i=0,j=0;i<1000;i++)
// {
// if(i%2==1)
// {
// j+=1;
// }
// if(i==0)
// {
// fg[i]=n+j;
// }
// else
// {
// if(i%2==1)
// {
// if(m-j>0)
// {
// fg[i]=m-j;
// }
// else
// {
// temp=i;
// break;
// }
// }
// else
// {
// if(n-j>0)
// {
// fg[i]=n-j;
// }
// else
// {
// temp=i;
// break;
// }
// }
// }
// }
// int x=1;
// int a=1;
// int r=0;
// int c=0;
// for(int i=0;fg[i]>0;i++,x++)
// {
// if(x%4==1)//→
// {
// for(int j=0;j<fg[i];j++,c++,a++)
// {
// A[r][c]=a;
// }
// for(int j=0;j<m;j++)
// {
// System.out.println(Arrays.toString(A[j]));
// }
// r++;
// c--;
// }
// if(x%4==2)//↓
// {
// for(int j=0;j<fg[i];j++,r++,a++)
// {
// A[r][c]=a;
// }
// for(int j=0;j<m;j++)
// {
// System.out.println(Arrays.toString(A[j]));
// }
// c--;
// r--;
// }
// if(x%4==3)//←
// {
// for(int j=0;j<fg[i];j++,c--,a++)
// {
// A[r][c]=a;
// }
// for(int j=0;j<m;j++)
// {
// System.out.println(Arrays.toString(A[j]));
// }
// r--;
// c++;
// }
// if(x%4==0)//↑
// {
// for(int j=0;j<fg[i];j++,r--,a++)
// {
// A[r][c]=a;
// }
// for(int j=0;j<m;j++)
// {
// System.out.println(Arrays.toString(A[j]));
// }
// c++;
// r++;
// }
// }
// int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
// int[][]A=new int[m][n];
// A[0][0]=1;
// for(int i=1;i<=m*n;i++)
// {
// }
////////while循环 完成//////////
// int m=InputInt();
// int n=InputInt();
// int[][]A=new int[m][n];
// int x=0,y=0;
// int count=2;
// A[0][0]=1;
// while(count<m*n)
// {
// while(y+1<n&&A[x][y+1]==0)
// {
// A[x][y+1]=count;
// count++;
// y++;
// }
// while(x+1<m&&A[x+1][y]==0)
// {
// A[x+1][y]=count;
// count++;
// x++;
// }
// while(y-1>=0&&A[x][y-1]==0)
// {
// A[x][y-1]=count;
// count++;
// y--;
// }
// while(x-1>=0&&A[x-1][y]==0)
// {
// A[x-1][y]=count;
// count++;
// x--;
// }
// }
// for(int j=0;j<m;j++)
// {
// System.out.println(Arrays.toString(A[j]));
// }
////////插入排序///////////////
// System.out.println("输入数组中元素的个数");
// int n=InputInt();
// int[] arr=new int[n];
// System.out.println("输入数组中的每一个元素");
// for(int i=0;i<n;i++)
// {
// arr[i]=InputInt();
// }
// System.out.println(Arrays.toString(arr));
// for(int j=1;j<n;j++)
// {
// int temp=arr[j];
// int q=j-1;
// while(temp<arr[q])
// {
// arr[q+1]=arr[q];
// q--;
// if(q==-1)
// {
// break;
// }
// }
// arr[q+1]=temp;
// }
////////排序///////////////
// System.out.println("输入数组中元素的个数");
// int n=InputInt();
// int[] arr=new int[n];
// int[] arr2=new int[n];
// int[] arr3=new int[n];
// System.out.println("输入数组中的每一个元素");
// for(int i=0;i<n;i++)
// {
// arr[i]=InputInt();
// arr2[i]=arr[i];
// arr3[i]=arr[i];
// }
// System.out.println(Arrays.toString(arr));
// QuickSort(arr);
// System.out.println("假的快速排序"+Arrays.toString(arr));
// BubbleSort(arr);
// System.out.println("冒泡排序"+Arrays.toString(arr));
// SelectSort(arr2);
// System.out.println("选择排序"+Arrays.toString(arr2));
// InsertSort(arr3);
// System.out.println("插入排序"+Arrays.toString(arr3));
}
////////快速排序 非递归///////////
public static void QuickSort(int[] number)
{
for(int j=0;j<number.length;j++)
{
int middle=j;
int l=0,r=number.length-1;
while(true)
{
if(r==l)
{
r=0;
l=number.length-1;
break;
}
for(int i=0;i<=middle;i++)
{
if(number[i]>number[middle])
{
l=i;
break;
}
if(i==middle)
{
l=middle;
}
}
for(int i=number.length-1;i>=middle;i--)
{
if(number[i]<number[middle])
{
r=i;
break;
}
if(i==middle)
{
r=middle;
}
}
int temp=number[l];
number[l]=number[r];
number[r]=temp;
}
}
}
///////冒泡排序////////
public static void BubbleSort(int[] number)
{
for(int i=1,j=0;i<number.length-j;i++)
{
if(number[i-1]>number[i])
{
number[i]=number[i-1]+number[i];
number[i-1]=number[i]-number[i-1];
number[i]=number[i]-number[i-1];
}
if(i==number.length-j-1)
{
i=0;
j++;
}
}
}
public static void BubbleSort2(int[] number)
{
for(int i=1;i<number.length;i++)
{
for(int j=1;j<=number.length-i;j++)
{
if(number[j-1]>number[j])
{
number[j-1]=number[j]+number[j-1];
number[j]=number[j-1]-number[j];
number[j-1]=number[j-1]-number[j];
}
}
}
}
///////插入排序////////
public static void InsertSort(int[] number)
{
// 第一个元素作为一部分，对后面的部分进行循环
for (int j = 1; j < number.length; j++)
{
int tmp = number[j];
int i = j - 1;
while (tmp < number[i])
{
number[i + 1] = number[i]; i--;
if (i == -1)
break;
}
number[i + 1] = tmp;
}
}
///////选择排序////////
public static void SelectSort(int[] number)
{
for(int i=0;i<number.length;i++)
{
for(int j=i+1;j<number.length;j++)
{
if(number[i]>number[j])
{
number[i]=number[i]^number[j];
number[j]=number[i]^number[j];
number[i]=number[i]^number[j];
}
}
}
}
static int InputInt()
{
Scanner sc=new Scanner(System.in);
while(!sc.hasNextInt())
{
System.out.println("请输入一个整数");
sc.next();
}
return sc.nextInt();
}
static double InputNumber()
{
Scanner sc=new Scanner(System.in);
while(!sc.hasNextDouble())
{
System.out.println("请输入一个数字");
sc.next();
}
return sc.nextDouble();
}
static String InputString()
{
Scanner sc=new Scanner(System.in);
while(!sc.hasNextLine())
{
System.out.println("请输入一行字符串");
sc.next();
}
return sc.nextLine();
}
}