大資料預科班1~4天習題
阿新 • • 發佈：2019-01-19
第1~4天作業
1.（識別符號命名）下面幾個變數中，那些是對的？那些是錯的？錯的請說明理由
A. ILoveJava B. $20 C. [email protected] D. antony.lee E. Hello_World F. 2tige
正確的：A B E
錯誤的：C(@符號不滿足) D(.符號不滿足) F(數字不能開頭)
2.假設有如下程式：
package com.corejava.chp1;
public class HelloWorld{
public static void main(String args[]){
System.out.println("Hello World");
}
}
1）假設這個程式碼存在hello.java 檔案中，那這個程式能夠編譯通過？為什麼？如果編譯不通過，應該如何改進？
不可以編譯通過：因為檔名不和public修飾的類名一致（在java中java檔名和公共類名必須一致）
2）假設這個.java 檔案放在C:\javafile\目錄下，CLASSPATH=.，則生成的.class檔案應該放在什麼目錄下？如何執行？
生成的class檔案在當前檔案下的com/corejava/chp1下
執行 java com.corejava.chp1.HelloWorld
java -cp . com.corejava.chp1.HelloWorld(-cp代表目錄)
注：可以使用javac -d 路徑 java檔名（.java） eg:javac -d . HelloWorld.java快速建包，並在最後一層檔案下存放class檔案。
3.（if 語句）讀入一個整數，判斷其是奇數還是偶數
package com.tedu.study._day01; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { int x = (new Scanner(System.in)).nextInt(); if (x % 2 == 0) { System.out.println(x + "是偶數！"); } else { System.out.println(x + "是奇數！"); } } }
4.（操作符）有如下程式碼：int a = 5;int b = (a++) + (--a) +(++a);問執行完之後，b 的結果是多少？
(5)+(5)+(6)=16
5.（基本型別的運算）一家商場在舉行打折促銷，所有商品都進行8 折優惠。一位程式設計師把這個邏輯寫成：
short price = ...; // 先計算出原價 short realPrice = price * 8 / 10; //再計算出打折之後的價格 問：這段程式碼是否正確？如果正確，假設price 為100，那計算之後的 realPrice值為多少？如果不正確，應該怎麼改正？
不正確,因為整數計算打折有可能丟失精度；
改正：貨幣金額的計算用BigDecimal（這裡可以用double）,並double realPrice=price*0.8；
注：float和double只能用來做科學計算或者是工程計算，在商業計算中我們要用 java.math.BigDecimal,而且使用BigDecimal類也可以進行大數的操作。
6.（操作符）請說明>>與>>>之間的區別。
>>右移運算子：
如果該數為正，則高位補0，若為負數，則高位補1；
>>>無符號右移運算子：
也稱邏輯右移，即若該數不論正負，高位都補0；
補充：
<<是與>>對應的左移運算子，低位補0,；其實向左移動n位，就相當於乘以2的n次方，左移沒有<<<運算子！
7.a = (a>b)?a:b;請問這段程式碼完成了什麼功能？
求最大值
8.（if 語句）讀入一個整數，表示一個人的年齡。如果小於6 歲，則輸出“童”，6 歲到13 歲，輸出“少兒”；14 歲到18 歲，輸出“青少年”；18 歲到35 歲，輸出“青年”；35 歲到50 歲，輸出“中年”；50 歲以上輸出“中老年”。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x=new Scanner(System.in).nextInt();
if(x<1&&x>200){
System.out.println("輸入年齡範圍有誤！");
}else if(x<=6){
System.out.println("童");
}else if(x<=12){
System.out.println("少兒");
} else if(x<=18){
System.out.println("青少年");
}else if(x<=36){
System.out.println("青年");
}else if(x<=50){
System.out.println("中年");
}else{
System.out.println("中老年");
}
}
}
9.（switch 語句）讀入一個整數，如果是1~5 之間，則分別輸出5 個福娃的名字，否則輸出“北京歡迎你”
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x = new Scanner(System.in).nextInt();
switch (x) {
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("北京歡迎您!");
}
}
}
10. （if 語句，賦值操作）*讀入三個整數，輸出這三個整數中最大的一個。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
System.out.println("請輸入第一個整數：");
int a1=new Scanner(System.in).nextInt();
System.out.println("請輸入第二個整數：");
int a2=new Scanner(System.in).nextInt();
System.out.println("請輸入第三個整數：");
int a3=new Scanner(System.in).nextInt();
int max=a1;
if((max>a2)&&(max>a3)){
max=max;
}else{
if(a2>a3){
max=a2;
}else{
max=a3;
}
}
//注意擴充套件：最大值有多個時，且把key-value記住時需要=也加入
System.out.println("最大值："+max);
}
}
11. （if 語句）*讀入一個表示年份的整數，判斷這一年是否是閏年。如何判斷一個年份是否是閏年：1. 如果這個年份能夠被4 整除，且不能被100 整除，則這一年是閏年。例如，1996 年是閏年，而相應的，1993 年就不是閏年。2. 如果這個年份能夠被100 整除，則這個數必須要能被400 整除，才是閏年。例如，2000 年是閏年，1900 年不是閏年。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x = new Scanner(System.in).nextInt();
if ((x % 400 == 0) || (x % 4 == 0 && x % 100 != 0)) {
System.out.println(x + "是閏年");
} else {
System.out.println(x + "是平年");
}
}
}
12. （switch 語句）*完成一個簡單的計算器程式。程式要求如下：1. 讀入兩個整數2. 提示使用者選擇對這兩個整數的操作，即輸出1 ： +2 ： -3 ： *4 ： /請輸入您的選擇：讀入使用者的選擇，輸出運算結果。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
System.out.println("請輸入第一個整數：");
int x1=new Scanner(System.in).nextInt();
System.out.println("請輸入第二個整數：");
int x2=new Scanner(System.in).nextInt();
System.out.println("請選擇操作+-*/：");
String op=new Scanner(System.in).nextLine();
switch(op){
case "+" :{
System.out.println(x1+x2);
break;
}
case "-" :{
System.out.println(x1-x2);
break;
}
case "*" :{
System.out.println(x1*x2);
break;
}
case "/" :{
System.out.println(x1/x2);
break;
}
default :{
System.out.println("輸入操作有誤！");
}
}
}
}
13. （if 語句）*託運計費問題：當貨物重量小於20 公斤的時候，收費5 元，大於20 公斤小於100 公斤的時候超出20 公斤的部分按每0.2 元每公斤計費，如果超出100 公斤的時候，超的部分按照每公斤0.15 元計算。讀入貨物的重量，輸出計算之後貨物的運費。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
double x=new Scanner(System.in).nextDouble();
double sum=0;
if(x<=20){
sum=5;
}else if(x<=100){
sum=5+(x-20)*0.2;
}else{
sum=5+80*0.2+(x-100)*0.15;
}
System.out.println(sum);
}
}
14. （if 語句）中國的個稅計算方法：應稅所得為稅前收入扣除2000 元（起徵點），然後超出部分，按照以下稅率收稅：500 5%500-2000 10%2000-5000 15%5000-20000 20%20000-40000 25%40000-60000 30%60000-80000 35%80000-100000 40%100000 - ? 45%例：若月收入15000，則應稅所得為15000-2000=13000；總的個人所得稅為（13000-5000）20% + （5000-2000）*15% + （2000-500）10% + 5005%= 2225要求：讀入一個整數，表示稅前收入，輸出應當繳納的個人所得稅和稅後實際收入。
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
double x=new Scanner(System.in).nextDouble();
x-=2000;
double div=0;
if(x<=500){
div=x*0.05;
}else if(x<=2000){
sum=500*0.05+x(x-500)*0.1;
}else if(x<=5000){
sum=500*0.05+(2000-500)*0.1+(x-5000)*0.15;
}else if(x<=2000){
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(x-5000)*0.2;
}else if(x<=40000){
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(20000-5000)*0.2+(x-20000)*0.25;
}else if(x<=60000){
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(20000-5000)*0.2+(40000-20000)*0.25+(x-40000)*0.3;
}else if(x<=80000){
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(20000-5000)*0.2+(40000-20000)*0.25+(60000-40000)*0.3+(x-60000)*0.35;
}else if(x<=100000){
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(20000-5000)*0.2+(40000-20000)*0.25+(60000-40000)*0.3+(80000-60000)*0.35+(x-80000)*0.4;
}else{
sum=500*0.05+(2000-500)*0.1+(5000-2000)*0.15+(20000-5000)*0.2+(40000-20000)*0.25+(60000-40000)*0.3+(80000-60000)*0.35+(100000-80000)*0.4+(x-100000)*0.45;
}
System.out.println("應繳納"+num+"元，實際收入："+(x+2000-sum)+"元！");
}
}
15. （if 語句，操作符）**讀入一個三位數，計算其各位數字之和。例如：123各位數字之和為6
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x=new Scanner(System.in).nextInt();
int sum=0;
while(x!=0){
sum+=(x%10);
x=x/10;
}
System.out.println(sum);
}
}
16. （if 語句）**讀入三個整數，把這三個整數按照由大到小的順序輸
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int max = 0, mid = 0, min = 0;
System.out.println("請輸入第一個數：");
int a = new Scanner(System.in).nextInt();
System.out.println("請輸入第二個數：");
int b = new Scanner(System.in).nextInt();
System.out.println("請輸入第三個數：");
int c = new Scanner(System.in).nextInt();
if (a > b && a > c) {
max = a;
if (b > c) {
mid = b;
min = c;
} else {
mid = c;
min = b;
}
} else {
if (b > a && b > c) {
max = b;
if (a > c) {
mid = a;
min = c;
} else {
mid = c;
min = a;
}
} else {
max = c;
if (a > b) {
mid = a;
min = b;
} else {
mid = b;
min = a;
}
}
}
}
}
第三天作業
1.計算1+2+3+...+100的和
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
}
}
2.計算1+3+5+...+99的和
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) {
sum += i;
}
}
System.out.println(sum);
}
}
3.用while和do-while重寫第1題和第2題
//第一題while寫法
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
int i = 100;
while (i > 0) {
sum += i;
i--;
}
System.out.println(sum);
}
}
//第二題do-while寫法
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
int i = 100;
do{
sum += i;
i--;
}while(i>0);
System.out.println(sum);
}
}
//第二題while寫法
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
int i = 100;
while (i > 0) {
if (i % 2 != 0) {
sum += i;
}
i--;
}
System.out.println(sum);
}
}
//第二題do-while寫法
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
int i = 100;
do{
if (i % 2 != 0) {
sum += i;
}
i--;
}while(i>0);
System.out.println(sum);
}
}
4.（for）讀入一個小於10的整數，並計算其階乘
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x = new Scanner(System.in).nextInt();
int sum = 1;
for (int i = x; i > 1; i--) {
sum *= i;
}
System.out.println(sum);
}
}
//遞迴寫法
package com.peng.demo;
public class Demo01 {
public static void main(String args[]) {
System.out.println(getJieCheng(5));
}
// 遞迴函式求階乘
public static int getJieCheng(int x) {
if (x == 1) {
return 1;
}
return x * getJieCheng(x - 1);
}
}
5.（for）求100以內所有能被3整除，但不能被5整除的數字之和
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum =0;
for (int i = 1; i <=100; i++) {
if(i%3==0&&i%5!=0){
sum+=i;
}
}
System.out.println(sum);
}
}
6.（for）“百錢買百雞”：3文錢可以買一隻公雞；2文錢可以買一隻母雞；1文錢可以買3只小雞；用100文買100只雞，問公雞、母雞、小雞各有多少隻？
設公雞a只，母雞b只，小雞c只：
則：a+b+c=100
3a+2b+c/3=100
100文最多可買公雞（100/3=33）,100文最多可買母雞（100/2=50只），小雞便宜，但最多隻能99只（按100只算）即：
for(int x=0;x<=33;x++){
for(int y=0;y<=50;y++){
for(int z=0;z<=100){
if((x+y+z==100)&&(3*x+2*y+z/3==100)){
System.out.pri：nntln("公雞："+x+"，母雞："+y+"，小雞"+z);
}
}
}
}
//6種情況
7.搬磚問題：36塊磚，36人搬磚，男搬4，女搬3，兩個小孩擡一塊磚；要求一次性全部把磚搬完，問：男人、女人、小孩各若干？
設男人a人，女人b人，小孩c人
則：a+b+c=36
4a+3b+c/2=36
男生最多搬（4*9=36），女生最多搬（3*12=36），小孩最多搬（36/2=18）
則：
for(int x=0;x<=36;x++ ){
for(int y=0;y<=36;y++){
for(int z=0;z<=18){
if((x+y+z==36)&&(x/4+y/3+z*2=36)){
System.out.print("男人："+(x/4)+"，女人："+(y/3)+"，小孩："+(2*z));
}
}
}
}
8.（for）程式設計找出四位整數abcd中滿足下述關係的數：（ab+cd）（ab+cd）=abcd
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
for (int i = 1000; i < 9999; i++) {
if (i == getSS(i)) {
System.out.println(getSS(i));
}
}
}
public static int getSS(int x) {
int a1 = x % 10;
x = x / 10;
int a2 = x % 10;
x = x / 10;
int a3 = x % 10;
x = x / 10;
int a4 = x % 1000;
return (((10 * a2 + a1) + (10 * a4 + a3)) * ((10 * a2 + a1) + (10 * a4 + a3)));
}
}
9.(迴圈)讀入一個整數n， 輸出如下圖形
n=3時：
*
***
*****
n=4時：
*
***
*****
*******
每一行星數：（2*行數-1）
每一行前空格數：（2*n-1-行數)/2
每一行後空格數：（2*n-1-行數)/2
//程式碼
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
/*
* *
* ***
* *****
* *******
*/
int n = 4;
// 遍歷行
for (int i = 0; i < n; i++) {
// 遍歷列
for (int j = 0; j < (2 * n - 1); j++) {
// 列印空格
if ((j < (n - (i + 1))) || (j > (n + i - 1))) {
System.out.print(" ");
} else {// 列印*
System.out.print("*");
}
}
// 換行
System.out.println();
}
}
}
10.（迴圈）輸出99乘法表
package com.tedu.study._day01;
public class Demo01 {
public static void main(String[] args) {
for (int i = 1, j = 1; i <= 9; j++) {
System.out.print(i + "*" + j + "=" + (i * j) + "\t");
if (i == j) {
j = 0;
i++;
System.out.println();
}
}
}
}
11.（迴圈）水仙花數：一個三位數abc，如果滿足a3+b3+c3=abc,則abc是水仙數
package com.peng.demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
if (i == getSS(i)) {
System.out.println(getSS(i));
}
}
}
public static int getSS(int x) {
int a1 = x % 10;
x = x / 10;
int a2 = x % 10;
x = x / 10;
int a3 = x % 10;
return (int)(Math.pow(a1,3)+Math.pow(a2,3)+Math.pow(a3,3));
}
}
12. （迴圈）**輸入一個整數，計算它各位上數字的和。（注意：是任意位的整數）
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x = new Scanner(System.in).nextInt();
int num = 0;
while (x != 0) {
num += x % 10;
x /= 10;
}
System.out.println(num);
}
}
13.輸入一個整數，判斷是否是質數（提示2~Math.sqrt(x)）
package com.tedu.study._day01;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
boolean isok = true;
int x = new Scanner(System.in).nextInt();
for (int i = 2; i < (int) Math.sqrt(x); i++) {
if (x % i == 0) {
System.out.println(x + "不是質數");
isok = false;
break;
}
}
if (isok) {
System.out.println(x + "是質數");
}
}
}
14.完數：如果一個數等於它所有因子之和，eg:6=1+2+3,求1000以內的完數(和親密數相似)
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
for (int i = 3; i <= 1000; i++) {
if (i == getXSum(i)) {
System.out.println("完數：" + i);
}
}
}
public static int getXSum(int x) {
int sum = 1;
for (int i = 2; i <= x / 2; i++) {
if (x % i == 0) {
sum += i;
}
}
return sum;
}
}
15.計算圓周率：PI=4/1-4/3+4/5-4/7+4/9-4/11+...，圓周率在3.1415926和3.1415927之間，求要得到這樣的結果，經過多少次加減運算可以得到
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
/*
* ###15.計算圓周率：PI=4/1-4/3+4/5-4/7+4/9-4/11+...，
* 圓周率在3.1415926和3.1415927之間，求要得到這樣的結果，經過多少次加減運算可以得到
*/
double PI = 0;
int i = 1;
int num = 0;
while (PI < 3.1415926 || PI > 3.1415927) {
if ((num + 1) % 2 == 0) {
PI = PI - (4.0 / i);
} else {
PI = PI + (4.0 / i);
}
i += 2;
num++;
}
System.out.println(num);
}
}
16.faibonacci（斐波那契數列）：0,1,1,2,3,5,8...輸入n，求前n項
//遞迴（函式自己呼叫自己）
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
// 前10項斐波那契數
for (int i = 1; i <= 10; i++) {
System.out.println(faibonacci(i));
}
}
// 0,1,1,2,3,5...
public static int faibonacci(int n) {
if (n == 1) {
return 0;
}
if (n == 2) {
return 1;
}
return faibonacci(n - 1) + faibonacci(n - 2);
}
}
//簡單方法：設定三個變數first,second,third
...
for(){
third=first+second;
first=second;
second=third;
}
...
17.（迴圈）一個int是由32的二進位制位組成，每個二進位制數要麼0，要麼1。要求讀入一個int型別的數n,計算它的32個二進位制中共有多少位1
//倒取模將10進位制數轉化為二進位制數並在其中計算1的數量(正整數)
//注意負整數
//方法1.取反（01相轉）eg：-5 -> 4； 4有一個1，則-5有32-1=31個1
//方法2.&1並且右移
eg:
1110 0001 1110 1010 0010 0010 0001 0101
&
0000 0000 0000 0000 0000 0000 0000 0001
=
0000 0000 0000 0000 0000 0000 0000 0001即1
然後右移繼續判斷
package com.peng.demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
int x = new Scanner(System.in).nextInt();
// 正數直接求,負數先取反，在求
if (x < 0) {
x = ~x;
for (int i = 0; i < get32Array(5).length; i++) {
sum += get32Array(5)[i];
}
System.out.println("該陣列1的個數為" + (32 - sum));
} else {
for (int i = 0; i < get32Array(5).length; i++) {
sum += get32Array(5)[i];
}
System.out.println("該陣列1的個數為" + sum);
}
}
public static int[] get32Array(int n) {
int[] temp = new int[32];
int i = 31;
while (n != 0) {
temp[i] = n % 2;
n /= 2;
i--;
}
return temp;
}
}
18.三天打魚兩天晒網：假設有一個人從2000,1,1開始，輸入三個整數，分別代表年月日，問當前日期是在打魚還是晒網
/*算出當日距2000,1,1的天數，取模5,如果為1,2,3位打魚；4,5為晒網。
注意平年和閏年的2月*/
//程式碼
package com.peng.demo;
import javax.swing.JOptionPane;
public class Demo01 {
public static void main(String[] args) {
switch (1 + (getDays(2000, 1, 6) % 5)) {
// 1,2,3打魚
case 1:
case 2:
case 3: {
System.out.println("打魚！");
break;
}
// 4,5晒網
case 4:
case 5: {
System.out.println("晒網！");
break;
}
}
}
public static int getDays(int year, int month, int day) {
// 一：資料校驗：
// 1、年份>=2000；
// 2、1<=月份<=12;
// 3、日子數（1,3,5,7,8,10,12月）1~31天、（4,6,9,11）1~30天、（2）平年1~28，閏年1~29
if (year < 2000) {
JOptionPane.showMessageDialog(null, "年份為2000以後！");
return -1;
}
if (month < 1 || month > 12) {
JOptionPane.showMessageDialog(null, "月份為1~12月！");
return -1;
}
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: {
if (day < 1 || day > 31) {
JOptionPane.showMessageDialog(null, "此月為大月，範圍為1~31");
return -1;
}
break;
}
case 4:
case 6:
case 9:
case 11: {
if (day < 1 || day > 30) {
JOptionPane.showMessageDialog(null, "此月為小月，範圍為1~30");
return -1;
}
break;
}
case 2: {
if ((!isRunNian(year)) && (day < 1 || day > 28)) {// 平年
JOptionPane.showMessageDialog(null, "此月為平年2月，範圍為1~29");
return -1;
}
if ((isRunNian(year)) && (day < 1 || day > 29)) {// 閏年
JOptionPane.showMessageDialog(null, "此月為閏年2月，範圍為1~29");
return -1;
}
break;
}
}
// 二：計算天數
return getAllDays(year, month, day);
}
// 是否是閏年
public static boolean isRunNian(int year) {
if ((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))) {
return true;
} else {
return false;
}
}
// 計算所有天數
public static int getAllDays(int year, int month, int day) {
int all_days = 0;
int num_RunNian = 0;//
int num_PingNian = 0;// 平年個數
for (int i = 2000; i < year; i++) {
if (isRunNian(year)) {
num_RunNian++;// 計算閏年個數
} else {
num_PingNian++;
}
}
all_days += (366 * num_RunNian + 365 * num_PingNian);
// 計算當年的天數
if (isRunNian(year)) {// 閏年
switch (month) {
case 1: {
all_days += day;
break;
}
case 2: {
all_days += (31) + day;
break;
}
case 3: {
all_days += (31 + 29) + day;
break;
}
case 4: {
all_days += (31 + 29 + 31) + day;
break;
}
case 5: {
all_days += (31 + 29 + 31 + 30) + day;
break;
}
case 6: {
all_days += (31 + 29 + 31 + 30 + 31) + day;
break;
}
case 7: {
all_days += (31 + 29 + 31 + 30 + 31 + 30) + day;
break;
}
case 8: {
all_days += (31 + 29 + 31 + 30 + 31 + 30 + 31) + day;
break;
}
case 9: {
all_days += (31 + 29 + 31 + 30 + 31 + 30 + 31 + 31) + day;
break;
}
case 10: {
all_days += (31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30) + day;
break;
}
case 11: {
all_days += (31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31)
+ day;
break;
}
case 12: {
all_days += (31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30)
+ day;
break;
}
}
} else {
switch (month) {
case 1: {
all_days += day;
break;
}
case 2: {
all_days += (31) + day;
break;
}
case 3: {
all_days += (31 + 28) + day;
break;
}
case 4: {
all_days += (31 + 28 + 31) + day;
break;
}
case 5: {
all_days += (31 + 28 + 31 + 30) + day;
break;
}
case 6: {
all_days += (31 + 28 + 31 + 30 + 31) + day;
break;
}
case 7: {
all_days += (31 + 28 + 31 + 30 + 31 + 30) + day;
break;
}
case 8: {
all_days += (31 + 28 + 31 + 30 + 31 + 30 + 31) + day;
break;
}
case 9: {
all_days += (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31) + day;
break;
}
case 10: {
all_days += (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30) + day;
break;
}
case 11: {
all_days += (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31)
+ day;
break;
}
case 12: {
all_days += (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30)
+ day;
break;
}
}
}
return all_days - 1;
}
}
19.分解質因數並打印出來
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
int n = 99;
System.out.println("1");
for (int i = 2; i <= n / 2; i++) {
if (n % i == 0) {
System.out.println(i);
}
}
}
}
第四天作業
練習1. 下列陣列的宣告有哪些是對的？錯的應該怎麼修改？
- 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};
正確的：A、B
int[] a={1,2,3,4,5};
int[] a=new int[3];
//1.長度不同 2、不知道如何存、如何放
int[] a = new int[5]{1，2，3};
2. 看下面的程式碼，寫出輸出的結果
public class Ex2 {public static void main(String[] args) {
int[] a = {1,2,3,4,5};
expand(a);
changeArray(a);
printArray(a);
}
public static void expand(int[] a){
int[] newArray = new int[a.length * 2];
System.arraycopy(a, 0, newArray, 0, a.lena = newArray;
}
public static void changeArray(int[] a){
a[0] = 10;
}
public static void printArray(int[] a){
for(int i = 0; i<a.length; i++){
System.out.print(a[i] + "\t");
}
System.out.println();
}
}
請選擇輸出結果：
A. 10 2 3 4 5
B. 1 2 3 4 5
C. 10 2 3 4 5 0 0 0 0 0
D. 1 2 3 4 5 0 0 0 0 0
A
同一塊記憶體與不同記憶體的改變
3. 寫一個函式，計算一個整數陣列的平均值
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6 };
System.out.println(getAvg(arr));
}
// 陣列求平均值
public strictfp static double getAvg(int[] arr) {
double sum = 0;
for (int i : arr) {
sum += i;
}
return sum / arr.length;
}
}
4. 自定義一個整數陣列a，讀入一個整數n，如果n 在陣列中存在，則輸出n 的下標；如果不存在，則輸出-1。
//簡單方法
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6 };
System.out.println(getIndex(arr, 3));
}
// 從整數陣列中元素的下標：存在返回最後一個相同資料的下標，不存在返回-1
public static int getIndex(int[] arr, int x) {
for (int i = 0; i < arr.length; i++) {
if (x == arr[i]) {
return i;
}
}
return -1;
}
}
5. 給定一個數組，輸出陣列中的最大值和最小值
//簡單方法
package com.peng.demo;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 0 };
System.out.println(getIndex(arr)[0]);
System.out.println(getIndex(arr)[1]);
}
// 求一個數組中的最大值和最小值
public static int[] getIndex(int[] arr) {
int[] maxAndMin = new int[2];
Arrays.sort(arr);
maxAndMin[0] = arr[arr.length - 1];
maxAndMin[1] = arr[0];
return maxAndMin;
}
}
6. 已知一個二維陣列A 表示一個矩陣，求AT。其中，AT 表示矩陣的轉置。矩陣轉置的含義：表示把一個矩陣行列互換。例如，有下面的矩陣M 以及其轉置M
package com.peng.demo;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
int[][] a = { { 2, 3 }, { 4, 5 }, { 6, 7 } };
int[][] b = new int[a[0].length][a.length];
for (int i = 0; i < a[0].length; i++) {
for (int j = 0; j < a.length; j++) {
b[i][j] = a[j][i];
System.out.print(a[j][i]);
}
System.out.println();
}
}
}
7. *給定一個數組，把這個陣列中所有元素順序進行顛倒。
//思路：用一個迴圈，兩個條件進行約束
//程式碼
package com.peng.demo;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 0 };
arr = getBackArray(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//反轉陣列
public static int[] getBackArray(int[] arr) {
for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
return arr;
}
}
8. *陣列的擴容。給定一個數組，要求寫一個expand 函式，把原有陣列的長度擴容一倍，並保留原有陣列原有的內容。例如，給定一個數組int[] a = {1,2,3}，則擴容之後，a 陣列為：{1,2,3，0,0,0}
//關鍵程式碼
package com.peng.demo;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 0 };
arr = getExtendsArray(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
// 擴充套件陣列
public static int[] getExtendsArray(int[] arr) {
int[] temp=new int[arr.length*2];
System.arraycopy(arr,0,temp,0,arr.length);
arr=temp;
return arr;
}
}
9. *陣列的插入和刪除寫兩個函式，一個函式為delete 函式，宣告如下：public static void delete(int pos)該函式表示刪除陣列pos 位置上的元素。第二個函式為insert 函式，宣告如下：public static void insert(int pos, int value)該函式表示在陣列pos 位置上插入value 值。為了能在多個函式中使用同一個陣列，需要把這個陣列寫在函式的外面，類的裡面，並使用static 修飾。為了方便，還應該定義一個index 變數，用來儲存陣列的有效元素的個數。例如下面的程式碼
public class TestInsertDelete{
static int[] a = {1,3,2,5,7}; //多個函式可以直接操作該陣列
static int index = 5;
public static void main(String args[]){
delete(2); //1 3 5 7
insert(1, 4); //1 4 3 5 7
insert(0, 6); //6 1 4 3 5 7
}
public static void delete(int pos){…}
public static void insert(int pos, int value){…}
}
實現方式：1. delete 方法：把陣列pos 位後的所有元素向前移動1 位2. insert 方法：把陣列pos 位以及之後的元素向後移動1 位，然後設定value。要注意的是，insert 時有可能需要陣列擴容。有效元素的個數的含義：對於a 陣列，呼叫一次delete 之後，a 陣列的長度不變，長度依然為5，然而有效元素的個數為4 個。Tips:insert 方法中，如何判斷是否需要擴容：比較有效元素的個數和陣列的長度，如果這兩者一致，則需要擴容。
//題目的正確寫法
/*
增加時：控制陣列下標（index）+防止陣列越界
if(index>=arr.length-1){
//陣列擴容兩倍
}
1. 判斷下標是否越界 是的話reture掉
2. 判斷陣列大小是否已滿（是否需要擴容）
3. 放元素：方法一：從後往前遍歷，前一位覆蓋後一位+插入要插入的值；方法二：System.arraycopy();
*/
/*
刪除時：控制陣列下標（index）
1. 判斷下標是否越界(pos>index)
2. 移動pos之後的數到前一位，直到index也覆蓋了index-1的內容【方法：for迴圈或者用System.arraycope();】
3. index--
4. 注意陣列有效數小於等於陣列長度，可以縮容（縮小為原陣列的一半）
*/
//上述增加、刪除
package com.peng.demo;
import java.util.Arrays;
/*
* 陣列的插入與刪除
*/
public class ArraysOP {
static int[] arr = new int[5];
// 定義一個變數，標識要操作的陣列下標
static int index = 0;
// 向陣列中新增元素
public static void add(int i) {
// 判斷陣列是否需要擴容
if (index >= arr.length) {
arr = Arrays.copyOf(arr, arr.length * 2);
}
// 存放元素
arr[index] = i;
// 下標後移
index++;
}
// 刪除元素
public static void delete(int pos) {
if (pos >= index) {
System.out.println("超出資料範圍");
return;
}
/*
* //後一位覆蓋前一位 for(int i=pos;i<index-1;i++){ arr[i]=arr[i+1]; }
*/
System.arraycopy(arr, pos + 1, arr, pos, index - pos - 1);
// 下標前移
index--;
// 將當前位置的資料置為0
arr[index] = 0;
// 判斷是否可以進行縮容
if (index <= arr.length / 2) {
arr = Arrays.copyOf(arr, arr.length / 2);
}
}
// 向陣列插入元素
public static void insert(int pos, int value) {
// 判斷下標
if (pos > index || pos < 0) {
System.out.println("插入失敗！");
return;
}
// 判斷陣列是否需要進行擴容
if (index >= arr.length) {
arr = Arrays.copyOf(arr, arr.length * 2);
}
// 插入資料，後一位覆蓋前一位
/*
* for(int i=index;i>pos;i--){ arr[i]=arr[i-1;] }
*/
System.arraycopy(arr, pos, arr, pos + 1, index - pos);
arr[pos] = value;
// 向前移動一位
index++;
}
public static void main(String[] args) {
add(1);
add(5);
add(3);
delete(2);
insert(2, 10);
System.out.println(Arrays.toString(arr));
}
}
//簡單方式：
//刪除：new新陣列的長度為原陣列-1，將資料進行轉移，除了要刪除的
//插入：new新陣列的長度為原陣列+1，將資料（插入的資料也放在其中）進行轉移到新陣列中
package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4 };
// 插入測試
System.out.println(getInsArraya(arr, 1, 10)[1]);
// //刪除測試
// System.out.println(getDelArraya(arr,0)[0]);
}
// 刪除第x個元素
public static int[] getDelArraya(int[] arr, int x) {
int[] temp = new int[arr.length - 1];
for (int i = x; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
System.out.println("-----" + arr[i + 1] + "--------");
}
System.arraycopy(arr, 0, temp, 0, arr.length - 1);
return temp;
}
// 插入將y插入x處
public static int[] getInsArraya(int[] arr, int x, int y) {
int[] temp = new int[arr.length + 1];
for (int i = 0; i < x; i++) {
System.arraycopy(arr, 0, temp, 0, (x + 1));
}
temp[x] = y;
for (int j = x + 1; j < temp.length; j++) {
System.arraycopy(arr, x, temp, (x + 1), (temp.length - (x + 1)));
}
return temp;
}
}
10. *完成陣列的氣泡排序演算法：給定一個數組：int[] a = {1,3,2,7,5}，利用氣泡排序對其按照從小到大的順序排序，然後輸出結果
//冒泡演算法：相鄰兩個資料進行比較，規律：趟數與迴圈次數的和為陣列長度 package com.peng.demo;
public class Demo01 {
public static void main(String[] args) {
int[] a = { 1, 3, 2, 7, 5 };
System.out.println(getOrderArray(a)[0]);
System.out.println(getOrderArray(a)[1]);
System.out.println(getOrderArray(a)[2]);
System.out.println(getOrderArray(a)[3]);
System.out.println(getOrderArray(a)[4]);
}
public static int[] getOrderArray(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= arr.length - i; j++) {
if (arr[j - 1] > arr[j]) {
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
}
11. *使用第二種演算法對陣列進行排序
氣泡排序：相鄰兩個數進行比較，一次找一個最大的或是最小的（第n輪+第n輪的比較次數=陣列長度）
public static int[] getOrderArray(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= arr.length - i; j++) {
if (arr[j - 1] > arr[j]) {
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
選擇排序：第n位和之後的數字相比較（選中某一位一次和其他位置比較，習慣上從0位開始依次比較）
public static int[] getOrderArray(int[] arr) {
for(int i=1;i<=arr.length;i++){
for(int j=i-1;j<arr.length;j++){
if(arr[i-1]>arr[j]){
int temp=arr[i-1];
arr[i-1]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
12. *輸出楊輝三角
1
1 1
1 2 1
1 3 3 1
。。。
package com.peng.demo;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
// 楊輝三角
int n = 10;
int[][] arr = new int[n][];
for (int i = 0; i < arr.length; i++) {
int[] temp = new int[(i + 1)];
arr[i] = temp;
for (int j = 0; j < temp.length; j++) {
if (temp.length > 2) {
if (j == 0 || j == temp.length - 1) {
arr[i][j] = 1;
} else {
arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
}
} else {
arr[i][j] = 1;
}
}
}
//列印楊輝三角
for (int a = 0; a < arr.length; a++) {
for (int b = 0; b < arr[a].length; b++) {
System.out.print(arr[a][b] + "\t");
}
System.out.println();
}
}
}
13. *數學黑洞6174已知：一個任意的四位正整數。將數字重新組合成一個最大的數和最小的數相減，重複這個過程，最多七步，必得6174。即：7641-1467=6174。將永遠出不來。求證：所有四位數數字（全相同的除外），均能得到6174。輸出掉進黑洞的步數。
package com.peng.demo;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
int x = new Scanner(System.in).nextInt();
do {
System.out.println(x);
x = getMax(x) - getMin(x);
} while (x != 6174);
System.out.println(x);
}
// 任意數字求最大值
public static int getMax(int x) {
int[] temp = new int[4];
for (int i = 0; i < temp.length; i++) {
temp[i] = x % 10;
x /= 10;
}
Arrays.sort(temp);
return 1000 * temp[3] + 100 * temp[2] + 10 * temp[1] + temp[0];
}
// 任意數字求最小值
public static int getMin(int x) {
int[] temp = new int[4];
for (int i = 0; i < temp.length; i++) {
temp[i] = x % 10;
x /= 10;
}
Arrays.sort(temp);
// 防止出現類類似0123，0開頭的數
return 1000 * temp[0] + 100 * temp[1] + 10 * temp[2] + temp[3];
}
}
14. *篩選法求質數：輸入一個整數n，求小於這個整數的所有質數。
演算法：定義一個長度為n 的boolean 陣列，true 表示是質數，false 表示不是質數。初始均為true。之後從2 開始迴圈：1. 找到第一個值為true 的下標i2. 把所有下標為i 的倍數的值置為false。直到掃描完陣列中的所有數值。最後遍歷陣列，如果下標i 的值為true，則說明i 為質數
//注意1：陣列的下標是從0開始的，如果數想與下標一一對應的話，必須將陣列大小+1處理；
//注意2：遍歷時，0,1不用遍歷，直接從2開始
package com.peng.demo;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
// 因為下標從0開始到length-1，所以這裡建立時大小為n+1；
boolean[] b = new boolean[n + 1];
// 開始認為所有