diff --git "a/01 \351\231\210\346\242\246\346\242\246/20230330.md" "b/01 \351\231\210\346\242\246\346\242\246/20230330.md" deleted file mode 100644 index 5dedc960184c45d45dcb0e2dc6d1e8f12d860f24..0000000000000000000000000000000000000000 --- "a/01 \351\231\210\346\242\246\346\242\246/20230330.md" +++ /dev/null @@ -1,131 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -```java -public static void main(String[] args) { - char a = '1' ; - if (a>='0' && a<='9'){ - System.out.println("是数字字符"); - }else{ - System.out.println("不是数字字符"); - } -} -``` - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -```java -public static void main(String[] args) { - char a = '1' ; - if (a>='a' && a<='z' || a>='A' && a<='Z'){ - System.out.println("是字母字符"); - }else{ - System.out.println("不是字母字符"); - } -} -``` - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -``` -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int date = scanner.nextInt(); - if ((date%4==0 && date%100!=0) || date%400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } -} -``` - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int a = scanner.nextInt(); - int a1 = ((a%10)*(a%10)*(a%10))+((a/10%10)*(a/10%10)*(a/10%10))+((a/100%10)*(a/100%10)*(a/100%10)); - String b = "" + a; - if (b.length()==3 && a1==a){ - System.out.println("是水仙花数"); - }else{ - System.out.println("不是水仙花数"); - } -} -``` - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int a = scanner.nextInt(); - String b = ""+a; - int a1 = a%10; - int a2 = a/10%10; - int a3 = a/1000%10; - int a4 = a/10000%10; - if (b.length()!=5) { - System.out.println("不是五位数"); - }else if(a1==a4 && a2==a3){ - System.out.println("是回文数"); - }else{ - System.out.println("不是回文数"); - } -} -``` - diff --git "a/01 \351\231\210\346\242\246\346\242\246/20230404 \347\273\203\344\271\240.md" "b/01 \351\231\210\346\242\246\346\242\246/20230404 \347\273\203\344\271\240.md" deleted file mode 100644 index f1082eb0fa9feb4d49b56de7970b3db7d898f65f..0000000000000000000000000000000000000000 --- "a/01 \351\231\210\346\242\246\346\242\246/20230404 \347\273\203\344\271\240.md" +++ /dev/null @@ -1,147 +0,0 @@ -## 冒泡法 - -```java -int []arr={3,5,2,15,38,26,27}; -System.out.println("排序前"); -for (int n:arr){ - System.out.print(n+" "); -} -for (int i = 0; i < arr.length; i++) { - for (int j = 0; j < arr.length-1; j++) { - if (arr[j]>arr[j+1]) { - int temp=arr[j]; - arr[j]=arr[j+1]; - arr[j+1]=temp; - } - } -} -System.out.println(); -System.out.println("排序后"); -for (int n:arr){ - System.out.print(n+" "); -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java -int arr[]={5,2,3,4,1}; -int min=arr[0]; -int index=0; -for (int i = 0; i < arr.length; i++) { - if (min>arr[i]){ - index=i; - } -} -System.out.println("这个数组的最小值是"+arr[index]); -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -int arr[]={5,2,3,4,1}; -int count=0; -System.out.println("索引值与对应元素都是奇数的数有:"); -for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.print(arr[i]+" "); - count++; - } -} -if(count==0){ - System.out.println("此条件没有符合的数字"); -} -``` - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -Scanner sc = new Scanner(System.in); -Random r =new Random(); -int arr[]=new int[5]; -int count=0; -for (int i = 0; i < 5; i++) { - System.out.println("请输入第"+(i+1)+"个数字,要在1-60之间"); - arr[i]= sc.nextInt(); -} -int num=r.nextInt(8)+2; -System.out.print("是倍数的有:"); -for (int j = 0; j < arr.length; j++) { - if (arr[j]%num!=0){ - System.out.print(arr[j]+" "); - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -int arr[]={9,1,3,4,54,56,23,22,20,43,45,78}; -int count=0; -System.out.println("能被6整除的数有:"); -for (int i = 0; i < arr.length; i++) { - if(arr[i]%2==0){ - System.out.print(arr[i]+" "); - count++; - } -} -if (count==0){ - System.out.println("没有符合这个条件的数字"); -} -System.out.println(6%3); -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -Random r=new Random(); -int arr[]=new int[20]; -int count=0; -Scanner sc=new Scanner(System.in); -System.out.println("请输入指定数字,范围在20-40之间"); -int n= sc.nextInt(); -for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(21) + 20; - if (n == arr[i]) { - count++; - } -} -if(count==0){ - System.out.println("没有出现指定数字"); -}else{ - System.out.println("出现数字"+n+"出现了"+count+"次"); -} -``` - - - - - diff --git "a/03 \350\265\226\345\277\203\345\246\215/20230328 \345\244\215\344\271\240.md" "b/03 \350\265\226\345\277\203\345\246\215/20230328 \345\244\215\344\271\240.md" deleted file mode 100644 index 364c1ffb028df8387140ba1f2230082ef2a6c323..0000000000000000000000000000000000000000 --- "a/03 \350\265\226\345\277\203\345\246\215/20230328 \345\244\215\344\271\240.md" +++ /dev/null @@ -1,261 +0,0 @@ -# 知识点 - -运算符 - -## 题目1(训练) - -身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： - -​ 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 - -​ 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 - -现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？ - -### 训练提示 - -1. 已知的父母身高如何用代码体现？ - -2. 题目中的公式如何转化为代码？ - -### 解题方案 - -1. 使用变量的定义和算术运算符完成本题 - -### 操作步骤 - -1. 定义小数变量代表父亲身高 - -2. 定义小数变量代表母亲身高 - -3. 通过儿子身高计算方式计算儿子身高 - -4. 通过女儿身高计算方式计算女人身高 - -```java -public class First { - public static void main(String[] args) { - int f=177,m=165; - double s=(f+m)*1.08/2,d=(f*0.923+m)/2; - System.out.printf("儿子的身高是"+s+"cm,女儿的身高是"+d+"cm"); - } -} -``` - - - -## 题目2（训练） - -红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？ - -### 训练提示 - -1. 用什么知识点来计算她们现在的钱有多少？ -2. 如何对比两个人的钱数？ - -### 解题方案 - -1. 使用赋值运算符和算术运算符计算各自的钱，使用比较运算符对比大小 - -### 操作步骤 - -1. 定义红茶妹妹原来的钱为整数变量 -2. 定义绿茶妹妹原来的钱为整数变量 -3. 使用赋值运算符和算术运算符计算其现有的钱 -4. 使用比较运算符对数值做出比较 - -```java -public class First { - public static void main(String[] args) { - int h=21,l=24; - int h1=h*2+3,l1=l*2; - String result= h1==l1? "结果一样多":"结果不一样多"; - System.out.println(result); - } -} -``` - -## 题目3（综合） - -某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？ - -### 训练提示 - -1. 有两种购买方式，一种是不使用优惠价，另一种是使用优惠价。分别计算花费后，对两种方式的花费作对比。 - -### 解题方案 - -1. 使用算术运算符、赋值运算符和三元运算符联合完成本题 - -### 操作步骤 - -1. 使用算术运算符求出不使用优惠时的总价 -2. 使用三元运算符判断总价是否满足打折条件，并求出折后总价 -3. 使用算术运算符求出使用优惠价时的总价 -4. 使用三元运算符判断最终更合算的购买方式和花费 - -### 参考答案 - -```java -public class First { - public static void main(String[] args) { - double order1 = (24+8+3)*0.8; - int order2=16+8+3; - if (order1>order2) { - System.out.println("方案一比较便宜,花费"+order1+"元"); - }else if(order1==order2){ - System.out.println("方案二和方案二是一个价格,花费"+order1+"元"); - }else{ - System.out.println("方案二比较便宜,花费"+order2+"元"); - } - } -} -``` - -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} -``` - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入a-z或者A-Z的其中一个字母"); - char e=num.next().charAt(0); - if(e>='a' & e<='z'){ - System.out.println("这个字符是字母字符"); - }else{ - System.out.println("这个字符不是字母字符"); - } - } -} -``` - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入年份"); - int year=num.nextInt(); - if (year%4==0 & year%100!=0 | year/400==0){ - System.out.println("这个年份是闰年"); - }else{ - System.out.println("这个年份不是闰年"); - } - } -} -``` - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入一个三位整数"); - int x= num.nextInt(); - int a=x%10; - int b=x/10%10; - int c=x/100; - if(a*a*a+b*b*b+c*c*c==x){ - System.out.println("这个数是水仙花数"); - }else{ - System.out.println("这个数不是水仙花数"); - } - } -} -``` - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入一个五位整数"); - int y= num.nextInt(); - int a=y%10; - int b=y/10%10; - int c=y/100%10; - int d=y/1000%10; - int e=y/10000; - if (a==e & b==d){ - System.out.println("这个数是回文数"); - }else{ - System.out.println("这个数不是回文数"); - } - } -} -``` - diff --git "a/03 \350\265\226\345\277\203\345\246\215/20230404 \347\273\203\344\271\240.md" "b/03 \350\265\226\345\277\203\345\246\215/20230404 \347\273\203\344\271\240.md" deleted file mode 100644 index 1ace1d65ef6b5f2f5cadf14fef6af389eb0029a8..0000000000000000000000000000000000000000 --- "a/03 \350\265\226\345\277\203\345\246\215/20230404 \347\273\203\344\271\240.md" +++ /dev/null @@ -1,146 +0,0 @@ -## 冒泡法 - -```java -int []arr={3,5,2,15,38,26,27}; -System.out.println("排序前"); -for (int n:arr){ - System.out.print(n+" "); -} -for (int i = 0; i < arr.length; i++) { - for (int j = 0; j < arr.length-1; j++) { - if (arr[j]>arr[j+1]) { - int temp=arr[j]; - arr[j]=arr[j+1]; - arr[j+1]=temp; - } - } -} -System.out.println(); -System.out.println("排序后"); -for (int n:arr){ - System.out.print(n+" "); -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java -int arr[]={5,2,3,4,1}; -int min=arr[0]; -int index=0; -for (int i = 0; i < arr.length; i++) { - if (min>arr[i]){ - index=i; - } -} -System.out.println("这个数组的最小值是"+arr[index]); -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -int arr[]={5,2,3,4,1}; -int count=0; -System.out.println("索引值与对应元素都是奇数的数有:"); -for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.print(arr[i]+" "); - count++; - } -} -if(count==0){ - System.out.println("此条件没有符合的数字"); -} -``` - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -Scanner sc = new Scanner(System.in); -Random r =new Random(); -int arr[]=new int[5]; -int count=0; -for (int i = 0; i < 5; i++) { - System.out.println("请输入第"+(i+1)+"个数字,要在1-60之间"); - arr[i]= sc.nextInt(); -} -int num=r.nextInt(9)+2; -System.out.print("是倍数的有:"); -for (int j = 0; j < arr.length; j++) { - if (arr[j]%num!=0){ - System.out.print(arr[j]+" "); - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -int arr[]={9,1,3,4,54,56,23,22,20,43,45,78}; -int count=0; -System.out.println("能被6整除的数有:"); -for (int i = 0; i < arr.length; i++) { - if(arr[i]%2==0){ - System.out.print(arr[i]+" "); - count++; - } -} -if (count==0){ - System.out.println("没有符合这个条件的数字"); -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -Random r=new Random(); -int arr[]=new int[20]; -int count=0; -Scanner sc=new Scanner(System.in); -System.out.println("请输入指定数字,范围在20-40之间"); -int n= sc.nextInt(); -for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(21) + 20; - if (n == arr[i]) { - count++; - } -} -if(count==0){ - System.out.println("没有出现指定数字"); -}else{ - System.out.println("出现数字"+n+"出现了"+count+"次"); -} -``` - - - - - diff --git "a/04 \346\235\216\346\230\216\345\201\245/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/04 \346\235\216\346\230\216\345\201\245/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" deleted file mode 100644 index 3c2cb3d18e0e4133c2dd89c2caf777bc6329bc42..0000000000000000000000000000000000000000 --- "a/04 \346\235\216\346\230\216\345\201\245/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" +++ /dev/null @@ -1,213 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -### 答案一 - -~~~ java -import java.util.Scanner; -public class D5 { -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要小于或等于字符9即可。 -// 3、判断完成之后，打印判断的结果。 - public static void main(String[] args) { - - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符："); - char c = sc.next().charAt(0); - - if (c>='0' && c<='9') { - System.out.println("是数字字符"); - }else{ - System.out.println("不是数字字符"); - } - } - } -} -~~~ - - - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -### 答案二 - -~~~ java -import java.util.Scanner; - -public class D6 { -// 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 -// 2、字符是否为字母字符： 数字字符的范围 a-z 或者 A-Z 之间都属于字母字符， -// 因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z -// 3、判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符："); - char c = sc.next().charAt(0); - - if((c>='a' && c<='z') || (c>='A' && c<='Z')){ - System.out.println("是字母字符"); - }else{ - System.out.println("不是字母字符"); - } - } - } -} -~~~ - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -### 答案三 - -~~~ java -import java.util.Scanner; - -public class D7 { - // 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份："); - int year = sc.nextInt(); - - if(year % 4 == 0 || year % 400 == 0 && year % 100 !=0){ - System.out.println(year+"是闰年"); - }else{ - System.out.println(year+"不是闰年"); - } - } - } -} -~~~ - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -### 答案四 - -~~~ java -import java.util.Scanner; - -public class D1 { - // 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - public static void main(String[] args) { - - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位整数"); - int number = sc.nextInt(); - - int ge = number % 100 % 10; - int shi = number / 10 % 10; - int bai = number / 100; - - if (ge * ge * ge + shi * shi * shi + bai * bai * bai == number) { - System.out.println(number + "是水仙花数"); - } else { - System.out.println(number + "不是水仙花数"); - } - } - - } -} -~~~ - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -### 答案五 - -~~~ java -import java.util.Scanner; - -public class D2 { - // 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321，23732，56665 - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位整数："); - int number = sc.nextInt(); - - int ge = number%10; - int shi = number/10%10; - int bai = number/100%10; - int qian = number/1000%10; - int wan = number/10000%10; - - if(ge==wan && shi==qian){ - System.out.println(number+"是回文数"); - }else{ - System.out.println(number+"不是回文数"); - } - - } - } -} -~~~ - - - diff --git "a/04 \346\235\216\346\230\216\345\201\245/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" "b/04 \346\235\216\346\230\216\345\201\245/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" deleted file mode 100644 index d6d696c43745db77feb1d2762a094e2584353237..0000000000000000000000000000000000000000 --- "a/04 \346\235\216\346\230\216\345\201\245/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" +++ /dev/null @@ -1,202 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -~~~ java -import java.util.Scanner; - -public class D1 { - // 定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值 - - public static void main(String[] args) { - - //1.定义5个元素数组 - int[] arr = new int[5]; - Scanner sc = new Scanner(System.in); - - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入五个数字添加到数组："); - int num = sc.nextInt(); - arr[i]=num; - } - - //3.遍历数组求数组中的最小值 - int min = arr[0]; - for (int i = 1; i < arr.length; i++) { - if(min>arr[i]){ - min=arr[i]; - } - } - System.out.println("这个数组中最小值为："+min); - } -} -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -import java.util.Scanner; - -public class D2 { - //需求：求出数组中索引与索引对应的元素都是奇数的元素 - - public static void main(String[] args) { - - //1、定义数组 - int[] arr =new int[5]; - Scanner sc = new Scanner(System.in); - - //2、键盘录入数组的每个元素并添加到数组 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入数组里面的值："); - int num = sc.nextInt(); - arr[i]=num; - } - - //3、遍历数组,判断索引是否是奇数（索引 % 2 != 0）,判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - for (int i = 0; i < arr.length; i++) { - if(i % 2 !=0 && arr[i] % 2 !=0){ - System.out.println("索引为："+i+"\n"+"值为："+arr[i]); - } - } - } -} -~~~ - - - -**3.按要求main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - //PS：输入的数组元素范围包括1和60，不需要代码判断 - public static void main(String[] args) { - //1. 定义一个长度为5的int型数组arr - int[] arr = new int[5]; - Scanner sc = new Scanner(System.in); - - //2.提示用户输入5个1-60之间的数字作为数组元素 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入5个1-60之间的数字："); - int number = sc.nextInt(); - arr[i]=number; - } - - //3. 生成2-10（范围包含2和10）之间的随机数num - Random ran = new Random(); - int num = ran.nextInt(9)+2; - - //4. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % num !=0){ - System.out.println("数组中"+arr[i]+"不是"+num+"的倍数"); - } - } - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - // 有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - - //遍历数组找到能被6整除的元素 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % 6 == 0){ - System.out.println("数组中"+arr[i]+"能被6整除"); - } - } - } -} -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Arrays; -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { - //定义一个长度为20的数组，元素为20-40的随机数， - //要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Random ran = new Random(); - Scanner sc = new Scanner(System.in); - - //1.循环将随机生成的数添加到数组 - for (int i = 0; i < arr.length; i++) { - int num = ran.nextInt(21) + 20; - arr[i] = num; - } - - //打印数组 - System.out.println("随机生成的数组为"); - System.out.println(Arrays.toString(arr)); - - //2.键盘录入一个指定元素,并判断输入的值是否在20-40之间 - System.out.println("请输入一个20-40的数："); - int num1 = sc.nextInt(); - - while (true) { - if(num1<20 || num1>40){ - System.out.println("输入的数值不在20-40之间，请重新输入"); - num1=sc.nextInt(); - }else{ - break; - } - } - - //3.遍历数组判断指定元素在数组中出现的次**数，并打印 - int count = 0; - for (int i = 0; i < arr.length; i++) { - if (arr[i] == num1) { - count++; - } - } - System.out.println(num1+"在数组中出现了："+count+"次"); - } -} - -~~~ diff --git "a/05 \350\260\242\351\223\226\346\265\251/20230328 java\345\244\215\344\271\240.md" "b/05 \350\260\242\351\223\226\346\265\251/20230328 java\345\244\215\344\271\240.md" deleted file mode 100644 index 93ff37f231a8fc51578b20dbd6b6037e665cd418..0000000000000000000000000000000000000000 --- "a/05 \350\260\242\351\223\226\346\265\251/20230328 java\345\244\215\344\271\240.md" +++ /dev/null @@ -1,188 +0,0 @@ -# 练习 - -## 第一题 - -```java -public class zy { -// 身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： -// -// 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 -// -// 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 -// -// 现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？ - public static void main(String[] args) { - double f = 177; - double m = 165; - double e = (f+m)*1.08/2; - double v = (f*0.923+m)/2; - System.out.println("预计儿子的身高为："+e); - System.out.println("预计女儿的身高为："+v); - } -} -``` - -## 第二题 - -```java -public class zy { -// 红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。 -// 绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。 -// 那么红茶和绿茶现在的钱一样多，请问对么？ - public static void main(String[] args) { - int hc = 21; - int lc = 24; - if(hc*2+3==lc*2){ - System.out.println("他们的钱一样多，对"); - }else{ - System.out.println("他们的钱不一样多，错"); - } - } -} -``` - -## 第三题 - -``` java -public class zy { -// 某小伙想定一份外卖，商家的优惠方式如下： -// 鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。 -// 订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。 -// 那么这个小伙要点这三样东西，最少要花多少钱？ - public static void main(String[] args) { - int yxrs = 24; - int hsm = 8; - int mf = 3; - double a = (yxrs+hsm+mf)*0.8; - int b = (16+hsm+mf); - double zj = a < b ? a:b; - System.out.println("最少要花："+zj+"元"); - } -} -``` - -# 作业 - - - -### 第一题 - -```java -import java.util.Scanner; - -public class zy { -// **1、判断一个字符数据是否是数字字符 ** -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符， -// 因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -// -// 3、判断完成之后，打印判断的结果。 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符"); - int a = sc.nextInt(); - if(a>=0|a<=9){ - System.out.println(a+"这个字符为数字字符"); - }else { - System.out.println(a+"这个字符不是数字字符"); - } - } -} -``` - -### 第二题 - -``` java -// 判断一个字符数据是否是字母字符 -``` - - - -### 第三题 - -``` java -import java.util.Scanner; - -public class zy { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份"); - int a = sc.nextInt(); - if(a%400==0){ - System.out.println(a+"为闰年"); - }else { - if(a%100==0){ - System.out.println(a +"不为闰年"); - }else { - if(a%4==0){ - System.out.println(a+"为闰年"); - } else { - System.out.println(a+"不为闰年"); - } - } - } - - - - } -} -``` - -### 第四题 - -```java -import java.util.Scanner; - -public class zy { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等， -// 则为水仙花数， - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位数"); - int a = sc.nextInt(); - int bai = a/100; - int shi = a/10%10; - int ge = a%10; - if (bai*bai*bai+shi*shi*shi+ge*ge*ge==a){ - System.out.println(a+"这个数为水仙花数"); - }else{ - System.out.println(a+"这个数不为水仙花数"); - } - } -} -``` - -### 第五题 - -``` java -import java.util.Scanner; - -public class zy { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。 -// 如：12321 23732 56665 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位数"); - int a = sc.nextInt(); - int ge = a%10000%1000%100%10; - int shi = a%10000%1000%100/10; - int qian = a%10000/1000; - int wan = a/10000; - if (ge==wan & shi==qian){ - System.out.println(a+"这个数为回文数"); - }else{ - System.out.println(a+"这个数不为回文数"); - } - } -} -``` - - - diff --git "a/05 \350\260\242\351\223\226\346\265\251/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" "b/05 \350\260\242\351\223\226\346\265\251/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" deleted file mode 100644 index 02f463d8da5a8ae13032c81e19052d444985116a..0000000000000000000000000000000000000000 --- "a/05 \350\260\242\351\223\226\346\265\251/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" +++ /dev/null @@ -1,167 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -~~~ java -import java.util.Scanner; - -public class D1 { - public static void main(String[] args) { - int[] num =new int[5]; - for (int i = 0; i < num.length; i++) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入"+(i+1)); - num[i]=sc.nextInt(); - } - int min = num[0]; - for (int i = 0; i num[i]){ - min=num[i]; - } - } - System.out.println("最小的是"+min); - } - } - -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -public class D2 { - public static void main(String[] args) { -// 1、遍历数组 -// -// 2、判断索引是否是奇数（索引 % 2 != 0） -// -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// -// 4、满足条件输出结果 - int[] arr ={12,11,17,4,6}; - for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.println("基数是"+arr[i]); - - } - } - - } -} - -~~~ - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - public static void main(String[] args) { - int[] arr = new int[5]; - for (int i = 0; i < arr.length; i++) { - Scanner sc= new Scanner(System.in); - System.out.println("请输入1-60的数"+(i+1)+":"); - arr[i]=sc.nextInt(); - } - Random ran=new Random(); - int num =ran.nextInt(8)+2; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0){ - System.out.println(arr[i]+"不是"+num+"的倍数"); - } - } - - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - public static void main(String[] args) { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - int[] arr ={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.print(+arr[i]+" "); - - } - - } - } -} - -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { -// **5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Scanner sc= new Scanner(System.in); - System.out.println("输入20-40的数:"); - int a=sc.nextInt(); - Random ran =new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = ran.nextInt(21)+20; - } - int count=0; - for (int i = 0; i shu[i]){ - min=shu[i]; - } - } - System.out.println(min); - } -} -``` - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -import java.util.Random; - -//**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -//**分析：** -// 1、遍历数组 -// 2、判断索引是否是奇数（索引 % 2 != 0） -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// 4、满足条件输出结果 -public class zy { - public static void main(String[] args) { - int [] shu = new int [10]; - Random ran = new Random(); - for(int i=0 ; i<10 ; i++){ - int shui = ran.nextInt(101); - shu [i] = shui; - System.out.print(shu[i]+" "); - } - System.out.println(); - for(int i=0 ; i<10 ; i++){ - if(shu[i]%2!=0){ - System.out.print(shu[i]+" "); - } - } - } -} -``` - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -import java.util.Random; - -//**3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** -public class zy { - public static void main(String[] args) { - int [] arr = new int [5]; - Random ran = new Random(); - for(int i=0;i<5;i++){ - int shui = ran.nextInt(60)+1; - arr[i] = shui; - System.out.print(arr[i]+" "); - } - int shui = ran.nextInt(9)+2; - int num = shui; - System.out.println(); - System.out.println(num); - for(int i=0;i<5;i++){ - if(arr[i] %num!= 0){ - System.out.print(arr[i]+" "); - } - } - } -} -``` - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java - -//**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** -public class zy { - public static void main(String[] args) { - int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - for(int i=0;i=20 && shu <=40){ - int count = 0; - for (int i=0;inum[i]){ - min=num[i]; - } - } - System.out.println("最小的是"+min); - } - } - -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -public class D2 { - public static void main(String[] args) { -// 1、遍历数组 -// -// 2、判断索引是否是奇数（索引 % 2 != 0） -// -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// -// 4、满足条件输出结果 - int[] arr ={12,11,17,4,6}; - for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.println("基数是"+arr[i]); - - } - } - - } -} - -~~~ - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - public static void main(String[] args) { - int[] arr = new int[5]; - for (int i = 0; i < arr.length; i++) { - Scanner sc= new Scanner(System.in); - System.out.println("请输入1-60的数"+(i+1)+":"); - arr[i]=sc.nextInt(); - } - Random ran=new Random(); - int num =ran.nextInt(8)+2; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0){ - System.out.println(arr[i]+"不是"+num+"的倍数"); - } - } - -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// -//​ b. 生成2-10（范围包含2和10）之间的随机数num -// -//​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// -//​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - public static void main(String[] args) { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - int[] arr ={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.print(+arr[i]+" "); - - } - - } - } -} - -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { -// **5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Scanner sc= new Scanner(System.in); - System.out.println("输入20-40的数:"); - int a=sc.nextInt(); - Random ran =new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = ran.nextInt(21)+20; - } - int count=0; - for (int i = 0; i num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+ min); - } -} - -``` - -### 作业2 - -```java -public class zy2 { - // **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - public static void main(String[] args) { - int [] num = {4,5,8,16,22,17}; - for (int i = 0; i < num.length; i++) { - if (i%2 != 0 && num[i]%2 != 0 ){ - System.out.println("索引:"+i+",元素："+ num[i]+"，满足条件"); - } - } - } -} - -``` - -### 作业3 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy3 { -// **3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - public static void main(String[] args) { - int [] arr = new int[5]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) { - arr[i] = sc.nextInt(); - } - - Random r = new Random(); - int num = r.nextInt(9)+2; - - for (int a = 0; a < arr.length; a++) { - if (arr[a]%num != 0){ - System.out.println(arr[a]+"不是随机数的倍数"); - } - } - } -} - -``` - -### 作业4 - -```java -public class zy4 { - // 4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - // 要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int [] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6 == 0){ - System.out.print(" "+ arr[i]); - } - } - } -} - -``` - -### 作业5 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy5 { - // 5.定义一个长度为20的数组，元素为20-40的随机数， - // 要求判断指定元素在数组中出现的次数， - // 指定元素为键盘录入范围为20-40之间。 - public static void main(String[] args) { - int [] num = new int[20]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入一个20-40的整数"); - int a = sc.nextInt(); - - Random r = new Random(); - - for (int i = 0; i < num.length; i++) { - num[i]= r.nextInt(21)+20; - } - - int b = 0; - for (int x = 0; x < num.length; x++) { - if (num[x] == a){ - b++; - } - } - - System.out.println("指定元素在随机数组出现的次数为："+b+"次。"); - - } -} -``` - diff --git "a/10 \346\270\251\350\264\265\351\233\257/20230406 java\344\275\234\344\270\232.md" "b/10 \346\270\251\350\264\265\351\233\257/20230406 java\344\275\234\344\270\232.md" deleted file mode 100644 index b4133356d6be3abbb0e1a7afbadf3acc5a17203d..0000000000000000000000000000000000000000 --- "a/10 \346\270\251\350\264\265\351\233\257/20230406 java\344\275\234\344\270\232.md" +++ /dev/null @@ -1,135 +0,0 @@ -# 作业 - -### 作业1 - -```java -public class zy1 { - // **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - // 1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - public static void main(String[] args) { - int [] num = {10,30,40,50,20}; - int min = num[0]; - for (int i = 1; i < num.length ; i++) { - if (min>num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+ min); - } -} - -``` - -### 作业2 - -```java -public class zy2 { - // **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - public static void main(String[] args) { - int [] num = {4,5,8,16,22,17}; - for (int i = 0; i < num.length; i++) { - if (i%2 != 0 && num[i]%2 != 0 ){ - System.out.println("索引:"+i+",元素："+ num[i]+"，满足条件"); - } - } - } -} - -``` - -### 作业3 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy3 { -// **3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - public static void main(String[] args) { - int [] arr = new int[5]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) { - arr[i] = sc.nextInt(); - } - - Random r = new Random(); - int num = r.nextInt(9)+2; - - for (int a = 0; a < arr.length; a++) { - if (arr[a]%num != 0){ - System.out.println(arr[a]+"不是随机数的倍数"); - } - } - } -} - -``` - -### 作业4 - -```java -public class zy4 { - // 4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - // 要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int [] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6 == 0){ - System.out.print(" "+ arr[i]); - } - } - } -} - -``` - -### 作业5 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy5 { - // 5.定义一个长度为20的数组，元素为20-40的随机数， - // 要求判断指定元素在数组中出现的次数， - // 指定元素为键盘录入范围为20-40之间。 - public static void main(String[] args) { - int [] num = new int[20]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入一个20-40的整数"); - int a = sc.nextInt(); - - Random r = new Random(); - - for (int i = 0; i < num.length; i++) { - num[i]= r.nextInt(21)+20; - } - - int b = 0; - for (int x = 0; x < num.length; x++) { - if (num[x] == a){ - b++; - } - } - - System.out.println("指定元素在随机数组出现的次数为："+b+"次。"); - - } -} -``` - diff --git "a/11 \351\202\271\344\272\250\344\274\237/02 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/11 \351\202\271\344\272\250\344\274\237/02 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" deleted file mode 100644 index 204e8c815b3d3b6de27b7511c919bed6f51ae8b9..0000000000000000000000000000000000000000 --- "a/11 \351\202\271\344\272\250\344\274\237/02 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" +++ /dev/null @@ -1,238 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -``` java -import sun.security.util.Length; - -import java.util.Scanner; -//1、判断一个字符数据是否是数字字符 -// 分析： -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -// 3、判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String a1 = sc.next(); - int num=a1.length(); - int pd=-1; - for(int i=0;i=2){ - System.out.println("超出请重新输入"); - return; - } - int pd=-1; - int asc = ziMu.charAt(0); - for(int i=97;i<=97+25;i++){ - if (asc==i){ - System.out.println("是字母字符"); - return; - }if(i==97+25){ - pd=-2; - } - } - if(pd==-2) { - for (int i = 65; i <= 65 + 25; i++) { - if (asc == i) { - pd=-1; - System.out.println("是字母字符"); - return; - } - if (i == 65 + 25) { - pd = -2; - } - } - } - if (pd==-2) { - System.out.println("不是字母字符"); - } - } -} -``` - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -//3、判断指定的年份是否为闰年，请使用键盘录入 -//分析： -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入年份"); - int nf = sc.nextInt(); - if (nf % 100!=0 & nf % 4==0 | nf % 400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } - } -} -``` - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -import java.util.Scanner; - -//4、判断一个数字是否为水仙花数,请使用键盘录入 -//水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， -//分析： -// 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 -// 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 -// 2、判断的过程 -// a) 将3位数字的每一位上的数字拆分下来 -// b) 计算每位数字的3次幂之和 -// C) 用和值 和 原来的数字进行比较 -// D) 打印判断的比较结果即可 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入三位数"); - String shuZi = sc.next(); - if (shuZi.length()>3){ - System.out.println("请重新输入"); - return; - } - int q1=Integer.parseInt(shuZi); - int b = q1/100; - int s = q1/10%10; - int g = q1%10; - if(q1==(b*b*b)+(s*s*s)+(g*g*g)){ - System.out.println("是水仙花束"); - }else{ - System.out.println("不是水仙花束"); - } - } -} -``` - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -//5、判断一个5位数字是否为回文数，使用键盘录入 -//五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 -//分析： -// 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 -// 2、判断的过程 -// a) 将5位数字的万、千、十、个位数拆分出来 -// b) 判断比较万位和个位 、 千位和十位是否相等 -// 3、判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入五位数"); - String shuZi = sc.next(); - if (shuZi.length()>5){ - System.out.println("请重新输入"); - return; - } - if (shuZi.charAt(0)==shuZi.charAt(4) & shuZi.charAt(1)==shuZi.charAt(3)){ - System.out.println("是回文数"+shuZi); - }else{ - System.out.println("不是回文数"+shuZi); - } - } -} -``` - diff --git "a/11 \351\202\271\344\272\250\344\274\237/20230405\344\275\234\344\270\232.md" "b/11 \351\202\271\344\272\250\344\274\237/20230405\344\275\234\344\270\232.md" deleted file mode 100644 index 96ee2ef591c6f30975f135ff6b138f0a7cf8176c..0000000000000000000000000000000000000000 --- "a/11 \351\202\271\344\272\250\344\274\237/20230405\344\275\234\344\270\232.md" +++ /dev/null @@ -1,56 +0,0 @@ -```java -public class Atime0405 { - public static void main(String[] args) { -// *1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** -// -//**操作步骤：** -// 1.定义5个元素数组 -// 2.可以使用初始化数组的两种方式之一为数组元素赋值 -// 3.遍历数组求数组中的最小值 - int[] Arr =new int[]{1,2,3,4,5}; - int[] a= new int[5]; - for (int i = 0; i arr[i]){ - min=arr[i]; - } - } - System.out.println("最小值； "+min); -// **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -//1、遍历数组 -//2、判断索引是否是奇数（索引 % 2 != 0） -//3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -//4、满足条件输出结果 - int[] arre={12,98,99,54,31,2}; -// **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -// 1、遍历数组 -// 2、判断索引是否是奇数（索引 % 2 != 0） -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// 4、满足条件输出结果 - arra(arre); -//**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - aba(); -//**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - num(); - } - public static void arra(int[] arr){ - - for (int i = 0; i < arr.length; i++) { - if (arr[i]%2!=0 && i%2 !=0){ - System.out.println("奇数有： "+arr[i]); - }; - } - } - public static void aba(){ - Scanner sc=new Scanner(System.in); - int a[]=new int[5]; - System.out.println("请输入5个1-60之间的数字作为数组元素"); - - for (int i=0;i='0' & b<=9 ){ - System.out.println(true); - }else { - System.out.println(false); - } -``` - - - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -public class Day01 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - char b= sc.nextLine().charAt(0); - char a= '1'; - if (b>='a' & a<='z' | b>='A' & a<='Z'){ - System.out.println(true); - }else { - System.out.println(false); - } - } -} -``` - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -public class Day02 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入年份："); - int i = sc.nextInt(); - if (i%4 == 0 && i%100 != 0 ||i%400 == 0 ){ - System.out.println("是闰年"); - }else{ - System.out.println("是平年"); - } - } -} -``` - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -import javax.swing.text.Style; -import java.util.Scanner; - -public class Day03 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一位三位数"); - int i = sc.nextInt(); - int a = i%10; - int b = i/10%10; - int c = i/100; - if (a*a*a+b*b*b+c*c*c == i){ - System.out.println("是水仙花数"); - }else { - System.out.println("不是水仙花数"); - } - } -} -``` - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -public class Day04 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位数："); - int num = sc.nextInt(); - int a =num%10; - int s = num/10%10; - int f = num/100%10; - int e = num/1000%10; - int t = num/10000; - if (a == t && s == e){ - System.out.println(num+":是回文数"); - }else { - System.out.println(num+":不是回文数"); - } - } -} -``` - - - diff --git "a/14 \346\235\216\344\277\212\345\205\264/20230404 \347\273\203\344\271\240.md" "b/14 \346\235\216\344\277\212\345\205\264/20230404 \347\273\203\344\271\240.md" deleted file mode 100644 index 1ace1d65ef6b5f2f5cadf14fef6af389eb0029a8..0000000000000000000000000000000000000000 --- "a/14 \346\235\216\344\277\212\345\205\264/20230404 \347\273\203\344\271\240.md" +++ /dev/null @@ -1,146 +0,0 @@ -## 冒泡法 - -```java -int []arr={3,5,2,15,38,26,27}; -System.out.println("排序前"); -for (int n:arr){ - System.out.print(n+" "); -} -for (int i = 0; i < arr.length; i++) { - for (int j = 0; j < arr.length-1; j++) { - if (arr[j]>arr[j+1]) { - int temp=arr[j]; - arr[j]=arr[j+1]; - arr[j+1]=temp; - } - } -} -System.out.println(); -System.out.println("排序后"); -for (int n:arr){ - System.out.print(n+" "); -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java -int arr[]={5,2,3,4,1}; -int min=arr[0]; -int index=0; -for (int i = 0; i < arr.length; i++) { - if (min>arr[i]){ - index=i; - } -} -System.out.println("这个数组的最小值是"+arr[index]); -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -int arr[]={5,2,3,4,1}; -int count=0; -System.out.println("索引值与对应元素都是奇数的数有:"); -for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.print(arr[i]+" "); - count++; - } -} -if(count==0){ - System.out.println("此条件没有符合的数字"); -} -``` - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -Scanner sc = new Scanner(System.in); -Random r =new Random(); -int arr[]=new int[5]; -int count=0; -for (int i = 0; i < 5; i++) { - System.out.println("请输入第"+(i+1)+"个数字,要在1-60之间"); - arr[i]= sc.nextInt(); -} -int num=r.nextInt(9)+2; -System.out.print("是倍数的有:"); -for (int j = 0; j < arr.length; j++) { - if (arr[j]%num!=0){ - System.out.print(arr[j]+" "); - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -int arr[]={9,1,3,4,54,56,23,22,20,43,45,78}; -int count=0; -System.out.println("能被6整除的数有:"); -for (int i = 0; i < arr.length; i++) { - if(arr[i]%2==0){ - System.out.print(arr[i]+" "); - count++; - } -} -if (count==0){ - System.out.println("没有符合这个条件的数字"); -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -Random r=new Random(); -int arr[]=new int[20]; -int count=0; -Scanner sc=new Scanner(System.in); -System.out.println("请输入指定数字,范围在20-40之间"); -int n= sc.nextInt(); -for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(21) + 20; - if (n == arr[i]) { - count++; - } -} -if(count==0){ - System.out.println("没有出现指定数字"); -}else{ - System.out.println("出现数字"+n+"出现了"+count+"次"); -} -``` - - - - - diff --git "a/16 \351\230\231\350\213\217\346\226\207/20230305\346\225\260\345\200\274\344\275\234\344\270\232.md" "b/16 \351\230\231\350\213\217\346\226\207/20230305\346\225\260\345\200\274\344\275\234\344\270\232.md" deleted file mode 100644 index f9376d66829a909b9ee66fd3cb856f8ac73c1f9d..0000000000000000000000000000000000000000 --- "a/16 \351\230\231\350\213\217\346\226\207/20230305\346\225\260\345\200\274\344\275\234\344\270\232.md" +++ /dev/null @@ -1,135 +0,0 @@ -# 作业 - -```java -public class array01 { -// **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - public static void main(String[] args) { -// 定义一个数组 - int[] array =new int[]{11,22,33,44,55}; -// 定义一个变量，记录最小值 - int min = array[0];[] -// 遍历数组 - for (int i=1;i< array.length;i++){ - if (min>array[i]){ - min=array[i]; - } - } - System.out.println("最小值是:"+min); - } -} - -``` - -```java -import java.util.Scanner; - -public class array02 { -// 求出数组中索引与索引对应的元素都是奇数的元素 - public static void main(String[] args) { - Scanner cs = new Scanner(System.in); - int arr[] =new int[5]; - for (int i=0;i<5;i++){ - System.out.println("请输入一个值："); - arr[i] = cs.nextInt(); - } - int count =0; - for (int j=0;j<5;j++){ - if (j%2!=0&&arr[j]%2==1){ - System.out.println("索引是："+(j)+"数值是："+arr[j]); - count++; - } - } - if (count==0){ - System.out.println("没有符合条件的数！"); - } - } -} - -``` - -```java -import java.util.Random; -//**3.按要求在main方法中完成以下功能：** -// -// ​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// -// ​ b. 生成2-10（范围包含2和10）之间的随机数num -// -// ​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// -//// ​ **PS：输入的数组元素范围包括1和60，不需要代码判断** -public class D1 { - public static void main(String[] args) { - int[] arr=new int[5]; - Random ran=new Random(); - int num=ran.nextInt(9)+2; - for (int i = 0; i < arr.length; i++) { - arr[i]=ran.nextInt(61)+1; - System.out.println(arr[i]); - } - System.out.println("随机的数是"+num); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0) { - System.out.print(arr[i]+"\t"); - } - } - System.out.println("不是num的倍数"); - } -} - -``` - -```java -public class D2 { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - public static void main(String[] args) { - int[] arr={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有"); - for (int i = 0; i < arr.length; i++) { - if (arr[i] % 6 == 0) { - System.out.print(arr[i]+" "); - } - } - } -} - -``` - -```java -import java.util.Random; -import java.util.Scanner; -//5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次数，指定元素为键盘录入范围为20-40之间。 -public class D3 { - public static void main(String[] args) { - System.out.println("输入想要的数"); - Random ran=new Random(); - Scanner sc=new Scanner(System.in); - int num=sc.nextInt(); - int[] arr=new int[20]; - int count=0; - - while (true) { - if (num<20 || num>40) { - System.out.println("数值有误,重新输入"); - num=sc.nextInt(); - }else { - break; - } - } - - System.out.print("随机数组为:"); - for (int i = 0; i < arr.length; i++) { - arr[i]=ran.nextInt(21)+20; - if (num == arr[i]) { - count++; - } - System.out.print(arr[i]+" "); - } - - System.out.println(" "); - System.out.println(num+"在数组中出现了"+count+"次"); - } -} - -``` - diff --git "a/16 \351\230\231\350\213\217\346\226\207/20230406\346\226\271\346\263\225\344\275\234\344\270\232.md" "b/16 \351\230\231\350\213\217\346\226\207/20230406\346\226\271\346\263\225\344\275\234\344\270\232.md" deleted file mode 100644 index 8c9645dce8e2d2fc186a5a2859a5b58f114692ff..0000000000000000000000000000000000000000 --- "a/16 \351\230\231\350\213\217\346\226\207/20230406\346\226\271\346\263\225\344\275\234\344\270\232.md" +++ /dev/null @@ -1,96 +0,0 @@ -# 作业 - -```java -public class Method { - // 1,定义一个方法，接收一个数组，返回该数组的最大值和最小值；在主方法中打印最大，最小值 - public static void main(String[] args) { - int[] meThod ={16,25,43,65,75,32}; - int max =gteMaxs(meThod); - System.out.println("最大值是" + max); - int min =getMins(meThod); - System.out.println("最小值是" + min); - } - - private static int getMins(int[] meThod) { - int min =meThod[0]; - for (int i : meThod){ - if (imax){ - max=i; - } - } - return max; - } -} - -``` - -```java -import java.util.Scanner; - -public class Method02 { - // 2,定义一个方法，接收长和宽，返回一个矩形的面积，在主方法中，打印这个面积 - public static void main(String[] args) { - int S = area(); - System.out.println("S = " + S); - } - - private static int area() { - Scanner cs =new Scanner(System.in); - int length =16; - int width =30; - int S =length*width; - return S; - } -} - -``` - -```java -import java.util.Scanner; - -public class Method03 { - // 3，利用方法重载，定义多个同名方法，通过接收一个不同类型的参数， - // 方法体里用扫描器接收一个对应类型的值，最后将该输入的值返回，在主方法中，输出该值。 - public static void main(String[] args) { - Scanner cs = new Scanner(System.in); - System.out.println("现有一个计算长方形面积的方法"); - System.out.println("请输入长方形的长"); - double a = cs.nextDouble(); - System.out.println("请输入长方形的宽"); - double b = cs.nextDouble(); - System.out.println("长方形的面积是：" + num(a, b)); - } - public static int num(int a, int b) { - int length = a * b; - return length; - } - - public static double num(double a, int b) { - double length = a * b; - return length; - } - - public static double num(int a, double b) { - double length = a * b; - return length; - } - - public static double num(double a, double b) { - double length = a * b; - return length; - } - -} - -``` - diff --git "a/17 \345\221\250\345\257\214/20230331Java\345\244\215\344\271\240\344\275\234\344\270\232.md" "b/17 \345\221\250\345\257\214/20230331Java\345\244\215\344\271\240\344\275\234\344\270\232.md" deleted file mode 100644 index 319df98ab70de305dd3e171bf6c2c9978f42db7a..0000000000000000000000000000000000000000 --- "a/17 \345\221\250\345\257\214/20230331Java\345\244\215\344\271\240\344\275\234\344\270\232.md" +++ /dev/null @@ -1,96 +0,0 @@ -# 作业 - -```java -import java.util.Scanner; - -public class D4 { - //1、判断一个字符数据是否是数字字符 - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字符进行判断："); - int a= sc.nextInt(); - if (0<=a & a<=9){ - System.out.println(a+"字符是数字字符"); - }else{ - System.out.println(a+"字符不是数字字符"); - } - } -} - - //2、判断一个字符数据是否是字母字符 -import java.util.Scanner; - -public class D6 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字母进行判断:"); - char a=sc.next().charAt(0); - if ('a'<=a & a<='z'){ - System.out.println(a+"字符是字母字符"); - }else{ - System.out.println(a+"字符不是字母字符"); - } - } -} - - //3、判断指定的年份是否为闰年，请使用键盘录入 -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { - Scanner cs =new Scanner(System.in); - System.out.println("请输入一个年份:"); - int a = cs.nextInt(); - if (a%4==0 && a/100!=0 || a%400==0){ - System.out.println(a+"年是闰年"); - }else{ - System.out.println(a+"年不是闰年"); - } - } -} - -//4、判断一个数字是否为水仙花数,请使用键盘录入 -import java.util.Scanner; - -public class D7 { - public static void main(String[] args) { - Scanner cs =new Scanner(System.in); - System.out.println("请输入一个数字:"); - int a = cs.nextInt(); - double ge=a%10; - double shi=a%100/10; - double bai=a/100; - double gee=ge*ge*ge; - double shii=shi*shi*shi; - double baii=bai*bai*bai; - if (gee+shii+baii==a){ - System.out.println(a+"是水仙花数"); - }else{ - System.out.println(a+"不是水仙花数"); - } - - - } -} - - //5、判断一个5位数字是否为回文数，使用键盘录入 -import java.util.Scanner; - -public class D8 { - public static void main(String[] args) { - Scanner cs = new Scanner(System.in); - System.out.println("请输入一个五位数："); - int a= cs.nextInt(); - int ge=a%10; - int shi=a%100/10; - int qian=a/1000%10; - int wan=a/10000; - if (ge==wan && shi==qian){ - System.out.println(a+"是回文数"); - }else { - System.out.println(a+"不是回文数"); - } - } -} -``` - diff --git "a/17 \345\221\250\345\257\214/20230405 java\344\275\234\344\270\232.md" "b/17 \345\221\250\345\257\214/20230405 java\344\275\234\344\270\232.md" deleted file mode 100644 index 5184f9826a4ceca12bd7849d981eef7918f4f685..0000000000000000000000000000000000000000 --- "a/17 \345\221\250\345\257\214/20230405 java\344\275\234\344\270\232.md" +++ /dev/null @@ -1,133 +0,0 @@ -## 作业 - -```java -// 第一题 -public class zy1 { -// **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** -// **操作步骤：** -// 1.定义5个元素数组 -// 2.可以使用初始化数组的两种方式之一为数组元素赋值 -// 3.遍历数组求数组中的最小值 - public static void main(String[] args) { - int[] num = {5,6,8,1,3}; - for (int i = 1; i < num.length; i++) { - if (num[i]=0|a<=9){ - System.out.println("这个不是数字字符"); - }else{ - System.out.println("这个是数字字符"); - } - } -} -``` - -```java -2、判断一个字符数据是否是字母字符 - -分析: - -1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -3、判断完成之后，打印判断的结果。 -import java.util.Scanner; - -public class s03 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - char a=sc.nextLine().charAt(0); - - if(a>='a'|a<='z' & a>='A'|a<='Z'){ - System.out.println("这个是字母字符"); - }else{ - System.out.println("这个不是字母字符"); - } - } - -} -``` - -```java -3、判断指定的年份是否为闰年，请使用键盘录入 - -分析: - -1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 -import java.util.Scanner; - -public class s04 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入年份"); - int a = sc.nextInt(); - if (a % 4 == 0 && a % 100 != 0 || a / 400 == 0) {//|| a/400=0){ - System.out.println("这个是闰年"); - } else { - System.out.println("这个不是闰年"); - } - } - } -``` - -```java -4、判断一个数字是否为水仙花数,请使用键盘录入 - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -分析: - -如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - - 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将3位数字的每一位上的数字拆分下来 - - b) 计算每位数字的3次幂之和 - - C) 用和值 和 原来的数字进行比较 - - D) 打印判断的比较结果即可 -import java.util.Scanner; - -public class s05 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个三位数"); - int x=sc.nextInt(); - //百位 - int a=x/100; - //十位 - int b=x/10%10; - //个位 - int c=x%10; - if (a*a*a+b*b*b+c*c*c==x){ - System.out.println(x+"这个数是水仙花数"); - }else{ - System.out.println(x+"这个不是水仙花数"); - } - - } -} -``` - -```java -5、判断一个5位数字是否为回文数，使用键盘录入 - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析: - - 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将5位数字的万、千、十、个位数拆分出来 - - b) 判断比较万位和个位 、 千位和十位是否相等 - - 3、判断完成之后，打印判断的结果。 -import java.util.Scanner; - -public class s06 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("输入一个五位数"); - int x=sc.nextInt(); - //个位 - int a=x%10; - //十位 - int b=x/10%10; - //百位 - int c=x/100%10; - //千位 - int d=x/1000%10; - //万位 - int e=x/10000; - if (a==e&b==d){ - System.out.println(x+"这个数是回文数"); - }else{ - System.out.println(x+"这个数不是回文数"); - } - } -} - -``` - diff --git "a/18 \345\276\220\346\260\270\346\267\263/20230404 java\344\275\234\344\270\232.md" "b/18 \345\276\220\346\260\270\346\267\263/20230404 java\344\275\234\344\270\232.md" deleted file mode 100644 index 5af49876475cd77e5125187b81a460fe1783fb24..0000000000000000000000000000000000000000 --- "a/18 \345\276\220\346\260\270\346\267\263/20230404 java\344\275\234\344\270\232.md" +++ /dev/null @@ -1,126 +0,0 @@ -```java -public class T1 { - public static void main(String[] args) { -//1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值 -//操作步骤： -// -//1.定义5个元素数组 -// -//2.可以使用初始化数组的两种方式之一为数组元素赋值 -// -//3.遍历数组求数组中的最小值 - int[] a = {1, 2, 3, 4, 5}; - int min = a[0]; - for (int i = 1; i < a.length; i++) { - if (a[i] < min) { - min = a[i]; - } - } - System.out.println(min); - } -} - -``` - -```java -{ - public static void main(String[] args) { -//1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值 -//操作步骤： -// -//1.定义5个元素数组 -// -//2.可以使用初始化数组的两种方式之一为数组元素赋值 -// -//3.遍历数组求数组中的最小值 - int[] a = {1, 2, 3, 4, 5}; - int min = a[0]; - for (int i = 1; i < a.length; i++) { - if (a[i] < min) { - min = a[i]; - } - } - System.out.println(min); - } -} -``` - -```java -import java.util.Random; -import java.util.Scanner; - -public class T3 { - public static void main(String[] args) { -// 3.按要求在main方法中完成以下功能： -// -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// -// b. 生成2-10（范围包含2和10）之间的随机数num -// -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - Scanner sc = new Scanner(System.in); - int[] arr=new int[5]; - - for (int i = 0; i <= arr.length-1; i++) { - System.out.println("请输入1-60之间的数作为数组元素,这是第"+(i+1)+"个"); - arr[i]=sc.nextInt(); - } - Random r= new Random(); - int num=r.nextInt(9)+2; - System.out.println("num = " + num); - for (int j=0;jx[i]){ - min=x[i]; - }else{ - - } - } - System.out.println(min); - } -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java - public static void main(String[] args) { - int[] sz={10,20,30,50,60,1}; - for (int i = 0; i < sz.length; i++) { - if (i%2!=0){ - System.out.println(sz[i]); - } - } - } -``` - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java - public static void main(String[] args) { - int [] arr = new int [5]; - Random ran = new Random(); - for(int i=0;i<5;i++){ - int shui = ran.nextInt(60)+1; - arr[i] = shui; - System.out.print(arr[i]+" "); - } - int shui = ran.nextInt(9)+2; - int num = shui; - System.out.println(); - System.out.println(num); - for(int i=0;i<5;i++){ - if(arr[i] %num!= 0){ - System.out.print(arr[i]+" "); - } - } - } -``` - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java - public static void main(String[] args) { - int[] arr={9,1,3,4,54,56,23,22,20,43,45,78}; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.println(arr[i]); - } - } - } -``` - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -public static void main(String[] args) { - int [] arr = new int[20]; - Random ran = new Random(); - for (int i=0;i=20 && shu <=40){ - int count = 0; - for (int i=0;i='0' && c<='9') { - System.out.println("是数字字符"); - }else{ - System.out.println("不是数字字符"); - } - } - } -} -~~~ - - - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -### 答案二 - -~~~ java -import java.util.Scanner; - -public class D6 { -// 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 -// 2、字符是否为字母字符： 数字字符的范围 a-z 或者 A-Z 之间都属于字母字符， -// 因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z -// 3、判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符："); - char c = sc.next().charAt(0); - - if((c>='a' && c<='z') || (c>='A' && c<='Z')){ - System.out.println("是字母字符"); - }else{ - System.out.println("不是字母字符"); - } - } - } -} -~~~ - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -### 答案三 - -~~~ java -import java.util.Scanner; - -public class D7 { - // 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份："); - int year = sc.nextInt(); - - if(year % 4 == 0 || year % 400 == 0 && year % 100 !=0){ - System.out.println(year+"是闰年"); - }else{ - System.out.println(year+"不是闰年"); - } - } - } -} -~~~ - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -### 答案四 - -~~~ java -import java.util.Scanner; - -public class D1 { - // 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - public static void main(String[] args) { - - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位整数"); - int number = sc.nextInt(); - - int ge = number % 100 % 10; - int shi = number / 10 % 10; - int bai = number / 100; - - if (ge * ge * ge + shi * shi * shi + bai * bai * bai == number) { - System.out.println(number + "是水仙花数"); - } else { - System.out.println(number + "不是水仙花数"); - } - } - - } -} -~~~ - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -### 答案五 - -~~~ java -import java.util.Scanner; - -public class D2 { - // 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321，23732，56665 - public static void main(String[] args) { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位整数："); - int number = sc.nextInt(); - - int ge = number%10; - int shi = number/10%10; - int bai = number/100%10; - int qian = number/1000%10; - int wan = number/10000%10; - - if(ge==wan && shi==qian){ - System.out.println(number+"是回文数"); - }else{ - System.out.println(number+"不是回文数"); - } - - } - } -} -~~~ - - - diff --git "a/20 \347\237\263\350\211\257\346\266\233/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" "b/20 \347\237\263\350\211\257\346\266\233/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" deleted file mode 100644 index d6d696c43745db77feb1d2762a094e2584353237..0000000000000000000000000000000000000000 --- "a/20 \347\237\263\350\211\257\346\266\233/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" +++ /dev/null @@ -1,202 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -~~~ java -import java.util.Scanner; - -public class D1 { - // 定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值 - - public static void main(String[] args) { - - //1.定义5个元素数组 - int[] arr = new int[5]; - Scanner sc = new Scanner(System.in); - - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入五个数字添加到数组："); - int num = sc.nextInt(); - arr[i]=num; - } - - //3.遍历数组求数组中的最小值 - int min = arr[0]; - for (int i = 1; i < arr.length; i++) { - if(min>arr[i]){ - min=arr[i]; - } - } - System.out.println("这个数组中最小值为："+min); - } -} -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -import java.util.Scanner; - -public class D2 { - //需求：求出数组中索引与索引对应的元素都是奇数的元素 - - public static void main(String[] args) { - - //1、定义数组 - int[] arr =new int[5]; - Scanner sc = new Scanner(System.in); - - //2、键盘录入数组的每个元素并添加到数组 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入数组里面的值："); - int num = sc.nextInt(); - arr[i]=num; - } - - //3、遍历数组,判断索引是否是奇数（索引 % 2 != 0）,判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - for (int i = 0; i < arr.length; i++) { - if(i % 2 !=0 && arr[i] % 2 !=0){ - System.out.println("索引为："+i+"\n"+"值为："+arr[i]); - } - } - } -} -~~~ - - - -**3.按要求main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - //PS：输入的数组元素范围包括1和60，不需要代码判断 - public static void main(String[] args) { - //1. 定义一个长度为5的int型数组arr - int[] arr = new int[5]; - Scanner sc = new Scanner(System.in); - - //2.提示用户输入5个1-60之间的数字作为数组元素 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入5个1-60之间的数字："); - int number = sc.nextInt(); - arr[i]=number; - } - - //3. 生成2-10（范围包含2和10）之间的随机数num - Random ran = new Random(); - int num = ran.nextInt(9)+2; - - //4. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % num !=0){ - System.out.println("数组中"+arr[i]+"不是"+num+"的倍数"); - } - } - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - // 有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - - //遍历数组找到能被6整除的元素 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % 6 == 0){ - System.out.println("数组中"+arr[i]+"能被6整除"); - } - } - } -} -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Arrays; -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { - //定义一个长度为20的数组，元素为20-40的随机数， - //要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Random ran = new Random(); - Scanner sc = new Scanner(System.in); - - //1.循环将随机生成的数添加到数组 - for (int i = 0; i < arr.length; i++) { - int num = ran.nextInt(21) + 20; - arr[i] = num; - } - - //打印数组 - System.out.println("随机生成的数组为"); - System.out.println(Arrays.toString(arr)); - - //2.键盘录入一个指定元素,并判断输入的值是否在20-40之间 - System.out.println("请输入一个20-40的数："); - int num1 = sc.nextInt(); - - while (true) { - if(num1<20 || num1>40){ - System.out.println("输入的数值不在20-40之间，请重新输入"); - num1=sc.nextInt(); - }else{ - break; - } - } - - //3.遍历数组判断指定元素在数组中出现的次**数，并打印 - int count = 0; - for (int i = 0; i < arr.length; i++) { - if (arr[i] == num1) { - count++; - } - } - System.out.println(num1+"在数组中出现了："+count+"次"); - } -} - -~~~ diff --git "a/20 \347\237\263\350\211\257\346\266\233/\346\226\271\346\263\225\350\257\276\347\250\213\347\273\203\344\271\240 \346\233\264\346\255\243.md" "b/20 \347\237\263\350\211\257\346\266\233/\346\226\271\346\263\225\350\257\276\347\250\213\347\273\203\344\271\240 \346\233\264\346\255\243.md" deleted file mode 100644 index 44fec6877ee5b7418d08afc23c89bcf8b4e0aa90..0000000000000000000000000000000000000000 --- "a/20 \347\237\263\350\211\257\346\266\233/\346\226\271\346\263\225\350\257\276\347\250\213\347\273\203\344\271\240 \346\233\264\346\255\243.md" +++ /dev/null @@ -1,101 +0,0 @@ -1,定义一个方法，接收一个数组，返回该数组的最大值和最小值；在主方法中打印最大，最小值 - -```java -public static int[] findMinMax(int[] arr) { - int min = arr[0]; - int max = arr[0]; - - for (int i = 1; i < arr.length; i++) { - if (arr[i] < min) { - min = arr[i]; - } - if (arr[i] > max) { - max = arr[i]; - } - } - - int[] result = {min, max}; - return result; -} -``` - -在主方法中，可以调用 `findMinMax` 方法，并打印结果： - -```java -public static void main(String[] args) { - int[] arr = {5, 2, 9, 1, 5, 6}; - int[] result = findMinMax(arr); - - System.out.println("最小值: " + result[0]); - System.out.println("最大值: " + result[1]); -} -``` - -2,定义一个方法，接收长和宽，返回一个矩形的面积，在主方法中，打印这个面积 - -```java -public static double calculateArea(double length, double width) { - double area = length * width; - return area; -} -``` - -在主方法中，可以调用 `calculateArea` 方法，并打印结果： - -```java -public static void main(String[] args) { - double length = 5.0; - double width = 3.0; - double area = calculateArea(length, width); - - System.out.println("矩形的面积为: " + area); -} -``` - -3，利用方法重载，定义多个同名方法，通过接收一个不同类型的参数，方法体里用扫描器接收一个对应类型的值，最后将该输入的值返回，在主方法中，输出该值。 - -```java -import java.util.Scanner; - -public class OverloadExample { - - public static int getValue(int input) { - Scanner scanner = new Scanner(System.in); - System.out.print("请输入一个整数: "); - input = scanner.nextInt(); - return input; - } - - public static double getValue(double input) { - Scanner scanner = new Scanner(System.in); - System.out.print("请输入一个小数: "); - input = scanner.nextDouble(); - return input; - } - - public static String getValue(String input) { - Scanner scanner = new Scanner(System.in); - System.out.print("请输入一个字符串: "); - input = scanner.nextLine(); - return input; - } - - public static void main(String[] args) { - int i = 0; - double d = 0.0; - String s = ""; - - i = getValue(i); - d = getValue(d); - s = getValue(s); - - System.out.println("输入的整数是: " + i); - System.out.println("输入的小数是: " + d); - System.out.println("输入的字符串是: " + s); - } -} -``` - -在主方法中，分别调用三个同名方法，并将返回值赋给相应的变量，最后输出这些变量的值。 - - diff --git "a/21 \345\215\242\344\272\250\350\200\200/01 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/21 \345\215\242\344\272\250\350\200\200/01 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" deleted file mode 100644 index e16631cf61d32a02d0cab01395c24ed604c8f794..0000000000000000000000000000000000000000 --- "a/21 \345\215\242\344\272\250\350\200\200/01 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" +++ /dev/null @@ -1,156 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -```java -Scanner sc=new Scanner(System.in); - System.out.println("请输入字符"); - int num=sc.nextInt(); - if (num>0 && num<10) { - System.out.println("是数字"); - }else{ - System.out.println("不是数字"); -``` - - - - - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -```java - Scanner sc=new Scanner(System.in); - System.out.println("请输入字符"); - - int shu=sc.nextInt(); - if (shu >='a' && shu<='z' || shu>='A' && shu<='Z') { - System.out.println(shu+"是字母"+"对应的ASCII："+(char)shu); - }else{ - System.out.println("不是字母"); - } -``` - - - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java - Scanner sc=new Scanner(System.in); - System.out.println("请输入年份"); - int year=sc.nextInt(); - if (year / 4 == 0 && year / 400 == 0) { - System.out.println("闰年"); - - } - else{ - System.out.println("不是闰年"); - } - } -``` - - - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入要判断的水仙花数"); - int num= sc.nextInt(); - int ge =num%10; - int shi=num/10%10; - int bai=num/100; - int num2=ge*ge*ge+shi*shi*shi+bai*bai*bai; - if (num==num2){ - System.out.println("是"); - } else - System.out.println("不是"); - } -} -``` - - - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java - Scanner sc=new Scanner(System.in); - System.out.println("请输入数值"); - int num= sc.nextInt(); - - int value1=num/10000; - int value2=num%10; - - if (num >99999 || num<10000) { - System.out.println("长度有误"); - } - if (value1==value2){ - System.out.println("是回文数"); - }else { - System.out.println("不是回文数"); - } - } -``` - - - - - diff --git "a/21 \345\215\242\344\272\250\350\200\200/04 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" "b/21 \345\215\242\344\272\250\350\200\200/04 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" deleted file mode 100644 index d9b0d66ce75ac94c121f9e217323c8ee36d491d8..0000000000000000000000000000000000000000 --- "a/21 \345\215\242\344\272\250\350\200\200/04 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" +++ /dev/null @@ -1,136 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java - int[] arr={2,5,4,7,9,3}; - int min=arr[0]; - for (int i = 0; i < arr.length; i++) { - System.out.print(arr[i]+" "); - if (arr[i]40) { - System.out.println("数值有误,重新输入"); - num=sc.nextInt(); - }else { - break; - } - } - - System.out.print("随机数组为:"); - for (int i = 0; i < arr.length; i++) { - arr[i]=ran.nextInt(21)+20; - if (num == arr[i]) { - count++; - } - System.out.print(arr[i]+" "); - } - - System.out.println(" "); - System.out.println(num+"在数组中出现了"+count+"次"); -``` - - - - - diff --git "a/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230330Java\345\244\215\344\271\240\344\275\234\344\270\232.md" "b/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230330Java\345\244\215\344\271\240\344\275\234\344\270\232.md" deleted file mode 100644 index 319df98ab70de305dd3e171bf6c2c9978f42db7a..0000000000000000000000000000000000000000 --- "a/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230330Java\345\244\215\344\271\240\344\275\234\344\270\232.md" +++ /dev/null @@ -1,96 +0,0 @@ -# 作业 - -```java -import java.util.Scanner; - -public class D4 { - //1、判断一个字符数据是否是数字字符 - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字符进行判断："); - int a= sc.nextInt(); - if (0<=a & a<=9){ - System.out.println(a+"字符是数字字符"); - }else{ - System.out.println(a+"字符不是数字字符"); - } - } -} - - //2、判断一个字符数据是否是字母字符 -import java.util.Scanner; - -public class D6 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字母进行判断:"); - char a=sc.next().charAt(0); - if ('a'<=a & a<='z'){ - System.out.println(a+"字符是字母字符"); - }else{ - System.out.println(a+"字符不是字母字符"); - } - } -} - - //3、判断指定的年份是否为闰年，请使用键盘录入 -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { - Scanner cs =new Scanner(System.in); - System.out.println("请输入一个年份:"); - int a = cs.nextInt(); - if (a%4==0 && a/100!=0 || a%400==0){ - System.out.println(a+"年是闰年"); - }else{ - System.out.println(a+"年不是闰年"); - } - } -} - -//4、判断一个数字是否为水仙花数,请使用键盘录入 -import java.util.Scanner; - -public class D7 { - public static void main(String[] args) { - Scanner cs =new Scanner(System.in); - System.out.println("请输入一个数字:"); - int a = cs.nextInt(); - double ge=a%10; - double shi=a%100/10; - double bai=a/100; - double gee=ge*ge*ge; - double shii=shi*shi*shi; - double baii=bai*bai*bai; - if (gee+shii+baii==a){ - System.out.println(a+"是水仙花数"); - }else{ - System.out.println(a+"不是水仙花数"); - } - - - } -} - - //5、判断一个5位数字是否为回文数，使用键盘录入 -import java.util.Scanner; - -public class D8 { - public static void main(String[] args) { - Scanner cs = new Scanner(System.in); - System.out.println("请输入一个五位数："); - int a= cs.nextInt(); - int ge=a%10; - int shi=a%100/10; - int qian=a/1000%10; - int wan=a/10000; - if (ge==wan && shi==qian){ - System.out.println(a+"是回文数"); - }else { - System.out.println(a+"不是回文数"); - } - } -} -``` - diff --git "a/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230406 \346\225\260\347\273\204\344\275\234\344\270\232.md" "b/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230406 \346\225\260\347\273\204\344\275\234\344\270\232.md" deleted file mode 100644 index e9d0136c293a9ad7ea1081cd86cff647d4c0658d..0000000000000000000000000000000000000000 --- "a/22 \350\202\226\351\222\237\345\207\257\351\237\251/20230406 \346\225\260\347\273\204\344\275\234\344\270\232.md" +++ /dev/null @@ -1,156 +0,0 @@ -# 作业 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - - 1.定义5个元素数组 - - 2.可以使用初始化数组的两种方式之一为数组元素赋值 - - 3.遍历数组求数组中的最小值 - -```java -import java.util.Scanner; - -public class D1 { - public static void main(String[] args) { - int[] num =new int[5]; - for (int i = 0; i < num.length; i++) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入"+(i+1)); - num[i]=sc.nextInt(); - } - int min = num[0]; - for (int i = 0; i num[i]){ - min=num[i]; - } - } - System.out.println("最小的是"+min); - } - } -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - - 1、遍历数组 - - 2、判断索引是否是奇数（索引 % 2 != 0） - - 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - - 4、满足条件输出结果 - -```java -public class D2 { - public static void main(String[] args) { -// 1、遍历数组 -// -// 2、判断索引是否是奇数（索引 % 2 != 0） -// -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// -// 4、满足条件输出结果 - int[] arr ={12,11,17,4,6}; - for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.println("基数是"+arr[i]); - - } - } - - } -} -``` - -**3.按要求在main方法中完成以下功能：** - - a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - - b. 生成2-10（范围包含2和10）之间的随机数num - - c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - - **PS：输入的数组元素范围包括1和60，不需要代码判断** - -``` -import java.util.Random; -import java.util.Scanner; - -public class D3 { - public static void main(String[] args) { - int[] arr = new int[5]; - for (int i = 0; i < arr.length; i++) { - Scanner sc= new Scanner(System.in); - System.out.println("请输入1-60的数"+(i+1)+":"); - arr[i]=sc.nextInt(); - } - Random ran=new Random(); - int num =ran.nextInt(8)+2; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0){ - System.out.println(arr[i]+"不是"+num+"的倍数"); - } - } - -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// -// b. 生成2-10（范围包含2和10）之间的随机数num -// -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -public class D4 { - public static void main(String[] args) { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - int[] arr ={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.print(+arr[i]+" "); - - } - - } - } -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { -// **5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Scanner sc= new Scanner(System.in); - System.out.println("输入20-40的数:"); - int a=sc.nextInt(); - Random ran =new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = ran.nextInt(21)+20; - } - int count=0; - for (int i = 0; i =0 & a<=9){ - System.out.println("是数字字符"); - }else { - System.out.println("no！"); - } - - } -} -``` - -## 2.判断一个字符数据是否是字母字符 - -**分析：** - - 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - - 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - - 3、判断完成之后，打印判断的结果。 - -```java -package com.school.work; - -import java.util.Scanner; - -public class test05 { - public static void main(String[] args) { -// 判断一个字符数据是否是字母字符 -// 分析： -// 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 -// 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符， -// 因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z -// 3、判断完成之后，打印判断的结果。 - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字符,看看是不是字母字符捏:"); - char zifu =sc.nextLine().charAt(0); - if(zifu>='a'& zifu<='z' |zifu>='A'&zifu<='Z' ){ - System.out.println("是"); - }else { - System.out.println("no！"); - } - } -} -``` - -## 3.判断指定的年份是否为闰年，请使用键盘录入 - -**分析：** - - 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - - 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -package com.school.work; - -import java.util.Scanner; - -public class test06 { - public static void main(String[] args) { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 分析： -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - System.out.println("请输入年份："); - if (a%4==0 && a%100!=0 || a%100==0){ - System.out.println(a+"是闰年"); - }else { - System.out.println(a+"不是闰年"); - - } - } -} -``` - -## 4. 判断一个数字是否为水仙花数,请使用键盘录入 - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - - 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - - 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将3位数字的每一位上的数字拆分下来 - - b) 计算每位数字的3次幂之和 - - C) 用和值 和 原来的数字进行比较 - - D) 打印判断的比较结果即可 - -```java -package com.school.work; - -import java.util.Scanner; - -public class test07 { - public static void main(String[] args) { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， -// 分析： -//如：153 ---> 1×1×1 + 5×5×5 + 3×3×3 = 153; 就是水仙花数 -//1、首先需要提供一个需要判断的3位数字，因此需要一个数值 -//2、判断的过程 -//a) 将3位数字的每一位上的数字拆分下来 -//b) 计算每位数字的3次幂之和 -//C) 用和值 和 原来的数字进行比较 -//D) 打印判断的比较结果即可 - System.out.println("请输入数字："); - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - int ge=a%10; - int shi=a/10%10; - int bai=a/100; - if (ge*ge*ge+shi*shi*shi+bai*bai*bai==a){ - System.out.println("水仙花"); - }else { - System.out.println("不是水仙花"); - } - - } -} -``` - -## 5.判断一个5位数字是否为回文数，使用键盘录入 - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 - -**分析：** - - 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将5位数字的万、千、十、个位数拆分出来 - - b) 判断比较万位和个位 、 千位和十位是否相等 - - 3、判断完成之后，打印判断的结果。 - -```java -package com.school.work; - -import java.util.Scanner; - -public class test08 { - public static void main(String[] args) { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 -// 分析： -//1、首先需要提供一个需要判断的5位数字，因此需要一个数值 -//2、判断的过程 -//a) 将5位数字的万、千、十、个位数拆分出来 -//b) 判断比较万位和个位 、 千位和十位是否相等 -//3、判断完成之后，打印判断的结果。 - System.out.println("请输入五位数字："); - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - int a1=a%10; - int a2=a/10%10; - int a3=a/100%10; - int a4=a/1000%10; - int a5=a/10000; - if (a1==a5 && a2==a4){ - System.out.println("是回文数"); - }else { - System.out.println("菜！"); - } - } -} -``` - diff --git "a/29 \350\267\257\347\216\262/20230404 \344\272\224\344\270\252\345\260\217\351\242\230\347\273\203\344\271\240.md" "b/29 \350\267\257\347\216\262/20230404 \344\272\224\344\270\252\345\260\217\351\242\230\347\273\203\344\271\240.md" deleted file mode 100644 index bdc9e9473eeed536bab5b1fc5000d33e5fb48dfd..0000000000000000000000000000000000000000 --- "a/29 \350\267\257\347\216\262/20230404 \344\272\224\344\270\252\345\260\217\351\242\230\347\273\203\344\271\240.md" +++ /dev/null @@ -1,180 +0,0 @@ -# 作业 - - - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java -import java.util.Random; - -public class Work { - public static void main(String[] args) { - //**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - //1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - int[] a={8,2,6,4,5};//数组 - int b=a[0]; - for (int i = 0; i < a.length;i++) {//遍历数组 - int c=a[i]; - i = i + 1; - if (b >c) {//判断条件 - b=c; - } - } - System.out.println(b); - } -} -``` - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -public class Work2 { - public static void main(String[] args) { - //**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //**分析：** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - int[] one ={8,9,4,5,6,3,4,5,6,1,5,25,5};//数组 - for (int i = 0; i < one.length ; i++) {//遍历数组 - /* System.out.print(one[i]);//值 - System.out.println(i);//索引*/ - if (i% 2 != 0) {//判断索引是否是奇数 - if (one[i]% 2 != 0 ) {//判断索引对应的元素是否是奇数 - System.out.println(one[i]);//输出结果 - } - } - } - } -} -``` - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -import java.util.Random; -import java.util.Scanner; -public class Work3 { - public static void main(String[] args) { - //**3.按要求在main方法中完成以下功能：** - // - //​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - // - //​ b. 生成2-10（范围包含2和10）之间的随机数num - // - //​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - // - //​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - int[] arr = new int[5];//创建数组 - Random r =new Random();//创建随机数对象 - Scanner sc = new Scanner(System.in);//创建一个键盘输入对象 - int num = r.nextInt(9)+2;//定义num输出随机数值,数组元素范围 2-10（+2指的是从2开始，（9）指的是8个数，（9）+2则为8+2=10，以10结束) - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) {//循环5次 - System.out.println("请输入第"+(i+1)+"个数字，建议不要写相同的数字！"); - arr[i]=sc.nextInt();//在数组中输入数值 - } - System.out.println("生成的随机数为"+num);//在这里写显示随机数的代码，是因为防止输入者看到随机数后故意写相同的数字 - System.out.println("筛选出数组中不是num倍数的元素"); - for (int i = 0; i arr[i]){ - min=arr[i]; - } - } - System.out.println("数组中的最小值为："+min); - } -} -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -import java.util.Scanner; - -public class D2 { - //需求：求出数组中索引与索引对应的元素都是奇数的元素 - - public static void main(String[] args) { - - //1、定义数组 - int[] arr =new int[5]; - Scanner sc = new Scanner(System.in); - - //2、键盘录入数组的每个元素并添加到数组 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入数组里面的值："); - int num = sc.nextInt(); - arr[i]=num; - } - - //3、遍历数组,判断索引是否是奇数（索引 % 2 != 0）,判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - for (int i = 0; i < arr.length; i++) { - if(i % 2 !=0 && arr[i] % 2 !=0){ - System.out.println("索引为："+i+"\n"+"值为："+arr[i]); - } - } - } -} -~~~ - - - -**3.按要求main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - //PS：输入的数组元素范围包括1和60，不需要代码判断 - public static void main(String[] args) { - //1. 定义一个长度为5的int型数组arr - int[] arr = new int[5]; - Scanner sc = new Scanner(System.in); - - //2.提示用户输入5个1-60之间的数字作为数组元素 - for (int i = 0; i < arr.length; i++) { - System.out.println("请输入5个1-60之间的数字："); - int number = sc.nextInt(); - arr[i]=number; - } - - //3. 生成2-10（范围包含2和10）之间的随机数num - Random ran = new Random(); - int num = ran.nextInt(9)+2; - - //4. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % num !=0){ - System.out.println("数组中"+arr[i]+"不是"+num+"的倍数"); - } - } - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - // 有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - - //遍历数组找到能被6整除的元素 - for (int i = 0; i < arr.length; i++) { - if(arr[i] % 6 == 0){ - System.out.println("数组中"+arr[i]+"能被6整除"); - } - } - } -} -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Arrays; -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { - //定义一个长度为20的数组，元素为20-40的随机数， - //要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Random ran = new Random(); - Scanner sc = new Scanner(System.in); - - //1.循环将随机生成的数添加到数组 - for (int i = 0; i < arr.length; i++) { - int num = ran.nextInt(21) + 20; - arr[i] = num; - } - - //打印数组 - System.out.println("随机生成的数组为"); - System.out.println(Arrays.toString(arr)); - - //2.键盘录入一个指定元素,并判断输入的值是否在20-40之间 - System.out.println("请输入一个20-40的数："); - int num1 = sc.nextInt(); - - while (true) { - if(num1<20 || num1>40){ - System.out.println("输入的数值不在20-40之间，请重新输入"); - num1=sc.nextInt(); - }else{ - break; - } - } - - //3.遍历数组判断指定元素在数组中出现的次**数，并打印 - int count = 0; - for (int i = 0; i < arr.length; i++) { - if (arr[i] == num1) { - count++; - } - } - System.out.println(num1+"在数组中出现了："+count+"次"); - } -} \ No newline at end of file diff --git "a/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt" "b/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt" deleted file mode 100644 index 874d7aeae31eccac7392c9b610ffb92fb383fa2e..0000000000000000000000000000000000000000 --- "a/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt" +++ /dev/null @@ -1,330 +0,0 @@ -## 笔记 - -1.为什么要进行类型转换？ - -l**存在不同类型的变量赋值给其他类型的变量** - -2.自动类型转换是什么样的？ - -类型范围小的变量，可以直接赋值给类型范围大的变量。 - -## 表达式的自动类型转换是 - -1.表达式的自动类型转换是什么样的？ - -l**小范围的类型会自动转换成大范围的类型运算。** - -2.表达式的最终结果类型是由谁决定的？ - -l**最终类型由表达式中的最高类型决定。** - -3.表达式的有哪些类型转换是需要注意的？ - -byte， short ，char是直接转换成int类型参与运算的。 - -## 强制类型转换 - -l可以强行将类型范围大的变量、数据赋值给类型范围小的变量。 - -数据类型 变量2 = (数据类型)变量1、数据 - -注意： - -l强制类型转换**可能**造成数据(丢失)溢出； - -浮点型强转成整型，直接丢掉小数部分，保留整数部分返回 - -# 作业 - -## one - -## 1.题目1(训练) - -身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： - -儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 - -女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 - -现有父亲身高177 CM,母亲身高165 CM。求子女身高分别预计为多少？ - -``` -package com.school.work; - -public class test01 { - public static void main(String[] args) { -// 题目1(训练) -// 身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： -//儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 -// 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 -// 现有父亲身高177 CM,母亲身高165 CM。求子女身高分别预计为多少？ - 方法一： - double father=177.00; - double mother=165.00; - double son=(father+mother)*1.08/2; - double daughter=(father*0.923+mother)*2; - System.out.println("儿子的身高预计为："son); - System.out.println("女儿的身高预计为："daughter); - 方法二： - int f=177,m=165; - double boy=(m+f)*1.08/2,girl=(f*0.923+m)/2; - System.out.println("儿子的身高预计为："+boy); - System.out.println("女儿的身高预计为："+girl); - - } -} -``` - -## 2. 题目2（训练） - -红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？ - -``` -package com.school.work; - -public class test02 { - public static void main(String[] args) { -// 题目2（训练） -// 红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。 -// 绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。 -// 那么红茶和绿茶现在的钱一样多，请问对么 - int red=21; - int red1=red*2+3; - int green=24; - int green1=green*2; - System.out.println(red1 == green1); - - -} -``` - -## 3.题目3（综合） - -某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？ - -``` -package com.school.work; - -public class test03 { - public static void main(String[] args) { -// 题目3（综合） -// 某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元， -// 米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。 -// 那么这个小伙要点这三样东西，最少要花多少钱？ - int fish=24; - int peanut=8; - int rice=3; - int one=(fish+peanut+rice)*0.8; - System.out.println(one); - int fish1=16; - int two=fish1+peanut+rice; - System.out.println(two); - - -} -``` - -# 3.作业 - -## 1.判断一个字符数据是否是数字字符  - -**分析：** - -1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -3、判断完成之后，打印判断的结果。 - -``` -package com.school.work; - -import java.util.Scanner; - -public class test04 { - public static void main(String[] args) { -//判断一个字符数据是否是数字字符 -//分析： -//1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -//2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -//3、判断完成之后，打印判断的结果。 - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字符,看看是不是数字字符:"); - char a=sc.nextLine().charAt(0); - if(a>=0 & a<=9){ - System.out.println("是数字字符"); - }else { - System.out.println("no！"); - } - - } -} -``` - -## 2.判断一个字符数据是否是字母字符 - -**分析：** - -1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -3、判断完成之后，打印判断的结果。 - -``` -package com.school.work; - -import java.util.Scanner; - -public class test05 { - public static void main(String[] args) { -// 判断一个字符数据是否是字母字符 -// 分析： -// 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 -// 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符， -// 因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z -// 3、判断完成之后，打印判断的结果。 - Scanner sc=new Scanner(System.in); - System.out.println("请输入一个字符,看看是不是字母字符捏:"); - char zifu =sc.nextLine().charAt(0); - if(zifu>='a'& zifu<='z' |zifu>='A'&zifu<='Z' ){ - System.out.println("是"); - }else { - System.out.println("no！"); - } - } -} -``` - -## 3.判断指定的年份是否为闰年，请使用键盘录入 - -**分析：** - -1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -``` -package com.school.work; - -import java.util.Scanner; - -public class test06 { - public static void main(String[] args) { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 分析： -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - System.out.println("请输入年份："); - if (a%4==0 && a%100!=0 || a%100==0){ - System.out.println(a+"是闰年"); - }else { - System.out.println(a+"不是闰年"); - - } - } -} -``` - -## 4. 判断一个数字是否为水仙花数,请使用键盘录入 - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -2、判断的过程 - -a) 将3位数字的每一位上的数字拆分下来 - -b) 计算每位数字的3次幂之和 - -C) 用和值 和 原来的数字进行比较 - -D) 打印判断的比较结果即可 - -``` -package com.school.work; - -import java.util.Scanner; - -public class test07 { - public static void main(String[] args) { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， -// 分析： -//如：153 ---> 1×1×1 + 5×5×5 + 3×3×3 = 153; 就是水仙花数 -//1、首先需要提供一个需要判断的3位数字，因此需要一个数值 -//2、判断的过程 -//a) 将3位数字的每一位上的数字拆分下来 -//b) 计算每位数字的3次幂之和 -//C) 用和值 和 原来的数字进行比较 -//D) 打印判断的比较结果即可 - System.out.println("请输入数字："); - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - int ge=a%10; - int shi=a/10%10; - int bai=a/100; - if (ge*ge*ge+shi*shi*shi+bai*bai*bai==a){ - System.out.println("水仙花"); - }else { - System.out.println("不是水仙花"); - } - - } -} -``` - -## 5.判断一个5位数字是否为回文数，使用键盘录入 - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 - -**分析：** - -1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -2、判断的过程 - -a) 将5位数字的万、千、十、个位数拆分出来 - -b) 判断比较万位和个位 、 千位和十位是否相等 - -3、判断完成之后，打印判断的结果。 - -``` -package com.school.work; - -import java.util.Scanner; - -public class test08 { - public static void main(String[] args) { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 -// 分析： -//1、首先需要提供一个需要判断的5位数字，因此需要一个数值 -//2、判断的过程 -//a) 将5位数字的万、千、十、个位数拆分出来 -//b) 判断比较万位和个位 、 千位和十位是否相等 -//3、判断完成之后，打印判断的结果。 - System.out.println("请输入五位数字："); - Scanner sc=new Scanner(System.in); - int a=sc.nextInt(); - int a1=a%10; - int a2=a/10%10; - int a3=a/100%10; - int a4=a/1000%10; - int a5=a/10000; - if (a1==a5 && a2==a4){ - System.out.println("是回文数"); - }else { - System.out.println("菜！"); - } - } -} -``` \ No newline at end of file diff --git "a/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.txt" "b/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.txt" deleted file mode 100644 index 69925f337d11f6caaea34222e766ca8dc95093b4..0000000000000000000000000000000000000000 --- "a/37 \346\217\255\351\230\263\344\270\275/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.txt" +++ /dev/null @@ -1,175 +0,0 @@ -# 第二次作业 - - - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - - 1.定义5个元素数组 - - 2.可以使用初始化数组的两种方式之一为数组元素赋值 - - 3.遍历数组求数组中的最小值 - -```java -import java.util.Random; - -public class Work { - public static void main(String[] args) { - //**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - //1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - int[] a={8,2,6,4,5};//数组 - int b=a[0]; - for (int i = 0; i < a.length;i++) {//遍历数组 - int c=a[i]; - i = i + 1; - if (b >c) {//判断条件 - b=c; - } - } - System.out.println(b); - } -} -``` - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - - 1、遍历数组 - - 2、判断索引是否是奇数（索引 % 2 != 0） - - 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - - 4、满足条件输出结果 - -```java -public class Work2 { - public static void main(String[] args) { - //**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //**分析：** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - int[] one ={8,9,4,5,6,3,4,5,6,1,5,25,5};//数组 - for (int i = 0; i < one.length ; i++) {//遍历数组 - /* System.out.print(one[i]);//值 - System.out.println(i);//索引*/ - if (i% 2 != 0) {//判断索引是否是奇数 - if (one[i]% 2 != 0 ) {//判断索引对应的元素是否是奇数 - System.out.println(one[i]);//输出结果 - } - } - } - } -} -``` - - - - - -**3.按要求在main方法中完成以下功能：** - - a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - - b. 生成2-10（范围包含2和10）之间的随机数num - - c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - - **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -import java.util.Random; -import java.util.Scanner; -public class Work3 { - public static void main(String[] args) { - //**3.按要求在main方法中完成以下功能：** - // - // a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - // - // b. 生成2-10（范围包含2和10）之间的随机数num - // - // c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - // - // **PS：输入的数组元素范围包括1和60，不需要代码判断** - int[] arr = new int[5];//创建数组 - Random r =new Random();//创建随机数对象 - Scanner sc = new Scanner(System.in);//创建一个键盘输入对象 - int num = r.nextInt(9)+2;//定义num输出随机数值,数组元素范围 2-10（+2指的是从2开始，（9）指的是8个数，（9）+2则为8+2=10，以10结束) - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) {//循环5次 - System.out.println("请输入第"+(i+1)+"个数字，建议不要写相同的数字！"); - arr[i]=sc.nextInt();//在数组中输入数值 - } - System.out.println("生成的随机数为"+num);//在这里写显示随机数的代码，是因为防止输入者看到随机数后故意写相同的数字 - System.out.println("筛选出数组中不是num倍数的元素"); - for (int i = 0; i ='0' && a<='9'){ - System.out.println("是数字字符"); - }else{ - System.out.println("不是数字字符"); - } -} -``` - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -```java -public static void main(String[] args) { - char a = '1' ; - if (a>='a' && a<='z' || a>='A' && a<='Z'){ - System.out.println("是字母字符"); - }else{ - System.out.println("不是字母字符"); - } -} -``` - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -``` -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int date = scanner.nextInt(); - if ((date%4==0 && date%100!=0) || date%400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } -} -``` - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int a = scanner.nextInt(); - int a1 = ((a%10)*(a%10)*(a%10))+((a/10%10)*(a/10%10)*(a/10%10))+((a/100%10)*(a/100%10)*(a/100%10)); - String b = "" + a; - if (b.length()==3 && a1==a){ - System.out.println("是水仙花数"); - }else{ - System.out.println("不是水仙花数"); - } -} -``` - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int a = scanner.nextInt(); - String b = ""+a; - int a1 = a%10; - int a2 = a/10%10; - int a3 = a/1000%10; - int a4 = a/10000%10; - if (b.length()!=5) { - System.out.println("不是五位数"); - }else if(a1==a4 && a2==a3){ - System.out.println("是回文数"); - }else{ - System.out.println("不是回文数"); - } -} -``` - diff --git "a/40 \346\227\266\345\255\246\345\256\211/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" "b/40 \346\227\266\345\255\246\345\256\211/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" deleted file mode 100644 index 02f463d8da5a8ae13032c81e19052d444985116a..0000000000000000000000000000000000000000 --- "a/40 \346\227\266\345\255\246\345\256\211/20230405 \346\225\260\347\273\204\344\275\234\344\270\232.md" +++ /dev/null @@ -1,167 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -~~~ java -import java.util.Scanner; - -public class D1 { - public static void main(String[] args) { - int[] num =new int[5]; - for (int i = 0; i < num.length; i++) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入"+(i+1)); - num[i]=sc.nextInt(); - } - int min = num[0]; - for (int i = 0; i num[i]){ - min=num[i]; - } - } - System.out.println("最小的是"+min); - } - } - -~~~ - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -~~~ java -public class D2 { - public static void main(String[] args) { -// 1、遍历数组 -// -// 2、判断索引是否是奇数（索引 % 2 != 0） -// -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// -// 4、满足条件输出结果 - int[] arr ={12,11,17,4,6}; - for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.println("基数是"+arr[i]); - - } - } - - } -} - -~~~ - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - public static void main(String[] args) { - int[] arr = new int[5]; - for (int i = 0; i < arr.length; i++) { - Scanner sc= new Scanner(System.in); - System.out.println("请输入1-60的数"+(i+1)+":"); - arr[i]=sc.nextInt(); - } - Random ran=new Random(); - int num =ran.nextInt(8)+2; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0){ - System.out.println(arr[i]+"不是"+num+"的倍数"); - } - } - - } -} -~~~ - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -~~~ java -public class D4 { - public static void main(String[] args) { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - int[] arr ={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.print(+arr[i]+" "); - - } - - } - } -} - -~~~ - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -~~~ java -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { -// **5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Scanner sc= new Scanner(System.in); - System.out.println("输入20-40的数:"); - int a=sc.nextInt(); - Random ran =new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = ran.nextInt(21)+20; - } - int count=0; - for (int i = 0; i (z.length()-1)/2;i--){ - char one = z.charAt(i); - String str = String.valueOf(one); - l = l+str; - - - } - if (y.equals(l)){ - System.out.println(x + "这个数是一个回文数"); - } - } else if (z.length()%2==0) { - String y = z.substring(0,z.length()/2); - for(int i =z.length()-1;i>=z.length()/2;i--){ - char negation = z.charAt(i); - String str = String.valueOf(negation); - l = l+str; - } - if (y.equals(l)){ - System.out.println(x + "这个数是一个回文数"); - } - } - - - - } - - - // 第二题 - public static void narcissistic_number() { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个数字:"); - int x = sc.nextInt(); - - int sum = 0; - if (x>99 && x<=999){ - String z = String.valueOf(x); - - for (int i = 0; i='0' && c<='9') { - System.out.println("是数字字符"); - }else{ - System.out.println("不是数字字符"); - } - } - } - - // 第四题 - public static void Ascll() { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符："); - char c = sc.next().charAt(0); - - if((c>='a' && c<='z') || (c>='A' && c<='Z')){ - System.out.println("是字母字符"); - }else{ - System.out.println("不是字母字符"); - } - } - } - - - // 第五题 - public static void year() { - while (true) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份："); - int year = sc.nextInt(); - - if(year % 4 == 0 || year % 400 == 0 && year % 100 !=0){ - System.out.println(year+"是闰年"); - }else{ - System.out.println(year+"不是闰年"); - } - } - } -} -``` - diff --git "a/42 \346\226\271\345\242\236\345\205\264/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" "b/42 \346\226\271\345\242\236\345\205\264/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" deleted file mode 100644 index ad57aa682861750dbe09a83b47289fab2661a774..0000000000000000000000000000000000000000 --- "a/42 \346\226\271\345\242\236\345\205\264/\347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" +++ /dev/null @@ -1,95 +0,0 @@ -```java -package PACKAGE_NAME.src.k; - -import sun.security.util.Length; - -import java.awt.*; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Random; -import java.util.Scanner; - -public class j { - public static void main(String[] args) { - // 第一题 - - -// Random ran = new Random(); -// ArrayList list = new ArrayList(); -// for (int i = 0; i < 5; i++) { -// int num = ran.nextInt(10); -// list.add(num); -// } -// int max_num = list.get(0); -// for (int i = 0; i < 5; i++) { -// if (list.get(i)>max_num){ -// max_num = list.get(i); -// } -// -// } -// System.out.println("数组"+list+"最大值是"+max_num); - - - // 第二题 -// Random new_ran = new Random(); -// ArrayList new_list = new ArrayList(); -// for (int i = 0; i < 20; i++) { -// int num = new_ran.nextInt(20); -// new_list.add(num); -// if (i%2!=0 && new_list.get(i)%2!=0){ -// System.out.println("索引为"+i+"的"+"值"+"这个数为奇数"+",值为"+new_list.get(i)); -// } -// } -// System.out.println(new_list); - - - // 第三题 -// int[] arr = new int[5]; -// for (int i = 0; i < arr.length; i++) { -// Scanner sc = new Scanner(System.in); -// System.out.println("请输入1-60的数" + (i + 1) + ":"); -// arr[i] = sc.nextInt(); -// } -// Random ran = new Random(); -// int num = ran.nextInt(8) + 2; -// for (int i = 0; i < arr.length; i++) { -// if (arr[i] % num != 0) { -// System.out.println(arr[i] + "不是" + num + "的倍数"); -// } -// } - - - // 第四题 -// int[] arr = {9, 1, 3, 4, 54, 56, 23, 22, 20, 43, 45, 78}; -// System.out.print("能被6整除的元素有："); -// for (int i = 0; i < arr.length; i++) { -// if (arr[i] % 6 == 0) { -// System.out.print(+arr[i] + " "); -// } -// } - - - // 第五题 -// int[] arr = new int[20]; -// Scanner sc= new Scanner(System.in); -// System.out.println("输入20-40的数:"); -// int a=sc.nextInt(); -// Random ran =new Random(); -// for (int i = 0; i < arr.length; i++) { -// arr[i] = ran.nextInt(21)+20; -// } -// int count=0; -// for (int i = 0; i arr[i]){ - min=arr[i]; - } - } - System.out.println("最小值； "+min); -// **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -//1、遍历数组 -//2、判断索引是否是奇数（索引 % 2 != 0） -//3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -//4、满足条件输出结果 - int[] arre={12,98,99,54,31,2}; -// **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -// 1、遍历数组 -// 2、判断索引是否是奇数（索引 % 2 != 0） -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// 4、满足条件输出结果 - arra(arre); -//**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - aba(); -//**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - num(); - } - public static void arra(int[] arr){ - - for (int i = 0; i < arr.length; i++) { - if (arr[i]%2!=0 && i%2 !=0){ - System.out.println("奇数有： "+arr[i]); - }; - } - } - public static void aba(){ - Scanner sc=new Scanner(System.in); - int a[]=new int[5]; - System.out.println("请输入5个1-60之间的数字作为数组元素"); - - for (int i=0;iorder2) { - System.out.println("方案一比较便宜,花费"+order1+"元"); - }else if(order1==order2){ - System.out.println("方案二和方案二是一个价格,花费"+order1+"元"); - }else{ - System.out.println("方案二比较便宜,花费"+order2+"元"); - } - } -} -``` - -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - - 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - - 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - - 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} -``` - -**2、判断一个字符数据是否是字母字符** - -**分析：** - - 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - - 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - - 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入a-z或者A-Z的其中一个字母"); - char e=num.next().charAt(0); - if(e>='a' & e<='z'){ - System.out.println("这个字符是字母字符"); - }else{ - System.out.println("这个字符不是字母字符"); - } - } -} -``` - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - - 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - - 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入年份"); - int year=num.nextInt(); - if (year%4==0 & year%100!=0 | year/400==0){ - System.out.println("这个年份是闰年"); - }else{ - System.out.println("这个年份不是闰年"); - } - } -} -``` - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - - 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - - 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将3位数字的每一位上的数字拆分下来 - - b) 计算每位数字的3次幂之和 - - C) 用和值 和 原来的数字进行比较 - - D) 打印判断的比较结果即可 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入一个三位整数"); - int x= num.nextInt(); - int a=x%10; - int b=x/10%10; - int c=x/100; - if(a*a*a+b*b*b+c*c*c==x){ - System.out.println("这个数是水仙花数"); - }else{ - System.out.println("这个数不是水仙花数"); - } - } -} -``` - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 - -**分析：** - - 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - - 2、判断的过程 - - a) 将5位数字的万、千、十、个位数拆分出来 - - b) 判断比较万位和个位 、 千位和十位是否相等 - - 3、判断完成之后，打印判断的结果。 - -```java -public class Class02 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入一个五位整数"); - int y= num.nextInt(); - int a=y%10; - int b=y/10%10; - int c=y/100%10; - int d=y/1000%10; - int e=y/10000; - if (a==e & b==d){ - System.out.println("这个数是回文数"); - }else{ - System.out.println("这个数不是回文数"); - } - } -} -``` \ No newline at end of file diff --git "a/47 \346\250\212\345\260\217\351\203\255/20230404 Java\351\235\242\345\257\271\345\257\271\350\261\241\345\206\222\346\263\241\346\263\225.md" "b/47 \346\250\212\345\260\217\351\203\255/20230404 Java\351\235\242\345\257\271\345\257\271\350\261\241\345\206\222\346\263\241\346\263\225.md" deleted file mode 100644 index 200145476ae8a9356fce842ab47b966d622be0cc..0000000000000000000000000000000000000000 --- "a/47 \346\250\212\345\260\217\351\203\255/20230404 Java\351\235\242\345\257\271\345\257\271\350\261\241\345\206\222\346\263\241\346\263\225.md" +++ /dev/null @@ -1,141 +0,0 @@ -## 冒泡法 - -```java -int []arr={3,5,2,15,38,26,27}; -System.out.println("排序前"); -for (int n:arr){ - System.out.print(n+" "); -} -for (int i = 0; i < arr.length; i++) { - for (int j = 0; j < arr.length-1; j++) { - if (arr[j]>arr[j+1]) { - int temp=arr[j]; - arr[j]=arr[j+1]; - arr[j+1]=temp; - } - } -} -System.out.println(); -System.out.println("排序后"); -for (int n:arr){ - System.out.print(n+" "); -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - - 1.定义5个元素数组 - - 2.可以使用初始化数组的两种方式之一为数组元素赋值 - - 3.遍历数组求数组中的最小值 - -```java -int arr[]={5,2,3,4,1}; -int min=arr[0]; -int index=0; -for (int i = 0; i < arr.length; i++) { - if (min>arr[i]){ - index=i; - } -} -System.out.println("这个数组的最小值是"+arr[index]); -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - - 1、遍历数组 - - 2、判断索引是否是奇数（索引 % 2 != 0） - - 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - - 4、满足条件输出结果 - -```java -int arr[]={5,2,3,4,1}; -int count=0; -System.out.println("索引值与对应元素都是奇数的数有:"); -for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.print(arr[i]+" "); - count++; - } -} -if(count==0){ - System.out.println("此条件没有符合的数字"); -} -``` - -**3.按要求在main方法中完成以下功能：** - - a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - - b. 生成2-10（范围包含2和10）之间的随机数num - - c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - - **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -Scanner sc = new Scanner(System.in); -Random r =new Random(); -int arr[]=new int[5]; -int count=0; -for (int i = 0; i < 5; i++) { - System.out.println("请输入第"+(i+1)+"个数字,要在1-60之间"); - arr[i]= sc.nextInt(); -} -int num=r.nextInt(9)+2; -System.out.print("是倍数的有:"); -for (int j = 0; j < arr.length; j++) { - if (arr[j]%num!=0){ - System.out.print(arr[j]+" "); - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -int arr[]={9,1,3,4,54,56,23,22,20,43,45,78}; -int count=0; -System.out.println("能被6整除的数有:"); -for (int i = 0; i < arr.length; i++) { - if(arr[i]%2==0){ - System.out.print(arr[i]+" "); - count++; - } -} -if (count==0){ - System.out.println("没有符合这个条件的数字"); -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -Random r=new Random(); -int arr[]=new int[20]; -int count=0; -Scanner sc=new Scanner(System.in); -System.out.println("请输入指定数字,范围在20-40之间"); -int n= sc.nextInt(); -for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(21) + 20; - if (n == arr[i]) { - count++; - } -} -if(count==0){ - System.out.println("没有出现指定数字"); -}else{ - System.out.println("出现数字"+n+"出现了"+count+"次"); -} -``` \ No newline at end of file diff --git "a/48 \351\251\254\345\256\217\350\276\276/3\346\234\21028.md" "b/48 \351\251\254\345\256\217\350\276\276/3\346\234\21028.md" deleted file mode 100644 index 92772cf2b27ae84a2b0df6adea2f7db6ecbed8a9..0000000000000000000000000000000000000000 --- "a/48 \351\251\254\345\256\217\350\276\276/3\346\234\21028.md" +++ /dev/null @@ -1,106 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -import java.util.Scanner; -public class a7 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -import java.util.Scanner; -public class a7 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -import java.util.Scanner; -public class rname { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入年份"); - int n= sc.nextInt(); - if(n%4==0 && n%100!=0 || n%400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } - } -} - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×_1 + 5_×5×_5 + 3×_3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -import java.util.Scanner; -public class a6 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入3位数"); - int sz= sc.nextInt(); - int gw=sz%10; - int sw=sz/10%10; - int bw=sz/100; - if(sz==gw*gw*gw+sw*sw*sw+bw*bw*bw){ - System.out.println("你输入的是水仙花数"); - }else{ - System.out.println("你输入的不是水仙花数"); - } - } -} diff --git "a/48 \351\251\254\345\256\217\350\276\276/4\346\234\2104\345\217\267.md" "b/48 \351\251\254\345\256\217\350\276\276/4\346\234\2104\345\217\267.md" deleted file mode 100644 index e1ddd8f34a48591727c6cb48095d018c5f9ba27d..0000000000000000000000000000000000000000 --- "a/48 \351\251\254\345\256\217\350\276\276/4\346\234\2104\345\217\267.md" +++ /dev/null @@ -1,65 +0,0 @@ -# 冒泡 - -import java.util.Random; -public class mp { - public static void main(String[] args) { - Random random = new Random(); - int[] num = new int[10]; - for (int i = 0; i < num.length; i++) { - num[i] = random.nextInt(10); - } - System.out.println("排序前"); - for (int n : num) { - System.out.print(n + " "); - } - for (int i = 0; i < num.length; i++) { - for (int j = 0; j < num.length - 1; j++) { - if (num[j] > num[j + 1]) { - int temp = num[j]; - num[j] = num[j + 1]; - num[j + 1] = temp; - } - } - } - System.out.println(); - System.out.println("\n排序后"); - for (int n : num) { - System.out.print(n + " "); - } - } -} - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - - int[] num = new int[]{2, 5, 7, 3, 8}; - int min = -999; - for (int i = 0; i < num.length; i++) { - for (int j = 0; j < num.length - 1; j++) { - if (num[j] > num[j + 1]) { - min = num[j + 1]; - num[j + 1] = num[j]; - num[j] = min; - } - } - } - System.out.println("min = " + num[0]); - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -{ - int[] n={2,6,3,1,7,9,5,4}; - int count=0; - for (int j = 0; j < n.length - 1; j++) { - if (n[j]%2!=0 && j%2!=0){ - System.out.print(n[j]+" "); - count++; - } - } - if (count==0){ - System.out.println("此数组中没有符合此条件的数字"); - } - } diff --git "a/49 \346\235\216\350\210\222\346\261\266/20230328 java\345\244\215\344\271\240.md" "b/49 \346\235\216\350\210\222\346\261\266/20230328 java\345\244\215\344\271\240.md" deleted file mode 100644 index d9c34b3fe7c36cd89a64944d72078df77782d7f2..0000000000000000000000000000000000000000 --- "a/49 \346\235\216\350\210\222\346\261\266/20230328 java\345\244\215\344\271\240.md" +++ /dev/null @@ -1,187 +0,0 @@ -# 练习 - -## 第一题 - -```java -public class zy { -// 身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： -// -// 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 -// -// 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 -// -// 现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？ - public static void main(String[] args) { - double f = 177; - double m = 165; - double e = (f+m)*1.08/2; - double v = (f*0.923+m)/2; - System.out.println("预计儿子的身高为："+e); - System.out.println("预计女儿的身高为："+v); - } -} -``` - -## 第二题 - -```java -public class zy { -// 红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。 -// 绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。 -// 那么红茶和绿茶现在的钱一样多，请问对么？ - public static void main(String[] args) { - int hc = 21; - int lc = 24; - if(hc*2+3==lc*2){ - System.out.println("他们的钱一样多，对"); - }else{ - System.out.println("他们的钱不一样多，错"); - } - } -} -``` - -## 第三题 - -```java -public class zy { -// 某小伙想定一份外卖，商家的优惠方式如下： -// 鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。 -// 订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。 -// 那么这个小伙要点这三样东西，最少要花多少钱？ - public static void main(String[] args) { - int yxrs = 24; - int hsm = 8; - int mf = 3; - double a = (yxrs+hsm+mf)*0.8; - int b = (16+hsm+mf); - double zj = a < b ? a:b; - System.out.println("最少要花："+zj+"元"); - } -} -``` - -# 作业 - - - -### 第一题 - -```java -import java.util.Scanner; - -public class zy { -// **1、判断一个字符数据是否是数字字符 ** -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符， -// 因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -// -// 3、判断完成之后，打印判断的结果。 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符"); - int a = sc.nextInt(); - if(a>=0|a<=9){ - System.out.println(a+"这个字符为数字字符"); - }else { - System.out.println(a+"这个字符不是数字字符"); - } - } -} -``` - -### 第二题 - -```java -// 判断一个字符数据是否是字母字符 -``` - - - -### 第三题 - -```java -import java.util.Scanner; - -public class zy { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份"); - int a = sc.nextInt(); - if(a%400==0){ - System.out.println(a+"为闰年"); - }else { - if(a%100==0){ - System.out.println(a +"不为闰年"); - }else { - if(a%4==0){ - System.out.println(a+"为闰年"); - } else { - System.out.println(a+"不为闰年"); - } - } - } - - - - } -} -``` - -### 第四题 - -```java -import java.util.Scanner; - -public class zy { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等， -// 则为水仙花数， - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位数"); - int a = sc.nextInt(); - int bai = a/100; - int shi = a/10%10; - int ge = a%10; - if (bai*bai*bai+shi*shi*shi+ge*ge*ge==a){ - System.out.println(a+"这个数为水仙花数"); - }else{ - System.out.println(a+"这个数不为水仙花数"); - } - } -} -``` - -### 第五题 - -```java -import java.util.Scanner; - -public class zy { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。 -// 如：12321 23732 56665 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位数"); - int a = sc.nextInt(); - int ge = a%10000%1000%100%10; - int shi = a%10000%1000%100/10; - int qian = a%10000/1000; - int wan = a/10000; - if (ge==wan & shi==qian){ - System.out.println(a+"这个数为回文数"); - }else{ - System.out.println(a+"这个数不为回文数"); - } - } -} -``` - - diff --git "a/49 \346\235\216\350\210\222\346\261\266/20230404 Java\345\244\215\344\271\240\344\275\234\344\270\232.md" "b/49 \346\235\216\350\210\222\346\261\266/20230404 Java\345\244\215\344\271\240\344\275\234\344\270\232.md" deleted file mode 100644 index 2e4ac8cb40d8ee8d52e0594c0af201531a90a379..0000000000000000000000000000000000000000 --- "a/49 \346\235\216\350\210\222\346\261\266/20230404 Java\345\244\215\344\271\240\344\275\234\344\270\232.md" +++ /dev/null @@ -1,132 +0,0 @@ -# 作业 - -### 作业1 - -```java -public class zuoye { - // **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - // 1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - public static void main(String[] args) { - int [] num = {10,30,40,50,20}; - int min = num[0]; - for (int i = 1; i < num.length ; i++) { - if (min>num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+ min); - } -} - -``` - -### 作业2 - -```java -public class zuoye2 { - // **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - public static void main(String[] args) { - int [] num = {4,5,8,16,22,17}; - for (int i = 0; i < num.length; i++) { - if (i%2 != 0 && num[i]%2 != 0 ){ - System.out.println("索引:"+i+",元素："+ num[i]+"，满足条件"); - } - } - } -} - -``` - -### 作业3 - -```java - - -public class zuoye3 { -// **3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - public static void main(String[] args) { - int [] arr = new int[5]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) { - arr[i] = sc.nextInt(); - } - - Random r = new Random(); - int num = r.nextInt(9)+2; - - for (int a = 0; a < arr.length; a++) { - if (arr[a]%num != 0){ - System.out.println(arr[a]+"不是随机数的倍数"); - } - } - } -} - -``` - -### 作业4 - -```java -public class zuoye4 { - // 4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - // 要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int [] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6 == 0){ - System.out.print(" "+ arr[i]); - } - } - } -} - -``` - -### 作业5 - -```java - - -public class zuoye5 { - // 5.定义一个长度为20的数组，元素为20-40的随机数， - // 要求判断指定元素在数组中出现的次数， - // 指定元素为键盘录入范围为20-40之间。 - public static void main(String[] args) { - int [] num = new int[20]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入一个20-40的整数"); - int a = sc.nextInt(); - - Random r = new Random(); - - for (int i = 0; i < num.length; i++) { - num[i]= r.nextInt(21)+20; - } - - int b = 0; - for (int x = 0; x < num.length; x++) { - if (num[x] == a){ - b++; - } - } - - System.out.println("指定元素在随机数组次数为："+b+"次。"); - - } -} -``` diff --git "a/50 \345\274\240\350\265\267\347\221\236/20230328 \350\277\220\347\256\227\347\254\246\347\273\203\344\271\240\345\222\214\344\275\234\344\270\232.md" "b/50 \345\274\240\350\265\267\347\221\236/20230328 \350\277\220\347\256\227\347\254\246\347\273\203\344\271\240\345\222\214\344\275\234\344\270\232.md" deleted file mode 100644 index 873e3cb6ac7c35d47808c60a4ea709424e409013..0000000000000000000000000000000000000000 --- "a/50 \345\274\240\350\265\267\347\221\236/20230328 \350\277\220\347\256\227\347\254\246\347\273\203\344\271\240\345\222\214\344\275\234\344\270\232.md" +++ /dev/null @@ -1,209 +0,0 @@ -# 练习题 - -## 第一题 - -```java -public class sg{ -// 身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下： -// -// 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2 -// -// 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2 -// -// 现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？ - public static void main(String[] args) { - double a = 177; - double b = 165; - double c = (a+b)*1.08/2; - double d = (a*0.923+b)/2; - System.out.println("预计儿子的身高为："+c); - System.out.println("预计女儿的身高为："+d); - } -} -``` - -## 第二题 - -```java -public class hcfx{ -// 红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。 -// 绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。 -// 那么红茶和绿茶现在的钱一样多，请问对么？ - public static void main(String[] args) { - int h = 21; - int l = 24; - if(h*2+3==l*2){ - System.out.println("他们的钱一样多，对"); - }else{ - System.out.println("他们的钱不一样多，错"); - } - } -} -``` - -## 第三题 - -``` java -public class dc { -// 某小伙想定一份外卖，商家的优惠方式如下： -// 鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。 -// 订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。 -// 那么这个小伙要点这三样东西，最少要花多少钱？ - public static void main(String[] args) { - int yxrs = 24; - int hsm = 8; - int mf = 3; - double a = (yxrs+hsm+mf)*0.8; - int b = (16+hsm+mf); - double dc = a < b ? a:b; - System.out.println("最少要花："+dc+"元"); - } -} -``` - -# 0328作业： - - - -### 第一题 - -```java -import java.util.Scanner; - -public class szf{ -// **1、判断一个字符数据是否是数字字符 ** -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符， -// 因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -// -// 3、判断完成之后，打印判断的结果。 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个字符"); - int a = sc.nextInt(); - if(a>=0|a<=9){ - System.out.println(a+"这个字符为数字字符"); - }else { - System.out.println(a+"这个字符不是数字字符"); - } - } -} -``` - -### 第二题 - - - -``` java -import java.util.Scanner; -判断一个字符数据是否是字母字符** - -//**分析：** - -//​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -//​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -//​ 3、判断完成之后，打印判断的结果。 -public class Day01 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - char b= sc.nextLine().charAt(0); - char a= '1'; - if (b>='a' & a<='z' | b>='A' & a<='Z'){ - System.out.println(true); - }else { - System.out.println(false); - } - } -} -``` - - - -### 第三题 - -``` java -import java.util.Scanner; - -public class nf { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份"); - int a = sc.nextInt(); - if(a%400==0){ - System.out.println(a+"为闰年"); - }else { - if(a%100==0){ - System.out.println(a +"不为闰年"); - }else { - if(a%4==0){ - System.out.println(a+"为闰年"); - } else { - System.out.println(a+"不为闰年"); - } - } - } - - - - } -} -``` - -### 第四题 - -```java -import java.util.Scanner; - -public class sxh { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等， -// 则为水仙花数， - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位数"); - int a = sc.nextInt(); - int bai = a/100; - int shi = a/10%10; - int ge = a%10; - if (bai*bai*bai+shi*shi*shi+ge*ge*ge==a){ - System.out.println(a+"这个数为水仙花数"); - }else{ - System.out.println(a+"这个数不为水仙花数"); - } - } -} -``` - -### 第五题 - -``` java -import java.util.Scanner; - -public class hws { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。 -// 如：12321 23732 56665 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位数"); - int a = sc.nextInt(); - int ge = a%10000%1000%100%10; - int shi = a%10000%1000%100/10; - int qian = a%10000/1000; - int wan = a/10000; - if (ge==wan & shi==qian){ - System.out.println(a+"这个数为回文数"); - }else{ - System.out.println(a+"这个数不为回文数"); - } - } -} -``` - diff --git "a/50 \345\274\240\350\265\267\347\221\236/20230404 \347\273\203\344\271\240.md" "b/50 \345\274\240\350\265\267\347\221\236/20230404 \347\273\203\344\271\240.md" deleted file mode 100644 index d76dbecee900aee5c1e6b8fe0f065bec24adc22a..0000000000000000000000000000000000000000 --- "a/50 \345\274\240\350\265\267\347\221\236/20230404 \347\273\203\344\271\240.md" +++ /dev/null @@ -1,149 +0,0 @@ -## 冒泡排序 - -```java -int []arr={3,5,2,15,38,26,27}; -System.out.println("排序前"); -for (int n:arr){ - System.out.print(n+" "); -} -for (int i = 0; i < arr.length; i++) { - for (int j = 0; j < arr.length-1; j++) { - if (arr[j]>arr[j+1]) { - int temp=arr[j]; - arr[j]=arr[j+1]; - arr[j+1]=temp; - } - } -} -System.out.println(); -System.out.println("排序后"); -for (int n:arr){ - System.out.print(n+" "); -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java - -public static void main(String[] args) { - int [] num ={10,30,40,50,20}; - int min = num[0]; - for (int i=1;i< num.length;i++){ - if (min>num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+min); -} -} -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -int arr[]={5,2,3,4,1}; -int count=0; -System.out.println("索引值与对应元素都是奇数的数有:"); -for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.print(arr[i]+" "); - count++; - } -} -if(count==0){ - System.out.println("此条件没有符合的数字"); -} -``` - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -Scanner sc = new Scanner(System.in); -Random r =new Random(); -int arr[]=new int[5]; -int count=0; -for (int i = 0; i < 5; i++) { - System.out.println("请输入第"+(i+1)+"个数字,要在1-60之间"); - arr[i]= sc.nextInt(); -} -int num=r.nextInt(9)+2; -System.out.print("是倍数的有:"); -for (int j = 0; j < arr.length; j++) { - if (arr[j]%num!=0){ - System.out.print(arr[j]+" "); - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -int arr[]={9,1,3,4,54,56,23,22,20,43,45,78}; -int count=0; -System.out.println("能被6整除的数有:"); -for (int i = 0; i < arr.length; i++) { - if(arr[i]%2==0){ - System.out.print(arr[i]+" "); - count++; - } -} -if (count==0){ - System.out.println("没有符合这个条件的数字"); -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -Random r=new Random(); -int arr[]=new int[20]; -int count=0; -Scanner sc=new Scanner(System.in); -System.out.println("请输入指定数字,范围在20-40之间"); -int n= sc.nextInt(); -for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(21) + 20; - if (n == arr[i]) { - count++; - } -} -if(count==0){ - System.out.println("没有出现指定数字"); -}else{ - System.out.println("出现数字"+n+"出现了"+count+"次"); -} -``` - - - - - diff --git "a/51 \347\250\213\350\210\234/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/51 \347\250\213\350\210\234/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" deleted file mode 100644 index 204e8c815b3d3b6de27b7511c919bed6f51ae8b9..0000000000000000000000000000000000000000 --- "a/51 \347\250\213\350\210\234/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" +++ /dev/null @@ -1,238 +0,0 @@ -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -``` java -import sun.security.util.Length; - -import java.util.Scanner; -//1、判断一个字符数据是否是数字字符 -// 分析： -// 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 -// 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 -// 3、判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String a1 = sc.next(); - int num=a1.length(); - int pd=-1; - for(int i=0;i=2){ - System.out.println("超出请重新输入"); - return; - } - int pd=-1; - int asc = ziMu.charAt(0); - for(int i=97;i<=97+25;i++){ - if (asc==i){ - System.out.println("是字母字符"); - return; - }if(i==97+25){ - pd=-2; - } - } - if(pd==-2) { - for (int i = 65; i <= 65 + 25; i++) { - if (asc == i) { - pd=-1; - System.out.println("是字母字符"); - return; - } - if (i == 65 + 25) { - pd = -2; - } - } - } - if (pd==-2) { - System.out.println("不是字母字符"); - } - } -} -``` - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -//3、判断指定的年份是否为闰年，请使用键盘录入 -//分析： -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入年份"); - int nf = sc.nextInt(); - if (nf % 100!=0 & nf % 4==0 | nf % 400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } - } -} -``` - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -```java -import java.util.Scanner; - -//4、判断一个数字是否为水仙花数,请使用键盘录入 -//水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， -//分析： -// 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 -// 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 -// 2、判断的过程 -// a) 将3位数字的每一位上的数字拆分下来 -// b) 计算每位数字的3次幂之和 -// C) 用和值 和 原来的数字进行比较 -// D) 打印判断的比较结果即可 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入三位数"); - String shuZi = sc.next(); - if (shuZi.length()>3){ - System.out.println("请重新输入"); - return; - } - int q1=Integer.parseInt(shuZi); - int b = q1/100; - int s = q1/10%10; - int g = q1%10; - if(q1==(b*b*b)+(s*s*s)+(g*g*g)){ - System.out.println("是水仙花束"); - }else{ - System.out.println("不是水仙花束"); - } - } -} -``` - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; - -//5、判断一个5位数字是否为回文数，使用键盘录入 -//五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 -//分析： -// 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 -// 2、判断的过程 -// a) 将5位数字的万、千、十、个位数拆分出来 -// b) 判断比较万位和个位 、 千位和十位是否相等 -// 3、判断完成之后，打印判断的结果。 -public class zy { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入五位数"); - String shuZi = sc.next(); - if (shuZi.length()>5){ - System.out.println("请重新输入"); - return; - } - if (shuZi.charAt(0)==shuZi.charAt(4) & shuZi.charAt(1)==shuZi.charAt(3)){ - System.out.println("是回文数"+shuZi); - }else{ - System.out.println("不是回文数"+shuZi); - } - } -} -``` - diff --git "a/51 \347\250\213\350\210\234/20230405 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" "b/51 \347\250\213\350\210\234/20230405 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" deleted file mode 100644 index 76356ce39f337e034c0859fb2b944f4353c0dc7f..0000000000000000000000000000000000000000 --- "a/51 \347\250\213\350\210\234/20230405 \346\225\260\347\273\204\344\275\234\344\270\232 A.md" +++ /dev/null @@ -1,183 +0,0 @@ -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -**操作步骤：** - -​ 1.定义5个元素数组 - -​ 2.可以使用初始化数组的两种方式之一为数组元素赋值 - -​ 3.遍历数组求数组中的最小值 - -```java -import java.util.Random; - -//1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** -//**操作步骤：** -// 1.定义5个元素数组 -// 2.可以使用初始化数组的两种方式之一为数组元素赋值 -// 3.遍历数组求数组中的最小值 -public class zy { - public static void main(String[] args) { - int [] shu = new int [5]; - Random ran = new Random(); - for(int i=0 ; i<5 ; i++){ - int shui = ran.nextInt(101); - shu [i] = shui; - } - int min = shu[1]; - for(int i=0 ; i<5 ; i++){ - if(min>shu[i]){ - min=shu[i]; - } - } - System.out.println(min); - } -} -``` - - - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - -​ 1、遍历数组 - -​ 2、判断索引是否是奇数（索引 % 2 != 0） - -​ 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - -​ 4、满足条件输出结果 - -```java -import java.util.Random; - -//**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** -//**分析：** -// 1、遍历数组 -// 2、判断索引是否是奇数（索引 % 2 != 0） -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// 4、满足条件输出结果 -public class zy { - public static void main(String[] args) { - int [] shu = new int [10]; - Random ran = new Random(); - for(int i=0 ; i<10 ; i++){ - int shui = ran.nextInt(101); - shu [i] = shui; - System.out.print(shu[i]+" "); - } - System.out.println(); - for(int i=0 ; i<10 ; i++){ - if(shu[i]%2!=0){ - System.out.print(shu[i]+" "); - } - } - } -} -``` - - - - - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -import java.util.Random; - -//**3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** -public class zy { - public static void main(String[] args) { - int [] arr = new int [5]; - Random ran = new Random(); - for(int i=0;i<5;i++){ - int shui = ran.nextInt(60)+1; - arr[i] = shui; - System.out.print(arr[i]+" "); - } - int shui = ran.nextInt(9)+2; - int num = shui; - System.out.println(); - System.out.println(num); - for(int i=0;i<5;i++){ - if(arr[i] %num!= 0){ - System.out.print(arr[i]+" "); - } - } - } -} -``` - - - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java - -//**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** -public class zy { - public static void main(String[] args) { - int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - for(int i=0;i=20 && shu <=40){ - int count = 0; - for (int i=0;i 30) { - double priceDiscounts = price * 0.8; - System.out.println("你选择的套已满30元，所以可以享受8折优惠。优惠后的价格是"+priceDiscounts); - }else{ - System.out.println("你选择的套餐不满30元，所以无法享受8折优惠。你需要支付"+price+"元。"); - } - } else if (order == 2) { - System.out.println("你选择了套餐2，将单点鱼香肉丝"); - int fishDiscount = 16; - int price = (fishDiscount + peanut + rice); - System.out.println("你消费了"+price+"元。"); - } - } -} -``` - - - -**1、判断一个字符数据是否是数字字符 ** - -**分析：** - -​ 1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -​ 2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -​ 3、判断完成之后，打印判断的结果。 - -#### Answer: - -```java -import java.util.Scanner; - -public class d1 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String str = "请输入1-9中的其中一个数字" ; - System.out.println(str); - int zf=sc.nextInt(); - if (zf<=9 & zf>=0){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} -``` - - - -**2、判断一个字符数据是否是字母字符** - -**分析：** - -​ 1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -​ 2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -​ 3、判断完成之后，打印判断的结果。 - -#### Answer: - -```java -import java.util.Scanner; - -public class d1 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String str = "请输入 a - z 或者 A - Z 之间 的任意一个字符" ; - System.out.println(str); - char zf=sc.next().charAt(0); - if ((zf<='z' & zf>='a')| zf>='A' & zf<='Z'){ - System.out.println("这个字符是字母字符"); - }else{ - System.out.println("这个字符不是字母字符"); - } - } -} -``` - - - -**3、判断指定的年份是否为闰年，请使用键盘录入** - -**分析：** - -​ 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -​ 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -#### Answer: - -```java -import java.util.Scanner; - -public class d1 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String str = "请输入年份" ; - System.out.println(str); - int year = sc.nextInt(); - if ((year%4==0 & year%100!=0)|year%400==0) { - System.out.println(year+"年是闰年"); - }else - System.out.println(year+"年不是闰年"); - } -} - -``` - - - -**4、判断一个数字是否为水仙花数,请使用键盘录入** - -水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数， - -**分析：** - -​ 如：153 ---> 1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数 - -​ 1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将3位数字的每一位上的数字拆分下来 - -​ b) 计算每位数字的3次幂之和 - -​ C) 用和值 和 原来的数字进行比较 - -​ D) 打印判断的比较结果即可 - -#### Answer: - -````java -import java.util.Scanner; - -public class _20230329 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位数的数字"); - int num = sc.nextInt(); - int g = num%10; - int s = num/10%10; - int b = num/100; - int n = (g*g*g)+(s*s*s)+(b*b*b); - if(n==num){ - System.out.println(num+"是水仙花数"); - }else{ - System.out.println(num+"不是水仙花数"); - } - } -} -```` - - - -**5、判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 - -**分析：** - -​ 1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -​ 2、判断的过程 - -​ a) 将5位数字的万、千、十、个位数拆分出来 - -​ b) 判断比较万位和个位 、 千位和十位是否相等 - -​ 3、判断完成之后，打印判断的结果。 - -#### Answer: - -```java -import java.util.Scanner; - -public class d1 { - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - String str = "请任意输入一个5位数字"; - System.out.println(str); - int zf = sc.nextInt(); - int g = zf / 10000; - int s = zf / 1000 % 10; - int q = zf / 10 % 10; - int w = zf % 10; - if (g == w & s == q) { - System.out.println("这个字符是为回文数"); - } else { - System.out.println("这个字符不是为回文数"); - } - } -} -``` - diff --git "a/53 \345\221\250\345\216\232\350\276\260/20230405 \347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" "b/53 \345\221\250\345\216\232\350\276\260/20230405 \347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" deleted file mode 100644 index 74beececc8328ecb99a1f443e5626355f965b655..0000000000000000000000000000000000000000 --- "a/53 \345\221\250\345\216\232\350\276\260/20230405 \347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" +++ /dev/null @@ -1,155 +0,0 @@ -# 2023年4月5日 第一次作业 - -## 冒泡排序 - -```java -import java.util.Random; - -public class 冒泡排序 { - public static void main(String[] args) { - Random random = new Random(); - int[] num = new int[10]; - for (int i = 0; i < num.length; i++) { - num[i] = random.nextInt(10); - } - System.out.println("排序前"); - for (int n : num) { - System.out.print(n + " "); - } - for (int i = 0; i < num.length; i++) { - for (int j = 0; j < num.length - 1; j++) { - if (num[j] > num[j + 1]) { - int temp = num[j]; - num[j] = num[j + 1]; - num[j + 1] = temp; - } - } - } - System.out.println(); - System.out.println("\n排序后"); - for (int n : num) { - System.out.print(n + " "); - } - } -} -``` - -## 编码题 - -**1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - -```java - int[] num = new int[]{2, 5, 7, 3, 8}; - int min = -999; - for (int i = 0; i < num.length; i++) { - for (int j = 0; j < num.length - 1; j++) { - if (num[j] > num[j + 1]) { - min = num[j + 1]; - num[j + 1] = num[j]; - num[j] = min; - } - } - } - System.out.println("min = " + num[0]); -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -```java -{ - int[] n={2,6,3,1,7,9,5,4}; - int count=0; - for (int j = 0; j < n.length - 1; j++) { - if (n[j]%2!=0 && j%2!=0){ - System.out.print(n[j]+" "); - count++; - } - } - if (count==0){ - System.out.println("此数组中没有符合此条件的数字"); - } - } -``` - -**3.按要求在main方法中完成以下功能：** - -​ a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - -​ b. 生成2-10（范围包含2和10）之间的随机数num - -​ c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - -​ **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -{ - int[] arr = new int[5]; - System.out.println("输入5个1-60之间的数字作为数组元素"); - Scanner sc = new Scanner(System.in); - for (int i = 0; i < 5; i++) { - System.out.println("请输入第" + (i + 1) + "个1-60之间的数字作为数组元素"); - arr[i] = sc.nextInt(); - } - System.out.print("你输入的5个数字分别是："); - for (int n : arr) { - System.out.print(n + " "); - } - Random Ran = new Random(); - int ran = Ran.nextInt(8) + 2; - System.out.println("\n\n随机生成的数是" + ran); - System.out.println("\n以下是不是num倍数的元素"); - for (int i = 0; i < arr.length; i++) { - if (arr[i] % ran != 0) { - System.out.print(arr[i] + " "); - } - } - } -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -{ - int[] arr = {9, 1, 3, 4, 54, 56, 23, 22, 20, 43, 45, 78}; - for (int i = 0; i < arr.length; i++) { - if (arr[i] % 6 == 0) { - System.out.print(arr[i] + " "); - } - } - } -``` - - - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -{ - int[] arr = new int[20]; - Random r = new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = r.nextInt(20) + 20; - } - System.out.print("随机生成的20个数字分别是:"); - for (int n : arr) { - System.out.print(n + " "); - } - Scanner sc = new Scanner(System.in); - System.out.println("\n请输入范围为20-40之间的一个数字"); - int Sc = sc.nextInt(); -// if (Sc>20 && Sc<40){ -// System.out.println("合法输入"); -// }else { -// System.out.println("非法输入"); -// } - int count = 0; - System.out.println("你输入的是" + Sc + "\n"); - for (int i = 0; i < arr.length; i++) { - if (arr[i] == Sc) { - count++; - } - } - System.out.println(Sc + "出现了" + count + "次"); - } -``` - diff --git "a/53 \345\221\250\345\216\232\350\276\260/20230406 \347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" "b/53 \345\221\250\345\216\232\350\276\260/20230406 \347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" deleted file mode 100644 index 2e282ca7f48981925e0b90403ea5b9ba1d4f6e23..0000000000000000000000000000000000000000 --- "a/53 \345\221\250\345\216\232\350\276\260/20230406 \347\254\254\344\272\214\346\254\241\344\275\234\344\270\232.md" +++ /dev/null @@ -1,89 +0,0 @@ -# 2023年4月6日作业 - -1,定义一个方法，接收一个数组，返回该数组的最大值和最小值；在主方法中打印最大，最小值 - -```java -{ - public static void main(String[] args) { - int[] array = {423, 34, 56, 23, 2}; - int max = getMaxs(array); - int min = getMins(array); - System.out.println("最大值：" + max + "最小值：" + min); - } - - public static int getMins(int[] array) { - int tem = array[0]; - for (int i = 0; i < array.length; i++) { - if (tem < array[i]) { - tem = array[i]; - } - } - return tem; - } - - public static int getMaxs(int[] array) { - int tem = array[0]; - for (int i = 0; i < array.length; i++) { - if (tem > array[i]) { - tem = array[i]; - } - } - return tem; - } -} -``` - - - -2,定义一个方法，接收长和宽，返回一个矩形的面积，在主方法中，打印这个面积 - -```java -{ - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入长"); - int a = sc.nextInt(); - System.out.println("请输入宽"); - int b = sc.nextInt(); - System.out.println("长方形的面积为" + getArea(a, b)); - } - - private static int getArea(int a, int b) { - int area = a * b; - return area; - } -} -``` - - - -3，利用方法重载，定义多个同名方法，通过接收一个不同类型的参数，方法体里用扫描器接收一个对应类型的值，最后将该输入的值返回，在主方法中，输出该值。 - -```java -{ - public static void main(String[] args) { - System.out.println("请输入任意值，稍后将会返回任意值"); - System.out.println("你输入的值是：" + num(null)); - } - - public static int num(int result) { - Scanner sc = new Scanner(System.in); - result = sc.nextInt(); - return result; - } - - public static double num(double result) { - Scanner sc = new Scanner(System.in); - result = sc.nextDouble(); - return result; - } - - public static String num(String result) { - Scanner sc = new Scanner(System.in); - result = sc.next(); - return result; - } - -} -``` - diff --git "a/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2321.md" "b/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2321.md" deleted file mode 100644 index e35d2f4226d8ad2e40e40c121d86f1dd556b6ee1..0000000000000000000000000000000000000000 --- "a/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2321.md" +++ /dev/null @@ -1,139 +0,0 @@ -**判断一个字符数据是否是数字字符** - -1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据 - -2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。 - -3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; -public class zy22{ - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} -``` - -**判断一个字符数据是否是字母字符** - -1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据 - -2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z - -3、判断完成之后，打印判断的结果。 - -```java - -import java.util.Scanner; -public class zy23 { - public static void main(String[] args) { - Scanner num=new Scanner(System.in); - System.out.println("请输入1-9中的其中一个数字"); - int n=num.nextInt(); - if(0<=n & n<=9){ - System.out.println("这个字符是数字字符"); - }else{ - System.out.println("这个字符不是数字字符"); - } - } -} -``` - -**判断指定的年份是否为闰年，请使用键盘录入** - -1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 - -2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; -public class zy24 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入年份"); - int n= sc.nextInt(); - if(n%4==0 && n%100!=0 || n%400==0){ - System.out.println("是闰年"); - }else{ - System.out.println("不是闰年"); - } - } - } - -``` - -**判断一个数字是否为水仙花数,请使用键盘录入** - -1、首先需要提供一个需要判断的3位数字，因此需要一个数值 - -2、判断的过程 - -a) 将3位数字的每一位上的数字拆分下来 - -b) 计算每位数字的3次幂之和 - -C) 用和值 和 原来的数字进行比较 - -D) 打印判断的比较结果即可 - -```java -import java.util.Scanner; -public class zy25 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入3位数"); - int sz= sc.nextInt(); - int gw=sz%10; - int sw=sz/10%10; - int bw=sz/100; - if(sz==gw*gw*gw+sw*sw*sw+bw*bw*bw){ - System.out.println("你输入的是水仙花数"); - }else{ - System.out.println("你输入的不是水仙花数"); - } - } -} -``` - -**判断一个5位数字是否为回文数，使用键盘录入** - -五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321 23732 56665 - -1、首先需要提供一个需要判断的5位数字，因此需要一个数值 - -2、判断的过程 - -a) 将5位数字的万、千、十、个位数拆分出来 - -b) 判断比较万位和个位 、 千位和十位是否相等 - -3、判断完成之后，打印判断的结果。 - -```java -import java.util.Scanner; -public class zy27 { - public static void main(String[] args) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入五位数"); - int sz= sc.nextInt(); - int ww=sz/10000;//万位 - int qw=sz%10000/1000;//千位 - int gw=sz%10;//个位 - int sw=sz%100/10;//十位 - if(ww==gw && sw==qw){ - System.out.println("是回文数"); - }else{ - System.out.println("不是回文数"); - } - } -} -``` - diff --git "a/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2322.md" "b/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2322.md" deleted file mode 100644 index 3719f9d9529058de2b630169c7cca090acde656b..0000000000000000000000000000000000000000 --- "a/54.\345\217\266\345\255\220\350\261\252/\344\275\234\344\270\2322.md" +++ /dev/null @@ -1,142 +0,0 @@ -1.定义5个元素数组 - - 2.可以使用初始化数组的两种方式之一为数组元素赋值 - - 3.遍历数组求数组中的最小值 - -```java -import java.util.Scanner; - -public class D1 { - public static void main(String[] args) { - int[] num =new int[5]; - for (int i = 0; i < num.length; i++) { - Scanner sc=new Scanner(System.in); - System.out.println("请输入"+(i+1)); - num[i]=sc.nextInt(); - } - int min = num[0]; - for (int i = 0; i num[i]){ - min=num[i]; - } - } - System.out.println("最小的是"+min); - } - } -``` - -**2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - -**分析：** - - 1、遍历数组 - - 2、判断索引是否是奇数（索引 % 2 != 0） - - 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - - 4、满足条件输出结果 - -```java -public class D2 { - public static void main(String[] args) { -// 1、遍历数组 -// -// 2、判断索引是否是奇数（索引 % 2 != 0） -// -// 3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) -// -// 4、满足条件输出结果 - int[] arr ={12,11,17,4,6}; - for (int i = 0; i < arr.length; i++) { - if (i%2!=0 && arr[i]%2!=0){ - System.out.println("基数是"+arr[i]); - - } - } - - } -} -``` - -**3.按要求在main方法中完成以下功能：** - - a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 - - b. 生成2-10（范围包含2和10）之间的随机数num - - c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 - - **PS：输入的数组元素范围包括1和60，不需要代码判断** - -```java -import java.util.Random; -import java.util.Scanner; - -public class D3 { - public static void main(String[] args) { - int[] arr = new int[5]; - for (int i = 0; i < arr.length; i++) { - Scanner sc= new Scanner(System.in); - System.out.println("请输入1-60的数"+(i+1)+":"); - arr[i]=sc.nextInt(); - } - Random ran=new Random(); - int num =ran.nextInt(8)+2; - for (int i = 0; i < arr.length; i++) { - if (arr[i]%num!=0){ - System.out.println(arr[i]+"不是"+num+"的倍数"); - } - } - - } -} -``` - -**4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - -```java -public class D4 { - public static void main(String[] args) { -// **4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。** - int[] arr ={9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6==0){ - System.out.print(+arr[i]+" "); - - } - - } - } -} -``` - -**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - -```java -import java.util.Random; -import java.util.Scanner; - -public class D5 { - public static void main(String[] args) { -// **5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。 - int[] arr = new int[20]; - Scanner sc= new Scanner(System.in); - System.out.println("输入20-40的数:"); - int a=sc.nextInt(); - Random ran =new Random(); - for (int i = 0; i < arr.length; i++) { - arr[i] = ran.nextInt(21)+20; - } - int count=0; - for (int i = 0; i =0|a<=9){ - System.out.println(a+"这个字符为数字字符"); - }else { - System.out.println(a+"这个字符不是数字字符"); - } - } -} -``` - -### 第二题 - -``` java -// 判断一个字符数据是否是字母字符 -``` - - - -### 第三题 - -``` java -import java.util.Scanner; - -public class zy { -// 判断指定的年份是否为闰年，请使用键盘录入 -// 1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除 -// 2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。 - - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个年份"); - int a = sc.nextInt(); - if(a%400==0){ - System.out.println(a+"为闰年"); - }else { - if(a%100==0){ - System.out.println(a +"不为闰年"); - }else { - if(a%4==0){ - System.out.println(a+"为闰年"); - } else { - System.out.println(a+"不为闰年"); - } - } - } - - - - } -} -``` - -### 第四题 - -```java -import java.util.Scanner; - -public class zy { -// 判断一个数字是否为水仙花数,请使用键盘录入 -// 水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等， -// 则为水仙花数， - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个三位数"); - int a = sc.nextInt(); - int bai = a/100; - int shi = a/10%10; - int ge = a%10; - if (bai*bai*bai+shi*shi*shi+ge*ge*ge==a){ - System.out.println(a+"这个数为水仙花数"); - }else{ - System.out.println(a+"这个数不为水仙花数"); - } - } -} -``` - -### 第五题 - -``` java -import java.util.Scanner; - -public class zy { -// 判断一个5位数字是否为回文数，使用键盘录入 -// 五位数的回文数是指最高位和最低位相等，次高位和次低位相等。 -// 如：12321 23732 56665 - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - System.out.println("请输入一个五位数"); - int a = sc.nextInt(); - int ge = a%10000%1000%100%10; - int shi = a%10000%1000%100/10; - int qian = a%10000/1000; - int wan = a/10000; - if (ge==wan & shi==qian){ - System.out.println(a+"这个数为回文数"); - }else{ - System.out.println(a+"这个数不为回文数"); - } - } -} -``` - - - diff --git "a/56 \350\265\265\346\225\217/20230406java\344\275\234\344\270\232.md" "b/56 \350\265\265\346\225\217/20230406java\344\275\234\344\270\232.md" deleted file mode 100644 index b4133356d6be3abbb0e1a7afbadf3acc5a17203d..0000000000000000000000000000000000000000 --- "a/56 \350\265\265\346\225\217/20230406java\344\275\234\344\270\232.md" +++ /dev/null @@ -1,135 +0,0 @@ -# 作业 - -### 作业1 - -```java -public class zy1 { - // **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - // 1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - public static void main(String[] args) { - int [] num = {10,30,40,50,20}; - int min = num[0]; - for (int i = 1; i < num.length ; i++) { - if (min>num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+ min); - } -} - -``` - -### 作业2 - -```java -public class zy2 { - // **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - public static void main(String[] args) { - int [] num = {4,5,8,16,22,17}; - for (int i = 0; i < num.length; i++) { - if (i%2 != 0 && num[i]%2 != 0 ){ - System.out.println("索引:"+i+",元素："+ num[i]+"，满足条件"); - } - } - } -} - -``` - -### 作业3 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy3 { -// **3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - public static void main(String[] args) { - int [] arr = new int[5]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) { - arr[i] = sc.nextInt(); - } - - Random r = new Random(); - int num = r.nextInt(9)+2; - - for (int a = 0; a < arr.length; a++) { - if (arr[a]%num != 0){ - System.out.println(arr[a]+"不是随机数的倍数"); - } - } - } -} - -``` - -### 作业4 - -```java -public class zy4 { - // 4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - // 要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int [] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6 == 0){ - System.out.print(" "+ arr[i]); - } - } - } -} - -``` - -### 作业5 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy5 { - // 5.定义一个长度为20的数组，元素为20-40的随机数， - // 要求判断指定元素在数组中出现的次数， - // 指定元素为键盘录入范围为20-40之间。 - public static void main(String[] args) { - int [] num = new int[20]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入一个20-40的整数"); - int a = sc.nextInt(); - - Random r = new Random(); - - for (int i = 0; i < num.length; i++) { - num[i]= r.nextInt(21)+20; - } - - int b = 0; - for (int x = 0; x < num.length; x++) { - if (num[x] == a){ - b++; - } - } - - System.out.println("指定元素在随机数组出现的次数为："+b+"次。"); - - } -} -``` - diff --git "a/57 \351\273\204\346\265\201\346\266\233/20230405 java\344\275\234\344\270\232.md" "b/57 \351\273\204\346\265\201\346\266\233/20230405 java\344\275\234\344\270\232.md" deleted file mode 100644 index b4133356d6be3abbb0e1a7afbadf3acc5a17203d..0000000000000000000000000000000000000000 --- "a/57 \351\273\204\346\265\201\346\266\233/20230405 java\344\275\234\344\270\232.md" +++ /dev/null @@ -1,135 +0,0 @@ -# 作业 - -### 作业1 - -```java -public class zy1 { - // **1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值** - //**操作步骤：** - // 1.定义5个元素数组 - //2.可以使用初始化数组的两种方式之一为数组元素赋值 - //3.遍历数组求数组中的最小值 - public static void main(String[] args) { - int [] num = {10,30,40,50,20}; - int min = num[0]; - for (int i = 1; i < num.length ; i++) { - if (min>num[i]){ - min = num[i]; - } - } - System.out.println("数组中的最小值为："+ min); - } -} - -``` - -### 作业2 - -```java -public class zy2 { - // **2．需求：求出数组中索引与索引对应的元素都是奇数的元素** - //1、遍历数组 - //2、判断索引是否是奇数（索引 % 2 != 0） - //3、判断索引对应的元素是否是奇数(arr[索引] % 2 != 0) - //4、满足条件输出结果 - public static void main(String[] args) { - int [] num = {4,5,8,16,22,17}; - for (int i = 0; i < num.length; i++) { - if (i%2 != 0 && num[i]%2 != 0 ){ - System.out.println("索引:"+i+",元素："+ num[i]+"，满足条件"); - } - } - } -} - -``` - -### 作业3 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy3 { -// **3.按要求在main方法中完成以下功能：** -// a. 定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素 -// b. 生成2-10（范围包含2和10）之间的随机数num -// c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出 -// **PS：输入的数组元素范围包括1和60，不需要代码判断** - public static void main(String[] args) { - int [] arr = new int[5]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入5个1-60之间的数字作为数组元素"); - for (int i = 0; i < arr.length; i++) { - arr[i] = sc.nextInt(); - } - - Random r = new Random(); - int num = r.nextInt(9)+2; - - for (int a = 0; a < arr.length; a++) { - if (arr[a]%num != 0){ - System.out.println(arr[a]+"不是随机数的倍数"); - } - } - } -} - -``` - -### 作业4 - -```java -public class zy4 { - // 4.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - // 要求打印数组中能被6整除的元素。 - public static void main(String[] args) { - int [] arr = {9,1,3,4,54,56,23,22,20,43,45,78}; - System.out.print("能被6整除的元素有："); - for (int i = 0; i < arr.length; i++) { - if (arr[i]%6 == 0){ - System.out.print(" "+ arr[i]); - } - } - } -} - -``` - -### 作业5 - -```java -import java.util.Random; -import java.util.Scanner; - -public class zy5 { - // 5.定义一个长度为20的数组，元素为20-40的随机数， - // 要求判断指定元素在数组中出现的次数， - // 指定元素为键盘录入范围为20-40之间。 - public static void main(String[] args) { - int [] num = new int[20]; - - Scanner sc = new Scanner(System.in); - System.out.println("输入一个20-40的整数"); - int a = sc.nextInt(); - - Random r = new Random(); - - for (int i = 0; i < num.length; i++) { - num[i]= r.nextInt(21)+20; - } - - int b = 0; - for (int x = 0; x < num.length; x++) { - if (num[x] == a){ - b++; - } - } - - System.out.println("指定元素在随机数组出现的次数为："+b+"次。"); - - } -} -``` -