(C卷,100分)- 开源项目热度榜单（Java & JS & Python & C）

题目描述

某个开源社区希望将最近热度比较高的开源项目出一个榜单，推荐给社区里面的开发者。

对于每个开源项目，开发者可以进行关注（watch）、收藏（star）、fork、提issue、提交合并请求（MR）等。

数据库里面统计了每个开源项目关注、收藏、fork、issue、MR的数量，开源项目的热度根据这5个维度的加权求和进行排序。

H = W(watch) x #watch + W(star) x #star + W(fork) x #fork + W(issue) x #issue + W(mr) x #mr

• H 表示热度值
• W(watch)、W(star)、W(fork)、W(issue)、W(mr) 分别表示5个统计维度的权重
• #watch、#star、#fork、#issue、#mr 分别表示5个统计维度的统计值

榜单按照热度值降序排序，对于热度值相等的，按照项目名字转换为全小写字母后的字典序排序（'a','b','c',…,'x','y','z'）。

输入描述

第一行输入为N，表示开源项目的个数，0 ＜ N ＜100。

第二行输入为权重值列表，一共 5 个整型值，分别对应关注、收藏、fork、issue、MR的权重，权重取值 0 < W ≤ 50。

第三行开始接下来的 N 行为开源项目的统计维度，每一行的格式为：

name nr_watch nr_start nr_fork nr_issue nr_mr

其中 name 为开源项目的名字，由英文字母组成，长度 ≤ 50，其余 5 个整型值分别为该开源项目关注、收藏、fork、issue、MR的数量，数量取值 0 < nr ≤ 1000。

输出描述

按照热度降序，输出开源项目的名字，对于热度值相等的，按照项目名字转换为全小写后的字典序排序（'a' > 'b' > 'c' > … > 'x' > 'y' > 'z'）。

用例

题目解析

简单的多条件排序题。

具体逻辑请看代码实现。

JavaScript算法源码

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

void (async function () {
  class Project {
    constructor(name, hot) {
      this.name = name;
      this.hot = hot;
    }
  }

  const n = parseInt(await readline());

  const weights = (await readline()).split(" ").map(Number);

  const projects = [];
  for (let i = 0; i < n; i++) {
    const tmp = (await readline()).split(" ");

    const name = tmp.shift();

    let hot = 0;
    tmp.map(Number);
    for (let j = 0; j < 5; j++) {
      hot += tmp[j] * weights[j];
    }

    projects.push(new Project(name, hot));
  }

  projects
    .sort((a, b) =>
      a.hot != b.hot ? b.hot - a.hot : strcmp(a.name.toLowerCase(), b.name.toLowerCase())
    )
    .forEach((p) => console.log(p.name));
})();

function strcmp(a, b) {
  if (a == b) {
    return 0;
  } else if (a > b) {
    return 1;
  } else {
    return -1;
  }
}

Java算法源码

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

public class Main {
  static class Project {
    String name;
    int hot;

    public Project(String name, int hot) {
      this.name = name;
      this.hot = hot;
    }
  }

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

    int n = sc.nextInt();

    int[] weights = new int[5];
    for (int i = 0; i < 5; i++) {
      weights[i] = sc.nextInt();
    }

    Project[] projects = new Project[n];

    for (int i = 0; i < n; i++) {
      String name = sc.next();

      int hot = 0;
      for (int j = 0; j < 5; j++) {
        hot += sc.nextInt() * weights[j];
      }

      projects[i] = new Project(name, hot);
    }

    Arrays.sort(
        projects,
        (a, b) ->
            a.hot != b.hot ? b.hot - a.hot : a.name.toLowerCase().compareTo(b.name.toLowerCase()));

    for (Project project : projects) {
      System.out.println(project.name);
    }
  }
}

Python算法源码

class Project:
    def __init__(self, name, hot):
        self.name = name
        self.hot = hot


# 输入获取
n = int(input())

weights = list(map(int, input().split()))

projects = []
for _ in range(n):
    tmp = input().split()

    name = tmp.pop(0)

    statistics = list(map(int, tmp))

    hot = 0
    for i in range(5):
        hot += statistics[i] * weights[i]

    projects.append(Project(name, hot))

projects.sort(key=lambda x: (-x.hot, x.name.lower()))

for p in projects:
    print(p.name)

C算法源码

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

#define MAX_NAME_LEN 51

typedef struct {
    char name[MAX_NAME_LEN];
    int hot;
} Project;

Project *new_Project(char *name, int hot) {
    Project *p = (Project *) malloc(sizeof(Project));
    strcpy(p->name, name);
    p->hot = hot;
    return p;
}

char *lower(char *s) {
    char *res = (char *) calloc(MAX_NAME_LEN, sizeof(char));
    strcpy(res, s);

    int diff = 'a' - 'A';

    int i = 0;
    while (res[i] != '') {
        if (res[i] >= 'A' && res[i] <= 'Z') {
            res[i] = (char) (res[i] + diff);
        }
        i++;
    }

    return res;
}

int cmp(const void *a, const void *b) {
    Project *A = *((Project **) a);
    Project *B = *((Project **) b);

    if (A->hot != B->hot) {
        return B->hot - A->hot;
    } else {
        return strcmp(lower(A->name), lower(B->name));
    }
}

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

    int weights[5];
    for (int i = 0; i < 5; i++) {
        scanf("%d", &weights[i]);
    }

    Project *ps[n];

    for (int i = 0; i < n; i++) {
        char name[MAX_NAME_LEN];
        scanf("%s", name);

        int hot = 0;
        for (int j = 0; j < 5; j++) {
            int val;
            scanf("%d", &val);

            hot += val * weights[j];
        }

        ps[i] = new_Project(name, hot);
    }

    qsort(ps, n, sizeof(Project *), cmp);

    for (int i = 0; i < n; i++) {
        puts(ps[i]->name);
    }

    return 0;
}