package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// 需求：写一万次"我错了！"
// 方式1、使用CV大法
System.out.println("我错了！");
System.out.println("我错了！");
System.out.println("我错了！");
System.out.println("我错了！");
// ...
// 方式2、机械的重复的动作，很傻，考虑让计算机去做，引入了循环的概念
// 循环怎么理解？
// 循：按照一定的规律
// 环：闭合的圆，重复的
// 循环的形式：
/*
* 1、while循环
* 2、do...while循环
* 3、for循环
*/
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// while循环（当型循环）
/*
* while(条件) { ... }
* 当条件满足时，一直做某事，直到条件不满足为止
*
* while结构中的 { ... } 包含的内容称为循环体
*/
// 需求：打印显示"我错了！"这句话3遍
// 定义次数变量
int count = 0;
while (count < 3) {
// 做打印显示的事情
System.out.println("我错了！");
// 对次数进行统计（即做了一次打印显示，就让次数加1）
// count = count + 1;
// count += 1;
// count++;
++count;
System.out.println("当前为第" + count + "次");
}
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
// 需求：使用while循环输出10以内的奇数：1、3、5、7、9
int i = 1;
// 写法1、考虑连续的奇数之间的间隔为2
// while (i < 10) {
// System.out.println(i);
//// i = i + 2;
//// i += 2;
//
// // Invalid argument to operation ++/--
//// i++++;
//// (i++)++;
//
// // 非要使用自增
// i++;
// i++;
// }
// 写法2、考虑在while循环中使用自增，但是只对那些和2求余数为1的数字才显示出来
while (i < 10) {
// 结合选择结构
// 判断是否为和2求余数为1的数字
if (i % 2 == 1) {
System.out.println(i);
}
i++;
}
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 需求：计算从1+2+3+...+100的和
int i = 1;
int result = 0;
// 分步来看1+2+3+...+100这个加法算式
// result += 1;
// result += 2;
// // ...
// result += 100;
// 因为有一定的规律，且重复的在操作，所以考虑使用循环
while (i <= 100) {
System.out.println(i);
result += i;
// i每次加法操作后都要做一下自增
i++;
}
System.out.println("1+2+3+...+100的总和为：" + result);
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
// 需求：世界最高峰珠穆朗玛峰有8848米，现在有一张很大很大的纸，纸的厚度为0.001米，折叠多少次后可以超过珠峰的高度？
// 思路：纸每次折叠，厚度都会是上一次厚度的2倍
// 纸的初始厚度
int height = 1;
// 折叠次数
int count = 0;
while (height <= 8848000) {
// 纸每次折叠，厚度都会是上一次厚度的2倍
height = height * 2;
// 折叠一次，折叠次数加1
count++;
}
System.out.println("折叠了" + count + "次后，就会超过珠峰的高度");
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
// 需求：存折中现在有1000块钱，银行的年利息为3.5%，问在银行里放多少年后，连本带利能翻倍？
// 定义存折的金额
double cash = 1000.00;
// 定义目标金额
double total = cash * 2;
// 定义年数
int year = 0;
while (cash < total) {
// 本金和利息记为后一年的本金
cash = (1 + 0.035) * cash;
year++;
}
System.out.println("在银行里放" + year + "年后，连本带利能翻倍");
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// while循环的要点：条件放上头，控制里面走
int i = 1;
while (i < 5) {
i++; // 显示：2、3、4、5
System.out.println(i);
// i++; // 显示：1、2、3、4
}
// 循环编写时，特别要注意循（按照一定的规律）的规律的归纳总结，这是写好循环的关键
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 需求：统计100 ~ 999之间的水仙花数并计算有多少个？
// 规则：以三位数字为例，数字的值 = (百位上的数字 * 百位上的数字 * 百位上的数字)
// + (十位上的数字 * 十位上的数字 * 十位上的数字)
// + (个位上的数字 * 个位上的数字 * 个位上的数字)，则称为是一个水仙花数
// 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
// 定义数字变量并赋值
int number = 100;
// 定义统计个数用的变量
int count = 0;
while (number <= 999) {
// 关键点：如何获取百位上的数字、十位上的数字、个位上的数字？
// 个位上的数字
int i = number / 1 % 10;
// 十位上的数字
int j = number / 10 % 10;
// 百位上的数字
int k = number / 100 % 10;
// 根据上面的分析，得到通用的公式，注意求余的10表示的是十进制的含义
// 规则：以三位数字为例，数字的值 = (百位上的数字 * 百位上的数字 * 百位上的数字)
// + (十位上的数字 * 十位上的数字 * 十位上的数字)
// + (个位上的数字 * 个位上的数字 * 个位上的数字)，则称为是一个水仙花数
// 结合选择结构进行判定
if (number == i * i * i + j * j * j + k * k *k) {
System.out.println(number);
// 统计用的变量需要自增
count++;
}
// 统计的范围从100~999，所以数字需要自增
number++;
}
System.out.println("【100~999】之间的水仙花数有：" + count + "个");
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 需求：大蜀山上有一段台阶，级数不知道，但是知道如果两个台阶一起跨，还剩1个台阶；
// 如果三个台阶一起跨，还剩2个台阶；如果四个台阶一起跨，还剩3个台阶；
// 如果五个台阶一起跨，还剩4个台阶；如果六个台阶一起跨，还剩5个台阶；
// 如果七个台阶一起跨，一个台阶都不剩。
// 问：这段台阶最少有多少级？
// 定义台阶变量
int step = 1;
// 思路：运用穷举思想，一个数字一个数字的来尝试是否满足规则
// 写法1、当台阶数不满足规则的，需要做自增；当找到第1个满足规则的台阶数时，就是最少的满足规则的台阶级数，不用自增了
// while (!((step % 2 == 1) && (step % 3 == 2) && (step % 4 == 3) && (step % 5 == 4) && (step % 6 == 5) && (step % 7 == 0))) {
// step++;
// }
//
// System.out.println("这段台阶最少有" + step + "级");
// 写法2、构造一个死循环，不断的做自增，在循环体中判断是否满足规则，当找到第1个满足规则的数字时，终止循环跳出
// while死循环的结构
// while (true) {
// System.out.println("死循环了么？");
// }
boolean flag = true;
while (flag) {
// 对台阶级数进行规则判断
if ((step % 2 == 1) && (step % 3 == 2) && (step % 4 == 3) && (step % 5 == 4) && (step % 6 == 5) && (step % 7 == 0)) {
System.out.println("这段台阶最少有" + step + "级");
flag = false;
}
step++;
}
}
}
package cn.temptation;
public class Sample10 {
public static void main(String[] args) {
// 需求：百钱百鸡问题：母鸡一只5元，公鸡一只3元，小鸡三只1元，有100元，如何买到100只鸡？母鸡多少只？公鸡多少只？小鸡多少只？（母鸡、公鸡、小鸡都有）
// 思路：
// 从需求中得到一些等式
// 母鸡数量 + 公鸡数量 + 小鸡数量 = 100
// 母鸡单价 * 母鸡数量 + 公鸡单价 * 公鸡数量 + 小鸡单价 * 小鸡数量 = 100
// 小鸡数量是3的倍数
// 运用"穷举法"
// 如果买1只母鸡，再买1只公鸡，还能买多少只小鸡
// 如果买1只母鸡，再买2只公鸡，还能买多少只小鸡
// ...
// 如果买2只母鸡，再买1只公鸡，还能买多少只小鸡
// 如果买2只母鸡，再买2只公鸡，还能买多少只小鸡
// ...
// 母鸡数量
int i = 0;
// 公鸡数量
int j = 0;
// 小鸡数量
int k = 0;
System.out.println("计算百钱百鸡问题的结果：");
// while循环的嵌套
// 注意：使用while循环的嵌套时，格外要注意内层while循环的循环条件；同时也要考虑到while循环的执行效率
// 下句语句其实效率不高，可以改进
// while (i < 100) { // 统计买母鸡的只数
while (i < 20) { // 统计买母鸡的只数
// 注意：必须在后一次的内层循环之前，把变量j的值重新赋值一下，否则这个变量j的值还是上一次内层循环结束时得到的那个值
j = 0;
// 下句语句其实效率不高，可以改进
// while (j < 100) { // 统计买公鸡的只数
while (j < 33) { // 统计买公鸡的只数
// 可以根据母鸡数量 和 公鸡数量 就可以得到小鸡数量
k = 100 - i - j;
// 根据思路分析中列出的等式
if ((5 * i + 3 * j + k / 3 == 100) && (k % 3 == 0) && (i != 0) && (j != 0) && (k != 0)) {
System.out.println("母鸡为：" + i + "只，公鸡为：" + j + "只，小鸡为：" + k + "只");
}
j++;
}
i++;
}
}
}
package cn.temptation;
public class Sample11 {
public static void main(String[] args) {
// do...while循环（直到型循环）
// 格式：
// do {
// System.out.println("直到型循环");
// } while (condition);
int i = 1;
// do {
// System.out.println(i);
// i++;
// } while (i < 4);
// while循环 和 do...while循环的区别：
// 1、可以设置断点，结合调试分析
// while循环的条件写在最上面，一上来就先判断条件是否满足，满足了才会进入循环体执行语句
// do...while循环的条件写在最后，一上来就先进入循环体并执行循环体中的语句，再判断循环条件是否满足，满足的话继续循环
// 注意：do...while循环在相同的条件（condition）不成立的情况下会比while循环多执行一次
// 2、while结构就是一个语句块；do...while结构后必须要有一个分号，否则就产生语法错误
// do...while循环在相同的条件（condition）成立的情况下和while循环的执行次数相同
while (i < 3) {
System.out.println(i);
i++;
}
do {
System.out.println(i);
i++;
} while (i < 3);
// do...while循环在相同的条件（condition）不成立的情况下会比while循环多执行一次
while (i < 1) {
System.out.println(i);
i++;
}
do {
System.out.println(i);
i++;
} while (i < 1);
}
}
package cn.temptation;
public class Sample12 {
public static void main(String[] args) {
// 需求：使用do...while循环输出1~100之间的数字
// 需求：使用do...while循环计算1+2+...+100和
int i = 1;
do {
System.out.println(i);
i++;
} while (i <= 100);
// 因为此时i == 101，所以需要把i进行重置
i = 1;
int sum = 0;
do {
sum += i;
i++;
} while (i <= 100);
System.out.println("1+2+...+100=" + sum);
}
}
package cn.temptation;
public class Sample13 {
public static void main(String[] args) {
// 需求：使用do...while循环列出1~100之间所有的奇数
int i = 1;
// 写法1、奇数的间隔为2
// do {
// System.out.println(i);
// i += 2;
// } while (i <= 100);
// 写法2、奇数是和2求余数为1的数字
do {
if (i % 2 == 1) {
System.out.println(i);
}
i++;
} while (i <= 100);
}
}