学完了循环，我们应该能做点什么？

编程入门

1. 变量。保存数据，数据处理。
2. 运算。
   1. 算术（+ · - / %）
   2. 关系( > == )
   3. 逻辑（&& || )
   4. 赋值（= + = -）
3. 选择结构
   1. if else
   2. if elseif
   3. elseif else
4. 循环结构
   1. while
   2. for
   3. do ... while
   4. break

需要能解决的题目列表

1. 从键盘上输入一个年份，判断它是不是闰年？

object base09 {
  def main(args: Array[String]): Unit = {
    // 判断闰年
    /*
    1. 让用户输入一个整数，表示年份
    2. 判断这个年份是否是闰年
    3. 输出结果
    */
    val year: Int = scala.io.StdIn.readInt()
    // 2000 ===> 2000是闰年
    // 2024 ===> 2024是闰年
    // 2025 ===> 2025不是闰年
    // 1900 ===> 1900不是闰年

    // 如果你定义了一个变量，并且之后并不打算修改它的值，那么建议使用val
    var result: Boolean = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)

    if (result) {
      println(s"$year 是闰年")
    } else {
      println(s"$year 不是闰年")
    }
  }
}

2. s = 1 - 1/2 + 1/3 - 1/4 + 1/5 ... 1/19的值。

object base0801 {
  def main(args: Array[String]): Unit = {
    // 求 s = 1 - 1/2 + 1/3 - 1/4 + 1/5 ... + 1/19的值
    var sum:Double = 0
    var i = 1
    while (i<=19){
      if(i%2 == 1){
        sum = sum + 1.0 / i
      } else {
        sum = sum - 1.0 / i
      }
      i += 1
    }
    println(s"sum=${sum}")
  }
}

3. 从键盘上输入一个数，判断它是不是素数？

import scala.util.control.Breaks.{break, breakable}

object base0802 {
  def main(args: Array[String]): Unit = {
    /*
    判断质数。
    * 质数：只能被1 和它自己整除的数。
    * eg：2，3，5，7，11，13，17，19 ...... 97
    *
    * 思路：用 2 ~ (n-1) 依次去除这个数，如果能整除说明不是质数！
    * 例如：
    * n = 9
    * 1，2 不能整除
    * 2，3 能整除（不是质数）
    *
    * n = 35
    * 1，2 不能整除
    * 3，4 不能整除
    * 4，5 能整除（不是质数）
    *
    * n = 7 （2 ~ 6）
    * 1，2 不能整除
    * 2，3 不能整除
    * 3，4 不能整除
    * 4，5 不能整除
    * 5，6 不能整除
    */

    // breakable + break: 优化不是素数的情况：提前结束循环
    // Math.sqrt(n) : 减少搜索的范围
    val n = 97
    // 假设它是素数
    var isPrime = true
    breakable{
      for (i <- 2 to n - 1) {
        if (n % i == 0) { // 能整除,结束循环
          println(s"${i}能整出除")
          isPrime = false
          break
        }
        println(i)
      }
    }
    if (isPrime) {
      println(s"$n 是素数")
    } else {
      println(s"$n 不是素数")
    }
  }
}

4. 小球从 100 米高处自由落下，着地后又弹回高度的一半再次落下，如此重复。问经过多少次落地后，小球弹起的高度才会低于 0.5 米？

object base0803 {
  def main(args: Array[String]): Unit = {
    /**
     * 弹跳小球
     */
    var h: Double = 100
    var i = 0

    while (h >= 0.5) {
      i += 1
      h = h * 0.5
    }
    println(i, h)

    // for (i <- 1 to 10) {
    //   h = h * 0.5
    //   println(s"第${i}次落地，高度是 ${h}")
    // }
  }
}

5. 复利公式。题目描述：假设某人的年化投资回报率是 10%。也就是说投入 1 元之后：第一年结束时有 1.1 元，计算过程是：1 (1+10%) = 1.1 第二年结束时有 1.21 元，计算过程是：1.1 (1+10%) = 1.21 元，第三年结束时有 1.331 元，计算过程是：1.21*(1+10%) = 1.331 元，编写程序：1、求它第 10 年结束时有多少元？2、多少年之后能超过 1000 元？

object base0804 {
  def main(args: Array[String]): Unit = {
    var i = 0
    var money = 1.0
    /*
    while (i < 20){
      money = money * 1.1
      i = i + 1
    }
    println(s"第${i} 年结束时，有 ${money} 元")
*/
    while (money < 1000) {
      // while(i < 20){
      money = money * 1.8
      // i = i + 1
    }
    println(s"第${i} 年结束时，有 ${money} 元")
  }
}
  // 本金 1 ---- 能力增长 10% ------ 时间 73 ------- 1051
  // 本金 10 ---- 能力增长 10% ------ 时间 73 ------- 1051
  // 本金 1 ---- 能力增长 80% ------ 时间 12 ------- 1051

6. 百鸡百钱问题？

object base1004 {
  def main(args: Array[String]): Unit = {
    // 百鸡百钱
    /**
     * 设公鸡 x，母鸡 y 只，小鸡是 100 - x - y。
     * 同时 0 <= x <= 20, 0<=y<=33
     *
     * 5x + 3y + (100 - x - y) / 3 = 100  (1)
     *
     * 暴力求解
     * 1. (0,0,100) 代入（1）看看是否成立？
     * 2. (0,1, 99) 代入（1）看看是否成立？
     * ...
     * 34. (0,99,1) 代入（1）看看是否成立？
     */
    var k = 0
    for (x <-0 to 20){
      for (y <-0 to 33){
        val z = 100 - x - y
        //  代入（1）
        if (5*x + 3*y + z/3 == 100){
          k += 1
          println(k, x,y,z)
        }
      }
    }
  }
}

7. 乘法口诀表？

object base1003 {
  def main(args: Array[String]): Unit = {
    for(i <-1 to 9){
      for(j <-1 to 9){
       // printf(s"${j}×${i}=${i*j}\t")
        printf("%d×%d=%-4d", j, i, i*j)
      }
      /**
       * %d: 占位符，会输出一个整数
       * %-4d: 占位符，会输出一个整数，一共占据4个字符的空间大小，左对齐！
       * %4d: 占位符，会输出一个整数，一共占据4个字符的空间大小，右对齐！
       */
        println() // 换行
    }
  }
}