(C卷,100分)- 测试用例执行计划（Java & JS & Python & C）

题目描述

某个产品当前迭代周期内有 N 个特性（F1,F2,……FN）需要进行覆盖测试，每个特性都被评估了对应的优先级，特性使用其 ID 作为下标进行标识。

设计了 M 个测试用例（T1,T2,……,TM），每个测试用例对应一个覆盖特性的集合，测试用例使用其 ID 作为下标进行标识，测试用例的优先级定义为其覆盖的特性的优先级之和。

在开展测试之前，需要制定测试用例的执行顺序，规则为：优先级大的用例先执行，如果存在优先级相同的用例，用例 ID 小的先执行。

输入描述

第一行输入为 N 和 M，

• N 表示特性的数量，0 < N ≤ 100
• M 表示测试用例的数量，0 < M ≤ 100

之后 N 行表示特性 ID=1 到特性 ID=N 的优先级，

再接下来 M 行表示测试用例 ID=1 到测试用例 ID=M 关联的特性的 ID 的列表。

输出描述

按照执行顺序（优先级从大到小）输出测试用例的 ID，每行一个ID。

测试用例覆盖的 ID 不重复。

用例

题目解析

简单的自定义排序问题。

JS算法源码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
  const [n, m] = (await readline()).split(" ").map(Number);

  const features = new Array(n + 1);
  for (let i = 1; i <= n; i++) {
    features[i] = parseInt(await readline());
  }

  const cases = [];
  for (let i = 1; i <= m; i++) {
    const priority = (await readline())
      .split(" ")
      .map((id) => features[id - 0]) // id-0是为了将字符串id转为数值id
      .reduce((a, b) => a + b);

    cases.push([priority, i]);
  }

  cases
    .sort((a, b) => (a[0] != b[0] ? b[0] - a[0] : a[1] - b[1]))
    .forEach(([_, id]) => console.log(id)); // forEach入参使用了数组解构语法
})();

Java算法源码

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

public class Main {
  static class TestCase {
    int id;
    int priority;

    public TestCase(int id, int priority) {
      this.id = id;
      this.priority = priority;
    }
  }

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

    int[] tmp = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
    int n = tmp[0];
    int m = tmp[1];

    int[] features = new int[n + 1];
    for (int i = 1; i <= n; i++) {
      features[i] = Integer.parseInt(sc.nextLine());
    }

    ArrayList<TestCase> cases = new ArrayList<>();

    for (int i = 1; i <= m; i++) {
      int priority =
          Arrays.stream(sc.nextLine().split(" "))
              .map(Integer::parseInt)
              .map(id -> features[id])
              .reduce(Integer::sum)
              .orElse(0);

      cases.add(new TestCase(i, priority));
    }

    cases.stream()
        .sorted((a, b) -> a.priority != b.priority ? b.priority - a.priority : a.id - b.id)
        .map(testcase -> testcase.id)
        .forEach(System.out::println);
  }
}

Python算法源码

# 输入获取
n, m = map(int, input().split())

features = [0] * (n + 1)
for i in range(1, n+1):
    features[i] = int(input())

cases = []
for i in range(1, m+1):
    priority = sum(map(lambda x: features[int(x)], input().split()))
    cases.append([priority, i])

cases.sort(key=lambda x: (-x[0], x[1]))

for _, idx in cases:
    print(idx)

C算法源码

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int priority;
    int id;
} TestCase;

TestCase *new_TestCase(int id) {
    TestCase *testcase = (TestCase *) malloc(sizeof(TestCase));
    testcase->priority = 0;
    testcase->id = id;
    return testcase;
}

int cmp(const void *a, const void *b) {
    TestCase *A = *((TestCase **) a);
    TestCase *B = *((TestCase **) b);
    return A->priority != B->priority ? B->priority - A->priority : A->id - B->id;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);

    int features[n + 1];
    for (int i = 1; i <= n; i++) {
        scanf("%d", &features[i]);
    }

    TestCase *cases[m];
    for (int i = 0; i < m; i++) {
        cases[i] = new_TestCase(i + 1);

        int feature_id;
        while (scanf("%d", &feature_id)) {
            cases[i]->priority += features[feature_id];
            if (getchar() != ' ') break;
        }
    }

    qsort(cases, m, sizeof(TestCase *), cmp);

    for (int i = 0; i < m; i++) {
        printf("%dn", cases[i]->id);
    }

    return 0;
}