【蓝桥杯日记】复盘篇三——循环结构

 前言

   本篇内容是对循环结构进行复盘的，循环可谓是在基础阶段特别重要的东西，是三大结构（顺序结构、选择结构、循环结构）中最重要的结构之一。

目录

🍑1.找最小值

分析：

知识点：

代码如下

🍊2.打分

分析：

知识点：

代码如下

🍎3.质数口袋

分析：

知识点：

代码如下

🍅4.阶乘之和

分析：

知识点：

代码如下

总结

---

🍑1.找最小值

题目描述

给出 n 和 n 个整数，求这 n 个整数中最小值是什么。

输入格式

第一行输入一个正整数 n，表示数字个数。

第二行输入 n 个非负整数，表示 a1​,a2​…an​，以空格隔开。

输出格式

输出一个非负整数，表示这 n 个非负整数中的最小值。

输入输出样例

输入 #1

8
1 9 2 6 0 8 1 7

输出 #1

0

说明/提示

数据保证，n≤100 且 0≤an≤1000。

分析：

1. 使用数组来接收输入的n个值。
2. 设置一个最小值min=0,由于题目说的是输入的是非负整数，故是等于0的。
3. 执行n次循环每次判断数组中的数值是否比min中的数值小，如果小于则对min中的数值进行替换。
4. 最后输入min中的数值

知识点：

• 使用数组对大量相同类型的数值进行存储。

代码如下

   Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int arr[]=new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=sc.nextInt();
        }
//        求最小值
        int min=0;
        for (int i=1;i<arr.length;i++){
            if(arr[min]>arr[i])
                min=i;
        }
        System.out.println(arr[min]);

🍊2.打分

题目描述

现在有n(n≤1000) 位评委给选手打分，分值从 0到 10。需要去掉一个最高分，去掉一个最低分（如果有多个最高或者最低分，也只需要去掉一个），剩下的评分的平均数就是这位选手的得分。现在输入评委人数和他们的打分，请输出选手的最后得分，精确到 2 位小数。

输入格式

第一行输入一个正整数 n，表示有 n 个评委。

第二行输入 n 个正整数，第 i 个正整数表示第 i 个评委打出的分值。

输出格式

输出一行一个两位小数，表示选手的最后得分。

输入输出样例

输入 #1

5
9 5 6 8 9

输出 #1

7.67

说明/提示

数据保证，3≤n≤1000，每个评委打出的分值为为 0到 10（含 0 与 10）之间的整数。

分析：

1. arr数组保存裁判的打分，使用sum进行对裁判的打分进行累加。
2. Arrays类的sort方法进行对数组中的内容进行从小到大的排序，这样直接取出最小值arr[0]和最大值arr[arr.length-1]。
3. 累加和sum减去最大值和最小值，除以评委的个数n减去2为最大值和最小值。
4. 使用字符串格式化函数String.format()进行保留小数位数，如果不明白字符串格式化语句可以去看一下复盘篇二。

知识点：

•   本题设计的知识点，之前的篇幅已经说过了。

代码如下

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int arr[]=new int[n];
        double sum=0;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = sc.nextInt();
            sum+=arr[i];
        }
        Arrays.sort(arr);
        System.out.println(String.format("%.2f",(sum-arr[0]-arr[arr.length-1])/(n-2)));
    }
}

🍎3.质数口袋

题目描述

小 A 有一个质数口袋，里面可以装各个质数。他从 2 开始，依次判断各个自然数是不是质数，如果是质数就会把这个数字装入口袋。

口袋的负载量就是口袋里的所有数字之和。

但是口袋的承重量有限，装的质数的和不能超过 L。给出 L，请问口袋里能装下几个质数？将这些质数从小往大输出，然后输出最多能装下的质数的个数，数字之间用换行隔开。

输入格式

一行一个正整数 L。

输出格式

将这些质数从小往大输出，然后输出最多能装下的质数个数，所有数字之间有一空行。

输入输出样例

输入 #1

100

输出 #1

2
3
5
7
11
13
17
19
23
9

输入 #2

5

输出 #2

2
3
2

输入 #3

11

输出 #3

2
3
5
3

说明/提示

数据保证，1≤L≤105。

分析：

1. 使用count进行基数，使用sum来进行记录当前素数的总数即本题中的质量。
2. 判断是否为素数，如果为素数则进行则进行累加且判断是否超出了质量，超出了质量则循环结束。

知识点：

• 素数的概念：是指在大于1的自然数中，除了1和它本身以外不再有其他因数的数。例如，2、3、5、7、11、13、17、19、23等都是素数。
• 我们可以使用枚举的方法来判断是否为素数，代码中的trial()函数就是用来判断素数的。偶数一定不为素数除了2，使用for循环进行判断是否能够被其他数值整除，如果可以则不是素数，反之则是。
• 我们只需要除到自身的平方根。

代码如下

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        装入的容量
        int n = sc.nextInt();
//        记录可以装入的个数
        int count = 0;
//        当前的累加和
        int sum = 0;
//        素数的初始值
        int i = 2;
        while (true) {
            if (trial(i)) {
                if (sum + i <= n) {
                    System.out.println(i);
//                  累加sum
                    sum += i;
//                  count累加
                    count++;
                } else {
                    break;
                }
            }
//            控制i的增加
            i++;
        }
        System.out.println(count);
    }

    //    判断素数
    static boolean trial(int x) {
        if (x % 2 == 0 && x != 2)
            return false;
        for (int i = 2; i <= Math.sqrt(x); i++) {
            if (x % i == 0)
                return false;
        }
        return true;
    }
}

🍅4.阶乘之和

题目描述

用高精度计算出 !S=1!+2!+3!+⋯+n!（n≤50）。

其中 ! 表示阶乘，定义为n!=n×(n−1)×(n−2)×⋯×1。例如5!=5×4×3×2×1=120。

输入格式

一个正整数 n。

输出格式

一个正整数 S，表示计算结果。

输入输出样例

输入 #1

3

输出 #1

9

说明/提示

【数据范围】

对于 100%的数据，1≤n≤50。

分析：

本题要求是求出n的阶乘，由于int型和long型无法满足题目给出的要求，如果贸然使用会出现溢出的情况。

我们就需要使用java中的高精度类型BigInteger类,进行阶乘的操作。

知识点：

BigInteger类常用的方法：

• abs() 返回一个BigInteger，它的值是此BigInteger的绝对值。
• add(BigInteger val) 返回值为 (this + val) 。
• compareTo(BigInteger val) 将此BigInteger与指定的BigInteger进行比较。 
• divide(BigInteger val) 返回值为 (this / val) 。 
• multiply(BigInteger val) 返回值为 (this * val) 。 
• modInverse(BigInteger m) 返回值为 (this  mod m) 。  
• subtract(BigInteger val) 返回值为 (this - val) 。 

 BigInteger类静态常量：

• ZERO BigInteger常数为零。
• ONE BigInteger常数一。
• TEN BigInteger常数十。

代码如下

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger sum=new BigInteger("0");
        int n=sc.nextInt();
        BigInteger result=new BigInteger("1");
        for (int i = 1; i <= n; i++) {
            result=result.multiply(new BigInteger(String.valueOf(i)));
            sum=sum.add(result);
        }
        System.out.println(sum);
    }

}

总结

 本篇的复习要点：

1.   for循环和while循环体的基本结构。
2.   素数的判断方法。
3.   高精度BigInteger类的使用。