for循环

循环结构 - 图1

找最小值

循环结构 - 图2

  • 头文件algorithm(算法)的max(),min(),和abs()
  • max() min()参数为两个,可以是整型或浮点型,返回最大值和最小值
  • 适用于个数不多的比较时
  • abs()返回绝对值,整数
  • math的fabs(),进行浮点数的取绝对值功能

    解法1:使用min()

  1. #include <algorithm>
  2. int n;
  3. cin << n;
  4. //int tmp = 2147483647;
  5. int tmp, minnum =2100000000;
  6. for(int i = 1; i <= n ; i++){
  7. cin << tmp;
  8. minnum = min(minnum , tmp)
  9. }
  10. cout << minnum;

解法2: 使用条件判断

  1. int n;
  2. cin << n;
  3. //int tmp = 2147483647;
  4. int tmp, minnum =2100000000;
  5. for(int i = 1; i <= n ; i++){
  6. cin << tmp;
  7. // 比较 最新输入的值是不是比当前最小值还小
  8. if(tmp < minnum){
  9. minnum = tmp;
  10. }
  11. }
  12. cout << minnum;

while循环

循环结构 - 图3

一尺之棰

循环结构 - 图4

注意,从第二天开始,所以定义days 默认为1;

  1. #include <iostream>
  2. using namespace std;
  3. int main() {
  4. int a;
  5. int days = 1;
  6. // a = 1
  7. cin >> a;
  8. while (a > 1) {
  9. days++;
  10. a = a / 2;
  11. cout << "days: " << days << " a: " << a << endl;
  12. }
  13. cout << days;
  14. }

多重循环

循环语句也能互相嵌套。如果需要循环的“大操作”中有好几个重复 的小操作,就可以进行循环嵌套。 如果超过一个语句,或者需要调整层级,则必须要大括号,建议 全部加上括号。

注意内层循环变量名不能和外层循环变量名冲突。

  1. for (;;) {
  2. for (;;) {
  3. for (;;) {
  4. // 内层循环体
  5. }
  6. }
  7. for (;;)
  8. while (...) {
  9. // 内层循环体
  10. }
  11. }

数字直角三角形

循环结构 - 图5

我们可以把这个任务分成两个层级

  1. 大任务:输出每一行。需要一个外层循环,其循环体就是输出 一行的内容。循环变量从 1 到 n (也可以 0 到 n-1)。
  2. 小任务:输出一行中的每一个数字。需要一个内层循环,用于 输出一行中的每一个数字。共需要打出 n 行,所当处理第 i 行时, 需要输出 n-i+1 个数字。

定义变量 cnt 来记录输出到那个数字

  1. #include <iostream>
  2. using namespace std;
  3. int main() {
  4. int cnt = 0, n;
  5. scanf("%d", &n);
  6. for(int i = 1; i <= n ; i++){
  7. for (int j = 0; j <= n -i ;j++){
  8. // ++ cnt;
  9. // cout << cnt ;
  10. printf("%02d",++cnt);
  11. // printf("%02d",cnt++);
  12. }
  13. cout << endl;
  14. }

求阶乘之和

long long n ; 有效值为 9 * 10^18 ;

例 4.7 (洛谷 P1009,有改动)

计算 S = 1! + 2! + 3! + ⋯ + n! (n ≤ 20) 的值,其中 i! 是指 i 的阶乘,即 i! = 1 × 2 × ⋯ × i 。

分析: 按计算器可发现, 20 的阶乘大约 2.4 × 1018,所以可以使用 long long 类型存下。

long long 是一种整数类型,可以放下 9 × 1018的数字,但是比 int 又大又慢。