11.22 JS基础5
- 嵌套循环应用
- 一系列经典问题
打印九九乘法表
<script>
for (let i = 1; i <= 9; i++) {//i控制内层乘数 3*5=15 3为外层被乘数 5为内层乘数 被乘数一般放在算式的前面
for (let j = 1; j <= i; j++) {//j控制外层被乘数 进入内循环每次从1开始，比i小，按照图表显示当放在算式的前面
//页面上打印
document.write(j + "*" + i + "=" + (j * i) + " ");
}
//内循环结束 打印 "<br>"
document.write("<br/>")
}
document.write("<br/>");
//打印倒的九九乘法表
for (let i = 9; i >= 1; i--) {
for (let j = 1; j <= i; j++) {
document.write(j + "*" + i + "=" + (j * i) + " ");
}
document.write("<br/>");
}
//控制台打印九九乘法表 用空串拼接
for (let i = 1; i <= 9; i++) {
let s = '';
for (let j = 1; j <= i; j++) {
s += j + '*' + i + '=' + (i * j) + '\t';
}
console.log(s);
}
</script>
百钱买百鸡问题
我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
分析：
如果100元全部用来买公鸡，则最多能买20只；如果全部用来买母鸡，则最多能买33只；如果全买小鸡，则最多能买300只，不过题目要求最多只能买100只。。
用一个循环来控制公鸡的数量;从0开始,到20结束。
在公鸡确定情况下，母鸡应该从0开始，到33结束。
公鸡和母鸡都确定的情况下，小鸡有100-公鸡-母鸡
计算价格 公鸡*5 + 母鸡*3 +小鸡*1/3 == 100 。
不过，考虑到小鸡三只一钱，一只三分之一钱不好计算，所以干脆化为整数计算比较方便。
<script>
//用一个循环来控制公鸡的数量;从0开始,到20结束.
for (let i = 0; i <= 20; i++) {
//母鸡数量
for (let j = 0; j <= 33; j++) {
//公鸡数量为i 母鸡数量为j
let k = 100 - i - j;//k为小鸡数量
//判断钱
if (3 * 5 * i + 3 * 3 * j + 1 / 3 * 3 * k == 300) {//小鸡三只1钱，一只三分之一钱不好计算，故两边都乘以3，方便计算
//满足 百钱
document.write("鸡翁:" + i + " , 鸡母: " + j + ", 鸡雏: " + k + "<br/>");
}
}
}
</script>类似的问题：已知有三种人民币,分别为1元、2元、5元。求100元可以有多少种换成上述三种零钱的方法。
<script>
let count=0;
for (let i = 0; i <= 10; i++) {//1元
for (let j = 0; j <= 5; j++) {//2元
for (let k=0;k<=2;k++){//5元
if (i + 2 * j + 5 * k == 10) {
document.write("1元" + i + "张" + "，2元" + j + "张" + "，5元" + k + "张" + "<br/>");
}
}
}
}
</script>我采用的是三层循环，虽然可以达到目的，但是这样比较耗费时间。（Ps：如能达到目的，嵌套的循环数越少越好。）
<script>
//i表示5元的纸币的数量 ，最后一层循环省略了，但是多了一个判断. 2层循环
for (let i = 0; i <= 2; i++) {
//j2元的纸币的数量
for (let j = 0; j <= 5; j++) {
let k = 10 - i * 5 - j * 2;
//输出
if (i * 5 + j * 2 + k == 10 && k >= 0) {
document.write("5元 " + i + " 张; " + " 2元 " + j + " 张; " + "1元 " + k + " 张<br/>");
}
}
}
</script>老师的方法明显更便捷，10元减去5元和2元的钱数就是1元的钱数（张数）。
- 鸡兔同笼
鸡兔同笼问题的解法和前几题的解法很像，循环嵌套尽量少用。
<script>
for(let i=0;i<=35;i++){//鸡
let j=35-i;//兔
if(i*2+j*4==94){
document.write("鸡"+i+"只"+"，兔"+j+"只"+"<br/>");
}
}
</script>
- 嵌套求和1
实现 1+（1+2）+（1+2+3）+（1+2+3+4）+（1+2+3+4+5）
分析：一个字，拆，n+((n+(n+1))+ (n+(n+1)+(n+2))…
<script>
//最终结果
let s = 0;
//外侧再来一个循环，从1到5
for (let n = 1; n <= 5; n++) {//要记得外层循环第5次时，内层循环要循环5次
//sum每个内循环累加得到和
let sum = 0;
for (let j = 1; j <= n; j++) {
sum = sum + j;
}
s += sum;//备注 s=s+sum;
//console.log(sum);
}
console.log("结果是" + s);
</script>
- 嵌套求和2
实现1!+2!+3!+4!+5!; 5!=5*4*3*2*1
//实现1!+2!+3!+4!+5!; 5!=5*4*3*2*1 n*=(n+1)
let s1 = 0;
for (let n = 5; n >= 1; n--) { //3
let sum = 1;
for (let j = 1; j <= n; j++) { //1*2*3
sum = sum*j;//1*1 1*2 1*2*3
}
s1 += sum;
}
console.log("结果是"+s1);
- 代码优化
<script>
//getTime 返回 1970 年 1 月 1 日至今的毫秒数。
let start = new Date().getTime();
//1. 外循环执行 1000次
for (let i = 0; i < 1000; i++){
//2. 内循环 执行100次
for (let j = 0; j < 100; j++){
//3 内2循环执行了10次
for (let k = 0; k < 10; k++)
{
//计算...
let s = i + j + k; //1000 * 100 * 10 = 100w次
}
}
}
let end = new Date().getTime();
console.log("end - start : "+(end - start)); //毫秒
console.log("***********************************");
start = new Date().getTime();
//1. 外循环执行 10次
for (let i = 0; i < 10; i++){
//2. 内循环 执行100次
for (let j = 0; j < 100; j++){
//3 内2循环执行了100次
for (let k = 0; k < 1000; k++)
{
//计算...
let s = i + j + k; //1000 * 100 * 10 = 100w次
}
}
}
end = new Date().getTime();
console.log("end - start : "+(end - start)); //毫秒
</script>这两组循环次数一样，但是他们的外层循环与内层循环都不一样，效率也不同。如果循环体内没有什么业务操作，也不做控制台输出，二者确实不太好比较。
在循环体中加上console.log()控制台输出，效率孰高孰低就明显很多了。
<script>
//从二者比较情况来看，如果在循环次数不变的情况下，我们的循环次数小的放在外层，次数多的放在内层
//循环执行的效率会高一些。js,java
//getTime 返回 1970 年 1 月 1 日至今的毫秒数。
let start = new Date().getTime();
//1. 外循环执行 1000次
//2. 内循环 执行100次
for (let j = 0; j < 100; j++){
//3 内2循环执行了10次
for (let k = 0; k < 10; k++)
{
//计算...
let s = j + k; //100 * 10 = 1000次
console.log("");
}
}
let end = new Date().getTime();
console.log("end - start : "+(end - start)); //毫秒
console.log("***********************************");
start = new Date().getTime();
//1. 外循环执行 10次
for (let j = 0; j < 10; j++){
//3 内2循环执行了100次
for (let k = 0; k < 100; k++)
{
//计算...
let s = j + k; //100 * 10 = 1000次
console.log("");
}
}
end = new Date().getTime();
console.log("end - start : "+(end - start)); //毫秒
</script>总结：从二者比较情况来看，如果在循环次数不变的情况下，将循环次数少的放在外层，次数多的放在内层，循环执行的效率会高一些。不仅在JS里是这样，在Java里也是如此。
备注：如何计算循环效率？在循环前加上
let start = new Date().getTime();以便设立循环的起始点，然后在循环的后面加上
let end = new Date().getTime();作为结束点，用end减去start得到的值就是执行循环所用的毫秒数，以判断循环的效率。
console.log("end - start : "+(end - start)); //毫秒
- 常见对象
- 数组
数组的创建方式（4种）：
1. 最简单的方式，直接赋值
let arr1=[1,2,3]; arr1为数组名
2. new Array() 不指定长度和内容
3. new Array(size) 指定长度，size 是期望的数组元素个数。
4. new Array(element0, element1, element2) 指定初始元素数量，长度也由此确定了（Ps：JS中数组的长度是可以改变的，而Java中数组的长度是不可改变的。）
<script>
//这就是数组 => 一组类型相同，内存是有序数集合.
//Array 对象用于在单个的变量中存储多个值
let arr01 = [1,2,3];
//如果不用数组 存储1 2 3
let a= 1,b= 2,c=3; //三个变量
//存储全班同学所有人的姓名
//定义20个变量？
let name1="艳辉",name2="浩东",name3="恒辉";
//如果换成数组
let arrayname = ["艳辉","浩东","恒辉"];
//1- 最简单的方式，直接赋值 ->arr02 数组名
let arr02 = [1,2,3,4,5,6];
console.log(arr02);
//输出数组元素的方法 ,使用数组下标[索引]
//下标的范围 从0开始，到数组长度-1结束
console.log(arr02[0])
console.log(arr02[5])
//超出索引范围则无法引用，数据为undefined
arr02[6] = 7;
//可以继续扩充
console.log(arr02[6])
// 2- new Array(); 不指定长度和内容
// 3- new Array(size); 指定长度
// 4- new Array(element0, element1, ..., elementn); 指定元素数量，同时长度也就确定了
let arr03 = new Array();
console.log(arr03.length)//打印数组长度 0
let arr04 = new Array(10);
console.log(arr04.length)//打印数组长度 10
let arr05 = new Array(1,2,4,6);
console.log(arr05.length)//打印数组长度 4
</script>常用的数组对象方法
|
concat() |
连接两个或更多的数组，并返回结果。 |
|
join() |
把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。 |
|
pop() |
删除并返回数组的最后一个元素 |
|
push() |
向数组的末尾添加一个或更多元素，并返回新的长度。 |
|
reverse() |
颠倒数组中元素的顺序。 |
|
sort() |
对数组的元素进行排序 |
<script>
//concat() 连接两个或更多的数组，并返回结果。
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let arr3 = arr1.concat(arr2);
console.log(arr3);//[1, 2, 3, 4, 5, 6]
// join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
let str = arr1.join(",,,");
console.log(str);// 1,,,2,,,3
// pop() 删除并返回数组的最后一个元素
arr1.pop(1);
console.log(arr1); //[1, 2]
console.log(arr1.length);//2 注意，这会改变数组的长度
// push() 向数组的末尾添加一个或更多元素，并返回新的长度。
arr2.push(7, 8, 9);
console.log(arr2);// [4, 5, 6, 7, 8, 9]
console.log(arr2.length); // 6
// reverse() 颠倒数组中元素的顺序。
arr2.reverse();
console.log(arr2);//[9, 8, 7, 6, 5, 4]
// sort() 对数组的元素进行排序
let arr4 = ["b", "a", "d"];
arr4.sort();
console.log(arr4);// ['a', 'b', 'd']
</script>感想：今天的不难，就是步骤可以再简化，要习惯用聪明点的办法。。
（Ps：基场今天表现还行，只是可惜明天大盘大概率又要开始跌，循环往复，如此就是a股。。）
17:45:56 2021-11-22
posted on 2021-11-22 17:45 heyiyang1312 阅读(3) 评论(0) 收藏 举报
浙公网安备 33010602011771号