22.1.13 java每日作业

最新推荐文章于 2024-04-12 20:00:00 发布

在数据库中独自升级

最新推荐文章于 2024-04-12 20:00:00 发布

阅读量612

点赞数

分类专栏：每日作业文章标签： eclipse java

本文链接：https://blog.csdn.net/yinhaoooo/article/details/122485090

版权

每日作业专栏收录该内容

3 篇文章 1 订阅

订阅专栏

题目目录

1、通过Scanner 获取一个整数，然后使用while计算这个整数的阶乘

2、实现9*9的乘法表

3、有30人，可能包括男人、女人、小孩，他们在一饭店共消费50先令，其中每个男人花3先令，每个女人花2先令，每个小孩花1先令，求男人、女人、小孩各多少人？

4、提示：

5、

6、打印 1-100 之间的数，如果这个数是3或者5的倍数，就忽略掉

7、水仙花数：

8、冒泡排序

9、选择排序

10、折半查找（二分查找法）【前提数组要正序排序】

11、1 2 3 4 5 6 7---》7654321 （折半逆转）

12、女朋友说（递推）

13、百鸡百钱：实现一百块买一百只鸡，公鸡1只5块钱，母鸡1只3块钱，小鸡3只一块钱

14、假设你月收入是6000，除开平时花销，每个月留下2000块钱进行投资。

1、通过Scanner 获取一个整数，然后使用while计算这个整数的阶乘

N的阶乘等于 N* (N-1) * (N-2) * ... * 1

3==》1*2*3

3==》3*2*1

需要使用经历多少次循环？

代码：

package com.day0113;

import java.util.Scanner;

public class Test1 {

	public static void main(String[] args) {
		// 通过Scanner 获取一个整数，然后使用while计算这个整数的阶乘
		// N的阶乘等于 N* (N-1) * (N-2) * ... * 1
		Scanner sc = new Scanner(System.in);
		// 获取一个数值
		int n = sc.nextInt();
		System.out.print(n);
		// 定义一个结果
		int result = n;
		// 循环进行乘积  5*4*3*2*1
		while(n>1) {
			//迭代
			n--;
			//求取乘积
			result = result*n;
		}
		//打印输出结果
		System.out.println("的阶乘结果为："+result);
	}

}

2、实现9*9的乘法表

1*1=1

2*1=2 2*2=2

3*1=3 3*2=6 3*3=9

4*1=4 4*2=8 4*3=12 4*4=16

9行数据每一个行对应有n列数据？

第一个循环遍历9行数据（外循环）

第二循环遍历每一行的n列数据（内循环）

代码：

package com.day0113;

public class Test2 {

	public static void main(String[] args) {
		// 9*9的乘法表
		//外循环：遍历9次--相当于打印每一行的乘法表
		for(int n=1;n<=9;n++) {
			//内循环：遍历n次--打印当前行的n个乘法表式
			for(int i=1;i<=n;i++) {
				//格式化输出
				System.out.printf("%d*%d=%d \t",i,n,(i*n));
			}
			//换行
			System.out.println();
		}
	}

}

3、有30人，可能包括男人、女人、小孩，他们在一饭店共消费50先令，其中每个男人花3先令，每个女人花2先令，每个小孩花1先令，求男人、女人、小孩各多少人？

4、提示：

System.out.print("*");//输出星号不换行

System.out.println();//换行

System.out.print(" ");//输出空格

6* --1

5*** --3

4***** --5

3******* --7

2********* --9

1*********** --11

0************* --13

规律：

每一行的星号：2*n-1;

每一行的空格：总行数-当前行的序号

总行数为7

5、

6* --1

5*** --3

4***** --5

3******* --7

2********* --9

1*********** --11

0************* --13

***********

*********

*******

*****

***

分析：已经完成上半部分，只需要添加下半部分

6、打印 1-100 之间的数，如果这个数是3或者5的倍数，就忽略掉

代码：

package com.day0113;

public class ForControllerTest {

	public static void main(String[] args) {
		//打印 1-100 之间的数，如果这个数是3或者5的倍数，就忽略掉
		for(int i=1;i<=100;i++) {
			if(i%3==0||i%5==0) {
				continue;
			}
			System.out.print(i+"\t");
		}
		System.out.println();
		
	}

}

7、水仙花数*

寻找所有的水仙花数一定是3位数(100~999)每一位的立方，加起来恰好是这个数本身，比如153=1*1*1+5*5*5+3*3*3 当前数= 百位^3+十位^3+个位^3

代码：

package com.day0113;

public class ForControllerTest {

	public static void main(String[] args) {
		//水仙花数定义：寻找所有的水仙花数
		for(int i=100;i<=999;i++) {
			//求取百十个的数值
			int bai = i/100;
			int shi = (i/10)%10;
			int ge = i%10;
			//计算并且判断是否满足条件
			if((bai*bai*bai+shi*shi*shi+ge*ge*ge)==i) {
				System.out.println(i);
			}
		}
	}

}

8、冒泡排序*

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

代码：

package com.day0113;

import java.util.Arrays;

public class ArrayDemo1 {

	public static void main(String[] args) {
		// 创建数组对象会默认初始化 引用类型默认为null
		/*
		 * int[] arr = new int[6]; for (int i : arr) { System.out.println(i); }
		 */

		// 每次操作后，确定一位【冒一次泡】
		int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };
		// 没确定一位之后，下一次操作的比较次数减少一次
		// 具体要操作多少次？（n-1）；每次操作要比较多少轮(n-i)？
		// 具体要操作多少次？（n-1
		for (int n = 0; n < arr.length - 1; n++) {// 0~6
			// 每次操作要比较多少轮(n-i)？
			for (int i = 0; i < arr.length - n - 1; i++) {// 0~6
				// 当前面的大于后面的则需要交换
				if (arr[i] > arr[i + 1]) {
					int item = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = item;
				}
			}
		}

		//遍历
		for (int i : arr) {
			System.out.println(i);
		}
	}

}

9、选择排序*

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

1-2 1-3 1-4 ....

2-3~7

3-4~7

代码：

package com.day0113;

import java.util.Arrays;

public class ArrayDemo1 {

	public static void main(String[] args) {
		// 创建数组对象会默认初始化 引用类型默认为null
		/*
		 * int[] arr = new int[6]; for (int i : arr) { System.out.println(i); }
		 */
		
		//选择排序  		
		//时间复杂度 O(N)
		//定义一个索引，用于保存当前最小的数值的位置
		int index = 0;
		for (int n = 0; n < arr.length - 1; n++) {// 0~6  起始位置
			//初始化起始位置的索引
			index = n;
			// 每次操作要比较多少轮(n-i)？[内循环作为后面的遍历]   起始位置n和后面的比较
			for (int i = n+1; i < arr.length; i++) {// 1~7 2~7 3~7
				// 当后面的小于index位置的数值则将该索引赋值给index
				if (arr[i] < arr[index]) {
					index = i;
				}
			}
			//交换：把最小的和起始位置的数值进行交换
			int item = arr[n];
			arr[n] = arr[index];
			arr[index] = item;
		}
		//时间复杂度 O(N^2)
		for (int n = 0; n < arr.length - 1; n++) {// 0~6  起始位置
			// 每次操作要比较多少轮(n-i)？[内循环作为后面的遍历]   起始位置n和后面的比较
			for (int i = n+1; i < arr.length; i++) {// 1~7 2~7 3~7
				// 当起始位置大于后面的则需要交换
				if (arr[n] > arr[i]) {
					int item = arr[i];
					arr[i] = arr[n];
					arr[n] = item;
				}
			}
		}
		//遍历
		for (int i : arr) {
			System.out.println(i);
		}
	}

}

10、折半查找（二分查找法）【前提数组要正序排序】*

[1, 5, 43, 45, 64, 65,99, 101, 978] key值99

ps:

1.先从数组中间开始找，如果查找的数>中间值，则在后面找；如果查找的数

2.如果第一次找不到，则二分从后面（前面）的中间继续找，直到起始位置>结束位置就退出循环

代码：

package day0113;

import java.util.Arrays;

public class Arraydemo3 {

	public static void main(String[] args) {
		int[] arr= {1, 5, 43, 45, 64, 65,99, 101, 978};
		//使用工具类进行排序
		Arrays.sort(arr);
		//实现二分查询逻辑操作
		int key =99;
		//中间值索引
		int index =0;
		//查询范围
		int start =0;
		int end =arr.length;
		//设置一个标志位：
		boolean isFind = false;
		//循环
		while(start<=end) { 
			//计算中间索引
			index =(end+start)/2;
			//进行判断操作[==、>、<]
			if(key==arr[index]) {
				System.out.println("找到目标索引为："+index);
				//结束
				isFind=true;
				break;
			}else if(arr[index]>key) {
				end=index-1;
			}else {
				start=index+1;
			}
		}
		if(!isFind) {
			System.out.println("没有找到索引");
		}	
	}

}

11、1 2 3 4 5 6 7---》7654321 （折半逆转）

- -折半逆转（反转数组顺序）

代码：

package day0113;

import java.util.Arrays;

public class Homeword1 {

	public static void main(String[] args) {
		// 1 2 3 4 5 6 7---》7654321
		// - -折半逆转（反转数组顺序）
		int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
		// 操作次数
		int num = arr.length / 2;
		// 交换操作:1和7换，2和6换，3和5换
		for (int i = 0; i <= num; i++) {
			int item = arr[i];
			arr[i] = arr[arr.length - i - 1];// 先第一个数和最后一个换。
			arr[arr.length - i - 1] = item;
		}
		System.out.println(Arrays.toString(arr));

	}

}

12、女朋友说（递推）

第一天给我1分钱

第二天给我2分钱

第三天给我4分钱

第四天给我8分钱

以此类推：给够一个月【30天】，我就嫁给你，不然就不要你了。【请计算总共需要多少钱】

代码：

package day0113;

public class Homeword2 {

	public static void main(String[] args) {
		// 女朋友说
		// 第一天给我1分钱
		// 第二天给我2分钱
		// 第三天给我4分钱
		// 第四天给我8分钱
		// 以此类推：给够一个月【30天】，我就嫁给你，不然就不要你了。【请计算总共需要多少钱】
		int num = 1;
		int n = 0;
		// 一共循环30次
		for (int i = 1; i <= 30; i++) {
			n += num;// 每天总钱数
			num *= 2;// 每天金额乘2
			System.out.println("第" + i + "天");
		}
		System.out.println("总共" + n + "分钱，我要嫁给你！");
	}

}

13、百鸡百钱：实现一百块买一百只鸡，公鸡1只5块钱，母鸡1只3块钱，小鸡3只一块钱

提示：使用for循环嵌套

成立的条件：价格总额为100.并且数目总数为100

分析：100块钱能最多能买20只公鸡

100块钱能最多能买33只母鸡

100块钱能最多能买100只小鸡

代码：

package day0113;

public class Homeword3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 外循环 设置100最多能买20只公鸡，就20轮以内
		for (int i = 1; i <= 20; i++) {
			// 内循环 设置100最多能买33只母鸡，就33轮以内
			for (int j = 1; j <= 33; j++) {
				// 设置条件同时满足 1.100只总数减去母鸡和公鸡余小鸡个数和
				// 2.三种鸡总价等于100的条件
				if ((100 - i - j) % 3 == 0 && 5 * i + 3 * j + (100 - i - j) / 3 == 100) {
					System.out.println("公鸡" + i + "只，母鸡" + j + "只，小鸡" + (100 - i - j) + "只。");
				}

			}
		}
	}

}

14、假设你月收入是6000，除开平时花销，每个月留下2000块钱进行投资。

假设达到了每年20%的投资回报率。以每个月投资2000块钱的节奏，持续投资多少年，总收入才能达到100万（复利计算按照每年24000投入计算，不按照每月计息）

复利公式：F = p* ( (1+r)^n );

F 今年的最终收入

p 本金

r 年利率

n 存了多少年

计算总的收入==>之前的收入+（今年的存款*复利）

第一年 24000 ==》 24000*（（1+0.2）^1）= 28800

第二年 28800+24000*（1.2）^2 = 63360

第三年 63360+24000（（1+0.2）^3）=104832

举例：

1.2^2

Math.pow(1.2,2);

代码：

package day0113;

public class Homeword4 {

	public static void main(String[] args) {
		// 每年本金数
		int n = 24000;
		// 利率
		double r = 1.2;
		// 年份
		int year = 1;
		// 总收入
		double num = 0;
		// 判定条件为真
		while (true) {
			// 计算每年利润加本金
			num = num + (n * Math.pow(r, year));
			System.out.printf("第%d年时总收入：%f \n", year, num);
			// 当金额大于1000000时 输出年份
			if (num >= 1000000) {
				System.out.printf("第%d年时达到100W", year);
				break;
			}
			// 年份自增
			year++;
		}

	}

}