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/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/08 \345\256\230\346\226\207\350\257\232/20230328 \345\244\215\344\271\240.md" "b/08 \345\256\230\346\226\207\350\257\232/20230328 \345\244\215\344\271\240.md"
deleted file mode 100644
index 93ff37f231a8fc51578b20dbd6b6037e665cd418..0000000000000000000000000000000000000000
--- "a/08 \345\256\230\346\226\207\350\257\232/20230328 \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/09 \346\233\271\346\255\243\346\263\242/20230328 JAVA\350\277\220\347\256\227\347\254\246.md" "b/09 \346\233\271\346\255\243\346\263\242/20230328 JAVA\350\277\220\347\256\227\347\254\246.md"
deleted file mode 100644
index 8e330cf7ef8971e27efe3c3a8e65b29685f61bed..0000000000000000000000000000000000000000
--- "a/09 \346\233\271\346\255\243\346\263\242/20230328 JAVA\350\277\220\347\256\227\347\254\246.md"	
+++ /dev/null
@@ -1,112 +0,0 @@
-# 作业
-
-``` java
-package 三月二十八;
-
-import java.util.Scanner;
-//1、判断一个字符数据是否是数字字符
-public class tiyi {
-    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+"字符不是数字字符");
-        }
-    }
-}
-
-```
-
-``` java
-package 三月二十八;
-
-import java.util.Scanner;
-//2、判断一个字符数据是否是字母字符
-public class tier {
-    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' || 'A'<=a & a<='Z'){
-            System.out.println(a+"字符是字母字符");
-        }else{
-            System.out.println(a+"字符不是字母字符");
-        }
-    }
-}
-
-```
-
-``` java
-package 三月二十八;
-
-import java.util.Scanner;
-//3、判断指定的年份是否为闰年，请使用键盘录入
-public class tisan {
-    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){
-            System.out.println(a+"年是闰年");
-        }else{
-            System.out.println(a+"年不是闰年");
-        }
-    }
-}
-
-```
-
-``` java
-package 三月二十八;
-
-import java.util.Scanner;
-//4、判断一个数字是否为水仙花数,请使用键盘录入
-public class tisi {
-    public static void main(String[] args) {
-        Scanner sc=new Scanner(System.in);
-        System.out.println("请输入一个数字：");
-        int a= sc.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+"不是水仙花数");
-        }
-    }
-}
-
-```
-
-``` java
-package 三月二十八;
-
-import java.util.Scanner;
-//5、判断一个5位数字是否为回文数，使用键盘录入
-public class tiwu {
-    public static void main(String[] args) {
-        Scanner sc=new Scanner(System.in);
-        System.out.println("请输入一个五位数：");
-        int a= sc.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/09 \346\233\271\346\255\243\346\263\242/20230404 JAVA\346\225\260\347\273\204\345\244\215\344\271\240.md" "b/09 \346\233\271\346\255\243\346\263\242/20230404 JAVA\346\225\260\347\273\204\345\244\215\344\271\240.md"
deleted file mode 100644
index c025ec2020b5c43e2a3367b47648742ca1f42b41..0000000000000000000000000000000000000000
--- "a/09 \346\233\271\346\255\243\346\263\242/20230404 JAVA\346\225\260\347\273\204\345\244\215\344\271\240.md"	
+++ /dev/null
@@ -1,138 +0,0 @@
-# 作业
-
-### 第一题
-
-```java
-package Fei;
-
-import java.util.Scanner;
-
-public class Ke1 {
-    public static void main(String[] args) {
-        //1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值
-        int[] Sz=new int[5]; //定义一个五位元素的动态数组
-        //给动态数组Sz赋值
-        for (int i = 0; i <Sz.length; i++) {
-            Scanner sc=new Scanner(System.in);
-            System.out.print("请输入第"+(i+1)+"个元素：");
-            Sz[i]= sc.nextInt();
-        }
-        //求动态数组Sz元素中的最小元素
-        int Max=0;
-        for (int i = 0; i < Sz.length; i++) {
-            if (Max<Sz[i]){
-                Max=Sz[i];
-            }
-        }
-        System.out.println("Sz数组中最大的元素是："+Max);
-    }
-}
-
-```
-
-### 第二题
-
-```java
-package Fei;
-
-public class Ke2 {
-    public static void main(String[] args) {
-        //2．需求：求出索引与索引对应的元素都是奇数的元素
-        int[] Aa={2,1,3,5,7,6};
-        for (int i = 0; i <Aa.length ; i++) {
-            if (i%2!=0 && Aa[i]%2!=0){
-                System.out.println("索引与索引对应的元素都是奇数的元素是："+Aa[i]);
-            }
-        }
-    }
-}
-
-```
-
-### 第三题
-
-```java
-package Fei;
-
-import java.util.Random;
-import java.util.Scanner;
-
-public class Ke3 {
-    public static void main(String[] args) {
-        //3.按要求在main方法中完成以下功能：
-        //a.定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素
-        //b.生成2-10（范围包含2和10）之间的随机数num
-        //c.遍历数组arr,筛选出数组中不是num倍数的元素并输出
-        int[] arr=new int[5];
-        for (int i = 0; i < arr.length; i++) {
-            Scanner sc=new Scanner(System.in);
-            System.out.print("请输入元素"+(i+1)+"：");
-            arr[i]= sc.nextInt();
-        }
-        Random a=new Random();
-        int Aa=a.nextInt(8)+2;
-        for (int i = 0; i < arr.length; i++) {
-            if (arr[i]%Aa!=0){
-                System.out.println(arr[i]+"不是随机数"+Aa+"的倍数");
-            }
-        }
-    }
-}
-
-```
-
-### 第四题
-
-```java
-package Fei;
-
-import java.util.Arrays;
-
-public class Ke4 {
-    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};
-        int[] a=new int[arr.length];
-        for (int i = 0; i < arr.length ; i++) {
-            if (arr[i]%6!=0){
-                 a[i]=arr[i];
-            }
-        }
-        System.out.println("不是6的倍数的元素有："+Arrays.toString(a));
-    }
-}
-
-```
-
-### 第五题
-
-```java
-package Fei;
-
-import java.util.Random;
-import java.util.Scanner;
-
-public class Ke5 {
-    public static void main(String[] args) {
-        //5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。
-        int[] arr=new int[20];
-        Random sc=new Random();
-        for (int i = 0; i < arr.length; i++) {
-            int a= sc.nextInt(20)+20;
-            arr[i]=a;
-        }
-        Scanner Bb=new Scanner(System.in);
-        System.out.print("请输入20-40范围内的一个数：");
-        int b= Bb.nextInt();
-        int Cf=0;
-        for (int i = 0; i < arr.length; i++) {
-            if (arr[i]==b){
-                Cf++;
-            }
-        }
-        System.out.println(b+"一共在数组中出现了"+Cf+"次");
-    }
-}
-
-```
-
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<num;i++){
-            int b = a1.charAt(i);
-            for(int j=48;j<=57;j++){
-                if(b==j){
-                    i=i+1;
-                }else if (j==57){
-                    pd=-2;
-                }
-            }
-        }
-        if (pd==-1){
-            System.out.println("是数字字符"+a1);
-        }else{
-            System.out.println("不是数字字符"+a1);
-        }
-    }
-}
-```
-
-
-
-**2、判断一个字符数据是否是字母字符** 
-
-**分析：**
-
-​	1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据
-
-​	2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z
-
-​	3、判断完成之后，打印判断的结果。
-
-```java
-import java.util.Scanner;
-
-//2、判断一个字符数据是否是字母字符
-//分析：
-//1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据
-//2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要下于或等于z 或者 大于或等于A，并且还要下于或等于Z
-//3、判断完成之后，打印判断的结果。
-public class zy {
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("请输入一个字符");
-        String ziMu = sc.next();
-        int b = ziMu.length();
-        if (b>=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/14 \346\235\216\344\277\212\345\205\264/20230328 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/14 \346\235\216\344\277\212\345\205\264/20230328 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"
deleted file mode 100644
index adc6247ba460888f734a722ab450d9ce7eff4395..0000000000000000000000000000000000000000
--- "a/14 \346\235\216\344\277\212\345\205\264/20230328 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"	
+++ /dev/null
@@ -1,167 +0,0 @@
-**1、判断一个字符数据是否是数字字符 **
-
-**分析：**
-
-​	1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
-
-​	2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。
-
-​	3、判断完成之后，打印判断的结果。
-
-```java
-import java.util.Scanner;
-
-public class Day0328 {
-    public static void main(String[] args) {
-//	1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
-        Scanner sc = new Scanner(System.in);
-        char b= sc.nextLine().charAt(0);
-        char a= '1';
-        if (b>='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/16 \351\230\231\350\213\217\346\226\207/20230330Java\345\244\215\344\271\240\344\275\234\344\270\232.md" "b/16 \351\230\231\350\213\217\346\226\207/20230330Java\345\244\215\344\271\240\344\275\234\344\270\232.md"
deleted file mode 100644
index 319df98ab70de305dd3e171bf6c2c9978f42db7a..0000000000000000000000000000000000000000
--- "a/16 \351\230\231\350\213\217\346\226\207/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/18 \345\276\220\346\260\270\346\267\263/20230328java\344\275\234\344\270\232.md" "b/18 \345\276\220\346\260\270\346\267\263/20230328java\344\275\234\344\270\232.md"
deleted file mode 100644
index 1ccbad6e206bdb99f71055301449aa332d54f336..0000000000000000000000000000000000000000
--- "a/18 \345\276\220\346\260\270\346\267\263/20230328java\344\275\234\344\270\232.md"	
+++ /dev/null
@@ -1,162 +0,0 @@
-```java
-1、判断一个字符数据是否是数字字符
-
-分析:
-
-1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
-
-2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。
-
-3、判断完成之后，打印判断的结果。
-import java.util.Scanner;
-
-public class s02 {
-    public static void main(String[] args) {
-        Scanner sc=new Scanner(System.in);
-        char a=sc.nextLine().charAt(0);
-        if(a>=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;j<arr.length;j++){
-            if (arr[j]%num!=0){
-                System.out.println(arr[j]+"不是num的倍数");
-            }
-        }
-
-    }
-}
-
-```
-
-```java
-public class T4 {
-    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};
-        for (int i = 0; i < arr.length; i++) {
-            if(arr[i]%6==0){
-                System.out.println(arr[i]+"可以被6整除");
-            }
-        }
-    }
-}
-
-```
-
-```java
-import java.util.Random;
-import java.util.Scanner;
-
-public class T5 {
-    public static void main(String[] args) {
-//        5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。
-        int[] arr = new int[20];
-        Random r = new Random();
-        Scanner sc = new Scanner(System.in);
-        System.out.println("请输入一个20-40的数字");
-        int x = 0;
-        int a = sc.nextInt();
-            for (int i = 0; i < arr.length; i++) {
-                arr[i] = r.nextInt(21) + 20;
-                if (a == arr[i]) {
-                    x++;
-                }
-            }
-            if (x == 0) {
-                System.out.println("未出现");
-            } else {
-                System.out.println("这个数字" + a + "重复了" + x + "次");
-
-            }
-        }
-    }
-
-```
-
diff --git "a/19\345\275\255\345\213\207\346\226\214/0328\344\275\234\344\270\232.md" "b/19\345\275\255\345\213\207\346\226\214/0328\344\275\234\344\270\232.md"
deleted file mode 100644
index ce6b9710fc02f603178b9e23ea7a9d653a3a3156..0000000000000000000000000000000000000000
--- "a/19\345\275\255\345\213\207\346\226\214/0328\344\275\234\344\270\232.md"
+++ /dev/null
@@ -1,167 +0,0 @@
-**1、判断一个字符数据是否是数字字符 **
-
-**分析：**
-
-​	1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
-
-​	2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。
-
-​	3、判断完成之后，打印判断的结果。
-
-```java
-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、判断完成之后，打印判断的结果。
-
-```java
-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、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。
-
-```java
-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) 打印判断的比较结果即可
-
-```java
-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("你输入的不是水仙花数");
-        }
-    }
-}
-```
-
-
-
-**5、判断一个5位数字是否为回文数，使用键盘录入** 
-
-五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 
-
-**分析：**
-
-​	1、首先需要提供一个需要判断的5位数字，因此需要一个数值
-
-​	2、判断的过程 
-
-​		a) 将5位数字的万、千、十、个位数拆分出来
-
-​		b) 判断比较万位和个位 、 千位和十位是否相等
-
-​	3、判断完成之后，打印判断的结果。
-
-```java
-import java.util.Scanner;
-
-public class a5 {
-    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/20230328 java\345\244\215\344\271\240.md" "b/20230328 java\345\244\215\344\271\240.md"
deleted file mode 100644
index d9c34b3fe7c36cd89a64944d72078df77782d7f2..0000000000000000000000000000000000000000
--- "a/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/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/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/24 \345\220\264\346\206\266\350\261\252/20230328java\344\275\234\344\270\232.md" "b/24 \345\220\264\346\206\266\350\261\252/20230328java\344\275\234\344\270\232.md"
deleted file mode 100644
index 1310c3f452cb9d559c1eb6434cfe38db9543579e..0000000000000000000000000000000000000000
--- "a/24 \345\220\264\346\206\266\350\261\252/20230328java\344\275\234\344\270\232.md"	
+++ /dev/null
@@ -1,153 +0,0 @@
-```java
-1、判断一个字符数据是否是数字字符
-
-分析:
-
-1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
-
-2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要下于或等于字符9即可。
-
-3、判断完成之后，打印判断的结果。
-import java.util.Scanner;
-
-public class s02 {
-    public static void main(String[] args) {
-        Scanner sc=new Scanner(System.in);
-        char a=sc.nextLine().charAt(0);
-        if(a>=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) {
-                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/29 \350\267\257\347\216\262/20230328 Java\347\273\203\344\271\240.md" "b/29 \350\267\257\347\216\262/20230328 Java\347\273\203\344\271\240.md"
deleted file mode 100644
index ff5978ff3bcdd4190c639ca8bfb413c2dc0b69db..0000000000000000000000000000000000000000
--- "a/29 \350\267\257\347\216\262/20230328 Java\347\273\203\344\271\240.md"	
+++ /dev/null
@@ -1,337 +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。求子女身高分别预计为多少？
-
-```java
-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元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？
-
-```java
-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元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？
-
-```java
-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、判断完成之后，打印判断的结果。
-
-```java
-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、判断完成之后，打印判断的结果。
-
-```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/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/42 \346\226\271\345\242\236\345\205\264/\344\272\224\351\201\223\351\242\230.md" "b/42 \346\226\271\345\242\236\345\205\264/\344\272\224\351\201\223\351\242\230.md"
deleted file mode 100644
index 46804c745dc1494af5c0e16b36f28e72099409dd..0000000000000000000000000000000000000000
--- "a/42 \346\226\271\345\242\236\345\205\264/\344\272\224\351\201\223\351\242\230.md"	
+++ /dev/null
@@ -1,116 +0,0 @@
-```java
-package PACKAGE_NAME.src.k;
-import java.util.Scanner;
-
-public class j {
-    // 第一题
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("请输入一个数字:");
-        int x = sc.nextInt();
-        String z = String.valueOf(x);
-        String l = "";
-        if(z.length()%2!=0){
-            String y = z.substring(0,(z.length()-1)/2);
-            for(int i =z.length()-1;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<z.length();i++){
-                char one = z.charAt(i);
-               String one1 = String.valueOf(one);
-               int num = Integer.parseInt(one1);
-                int mi = num*num*num;
-                sum = sum+mi;
-
-            }
-            if(sum == x){
-                System.out.println("这个数是一个水仙花数值为"+sum);
-            }else{
-                System.out.println(x + "这个数不是水仙花数");
-           }
-        }
-    }
-
-    // 第三题
-    public static void number() {
-
-        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("不是数字字符");
-            }
-        }
-    }
-
-    // 第四题
-    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/44 \344\273\243\347\221\236/20230329 Java\347\273\203\344\271\240.md" "b/44 \344\273\243\347\221\236/20230329 Java\347\273\203\344\271\240.md"
deleted file mode 100644
index 817e74498752022d13e39e3483e5f03a96065d90..0000000000000000000000000000000000000000
--- "a/44 \344\273\243\347\221\236/20230329 Java\347\273\203\344\271\240.md"	
+++ /dev/null
@@ -1,18 +0,0 @@
-/*某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？*/
-
-public class nihao {
-    public static void main(String[] args) {
-        int a=24;
-        int b=8;
-        int c=3;
-        int num=a+b+c;
-        double d=num*0.8;
-        double f=num-16;
-        if(d>f){
-            System.out.println(f+"这是大于d的");
-        }
-        else if(d<f){
-            System.out.println(d+"这是大于f的");
-        }
-    }
-}
\ No newline at end of file
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/06 \351\231\210\345\277\227\344\274\237/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"
similarity index 100%
rename from "06 \351\231\210\345\277\227\344\274\237/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"
rename to "51 \347\250\213\350\210\234/20230329 \350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"
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"
new file mode 100644
index 0000000000000000000000000000000000000000..76356ce39f337e034c0859fb2b944f4353c0dc7f
--- /dev/null
+++ "b/51 \347\250\213\350\210\234/20230405 \346\225\260\347\273\204\344\275\234\344\270\232 A.md"	
@@ -0,0 +1,183 @@
+## 编码题
+
+**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<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;
+
+//**5.定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次**数，指定元素为键盘录入范围为20-40之间。
+public class zy {
+    public static void main(String[] args) {
+        int [] arr = new int[20];
+        Random ran = new Random();
+        for (int i=0;i<arr.length;i++){
+            int num = ran.nextInt(21)+20;
+            arr[i]=num;
+            System.out.print(arr[i]+" ");
+        }
+        Scanner sc = new Scanner(System.in);
+        System.out.println();
+        System.out.println("请输入20-40之间的数");
+        int shu = sc.nextInt();
+        if(shu >=20 && shu <=40){
+            int count = 0;
+            for (int i=0;i<arr.length;i++){
+                if(arr[i]==shu){
+                    count++;
+                }
+            }
+            System.out.println(count);
+        }
+    }
+}
+```
+
+
+
+
+
diff --git "a/53 \345\221\250\345\216\232\350\276\260/20230328 \347\254\254\344\270\200\346\254\241\345\244\215\344\271\240\351\242\230.md" "b/53 \345\221\250\345\216\232\350\276\260/20230328 \347\254\254\344\270\200\346\254\241\345\244\215\344\271\240\351\242\230.md"
deleted file mode 100644
index b9f1e4d72b07094a0a05a241569cd2753d98936c..0000000000000000000000000000000000000000
--- "a/53 \345\221\250\345\216\232\350\276\260/20230328 \347\254\254\344\270\200\346\254\241\345\244\215\344\271\240\351\242\230.md"	
+++ /dev/null
@@ -1,335 +0,0 @@
-# 知识点
-
-运算符
-
-## 题目1(训练)
-
-身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下：
-
-​	儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
-
-​	女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
-
-现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？
-
-### 训练提示
-
-1. 已知的父母身高如何用代码体现？
-
-2. 题目中的公式如何转化为代码？
-
-### 解题方案
-
-1. 使用变量的定义和算术运算符完成本题
-
-### 操作步骤
-
-1. 定义小数变量代表父亲身高
-
-2. 定义小数变量代表母亲身高
-
-3. 通过儿子身高计算方式计算儿子身高
-
-4. 通过女儿身高计算方式计算女人身高
-
-#### Answer:
-
-```java
-public class d1 {
-    public static void main(String[] args) {
-       int fa =177;
-       int ma = 165;
-        System.out.println("儿子与女儿的身高分别是："+((fa+ma)*1.08/2)+"Cm、"+((fa*0.923+ma)/2)+"Cm");
-    }
-}
-```
-
-
-
-## 题目2（训练）
-
-红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？
-
-### 训练提示
-
-1. 用什么知识点来计算她们现在的钱有多少？
-2. 如何对比两个人的钱数？
-
-### 解题方案
-
-1. 使用赋值运算符和算术运算符计算各自的钱，使用比较运算符对比大小
-
-### 操作步骤
-
-1. 定义红茶妹妹原来的钱为整数变量
-
-2. 定义绿茶妹妹原来的钱为整数变量
-
-3. 使用赋值运算符和算术运算符计算其现有的钱
-
-4. 使用比较运算符对数值做出比较
-
-#### Answer
-
-```java
-public class _20230329 {
-    public static void main(String[] args) {
-        int r=21,g=24;
-        int r1=r*2+3,g1=g*2;
-        String result= r1==g1? "结果一样多":"结果不一样多";
-        System.out.println(result);
-    }
-}
-```
-
-## 题目3（综合）
-
-某小伙想定一份外卖，商家的优惠方式如下：
-
-鱼香肉丝单点24元，
-
-油炸花生米单点8元，
-
-米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？
-
-### 训练提示
-
-1. 有两种购买方式，一种是不使用优惠价，另一种是使用优惠价。分别计算花费后，对两种方式的花费作对比。
-
-### 解题方案
-
-1. 使用算术运算符、赋值运算符和三元运算符联合完成本题
-
-### 操作步骤
-
-1. 使用算术运算符求出不使用优惠时的总价
-2. 使用三元运算符判断总价是否满足打折条件，并求出折后总价
-3. 使用算术运算符求出使用优惠价时的总价
-4. 使用三元运算符判断最终更合算的购买方式和花费
-
-#### Answer:
-
-```java
-import java.util.Scanner;
-
-public class _20230329 {
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("某小伙想定一份外卖，商家的优惠方式如下：\n" +
-                "\n" +
-                "鱼香肉丝单点24元，\n" +
-                "油炸花生米单点8元，\n" +
-                "米饭单点3元。订单满30元8折优惠。" +
-                "鱼香肉丝优惠价16元，" +
-                "但是优惠价和折扣不能同时使用。" +
-                "\n那么这个小伙要点这三样东西，最少要花多少钱？" +
-                "\n" +
-                "\n");
-        System.out.println("请输入要选择的订餐类型，选好之后输入订餐类型前的数字" +
-                "\n1、鱼香肉丝、油炸花生米、米饭各单点，使用订单满30元8折优惠" +
-                "\n2、鱼香肉丝使用优惠价，油炸花生米、米饭使用原价"+
-                "\n");
-        int fish = 24;
-        int peanut = 8;
-        int rice = 3;
-        int order = sc.nextInt();
-        if (order == 1) {
-            System.out.println("你选择了套餐1，如果消费金额满30元将享受8折优惠");
-            int price = (fish + peanut + rice);
-            if (price > 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/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/56 \350\265\265\346\225\217/20230328 java\345\244\215\344\271\240.md" "b/56 \350\265\265\346\225\217/20230328 java\345\244\215\344\271\240.md"
deleted file mode 100644
index 93ff37f231a8fc51578b20dbd6b6037e665cd418..0000000000000000000000000000000000000000
--- "a/56 \350\265\265\346\225\217/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/57 \351\273\204\346\265\201\346\266\233/20230328 java\345\244\215\344\271\240.md" "b/57 \351\273\204\346\265\201\346\266\233/20230328 java\345\244\215\344\271\240.md"
deleted file mode 100644
index 93ff37f231a8fc51578b20dbd6b6037e665cd418..0000000000000000000000000000000000000000
--- "a/57 \351\273\204\346\265\201\346\266\233/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+"这个数不为回文数");
-        }
-    }
-}
-```
-
-
-