某测试实习岗位 笔试过程

近日测试实习岗位笔试 有若干个代码题目 个人认为值得深入学习，这里着重记录一下。

通过后台存的IDE看的一个题目 如下：

题目：

某人员获得若干笔记。一个合集可以由若干笔记构成。笔记包含两个属性：点赞数；评论数

定义优秀度：一个合集所有点赞数之和乘以评论数的最小值。

题目要求：

第一行为输入 n（笔记数），k（合集大小）

第二行输入n个正整数 ai，代表每个笔记点赞数

第三行输入n个正整数 bi，代表每个笔记评论数

最后结果：优秀度的最大值

解题思路：

在刚遇到本题的时候，略有一点懵，一开始是想通过建立两个链表接受点赞和评论数，再根据他的指针/角标进行计算，但是这个思路把这个题目想得过于简单了。首先合集是一个不定的数组大小限制，其次，一个取最大一个取最小，把我给绕晕了，后面仔细想想之后，最后得出这样一个分析结果：

例如：合集笔记：1 2 3 4

                  点赞：1 2 3 4

                  评论：1 2 3 4

则优秀度为：（1+2+3+4）*1=10

 这是对优秀度的理解

而我们运用封装的概念，将一个个合集封装起来，但是合集之间是有交叉笔记部分的，但是合集大小都是n

例如：总合集：合集1 合集2 合集3

           优秀度：1        2         3

则我们输出的则是合集三的优秀度

 经过简单的分析后可以得到：

我们需要对笔记按照某种方式排列，然后选择前k个。排序的依据可以是点赞数、评论数，或者他们组合。这里我们按照点赞数降序排列，点赞相同则按照评论数降序排列。然后我们再计算前k个笔记之和合集的优秀度即可。

代码实现:

以Java为例：

MaxRating.java:

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

public class MaxRating {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取笔记数量和合集大小
        int n = scanner.nextInt();
        int k = scanner.nextInt();

        // 读取点赞数
        int[] likes = new int[n];
        for (int i = 0; i < n; i++) {
            likes[i] = scanner.nextInt();
        }

        // 读取评论数
        int[] comments = new int[n];
        for (int i = 0; i < n; i++) {
            comments[i] = scanner.nextInt();
        }

        // 创建笔记对象数组，以便利用自定义排序
        Note[] notes = new Note[n];
        for (int i = 0; i < n; i++) {
            notes[i] = new Note(likes[i], comments[i]);
        }

        // 按照点赞数降序排序，若点赞数相同则按评论数降序排序
        Arrays.sort(notes, Comparator.comparingInt(Note::getLikes).reversed()
                .thenComparingInt(Note::getComments).reversed());

        // 计算前k个笔记的点赞数之和
        long sumLikes = 0;
        for (int i = 0; i < k; i++) {
            sumLikes += notes[i].getLikes();
        }

        // 找到前k个笔记中评论数的最小值
        int minComments = notes[0].getComments();
        for (int i = 1; i < k; i++) {
            minComments = Math.min(minComments, notes[i].getComments());
        }

        // 计算最大优秀度
        long maxRating = sumLikes * minComments;

        // 输出最大优秀度
        System.out.println(maxRating);

        scanner.close();
    }

    // 定义一个简单的笔记类，用于存储点赞数和评论数
    static class Note {
        private int likes;
        private int comments;

        public Note(int likes, int comments) {
            this.likes = likes;
            this.comments = comments;
        }

        public int getLikes() {
            return likes;
        }

        public int getComments() {
            return comments;
        }
    }
}

代码解析:

供和我一样的编程小白学习使用,大佬看个热闹即可:

Arrays.sort(notes, Comparator.comparingInt(Note::getLikes).reversed()
                .thenComparingInt(Note::getComments).reversed());

解析:

这段代码是这段程序较为复杂的 这段Java使用Java8的流和Lambda来对notes这个数组进行排序. 

Comparator.comparingInt(Note::getLikes).reversed():

:对Note类对象 getlikes方法返回值 就是点赞数进行排序.reversed()为降序排序方法

thenComparingInt(Note::getComments):

若note中两个对象点赞相同,会根据评论数大小进行排序. thenComparingInt()方法为根据括号中排序,评论数越多则越在前面.