华为OD机试 - 智能成绩表（ Python C C++ JavaGo JS PHP）

news/2024/7/20 16:57:27 标签: 华为od, python, c语言, c++, java, 面经, 秋招

题目描述

小明是一名新老师，他需要将学生按考试总分或单科分数进行排名。学生的信息包括姓名、科目和对应的分数。帮助小明完成这个任务吧！

输入描述

  1. 第一行包含两个整数 n 和 m，分别代表学生人数和科目数量。

    • 0 < n < 100
    • 0 < m < 10

  2. 第二行包含 m 个科目名称，用空格隔开。

    • 科目名称只包含英文字母，长度不超过10个字符。
    • 科目的出现顺序和后续输入的学生成绩一一对应。
    • 不会出现重复的科目名称。

  3. 接下来的 n 行，每行包含一个学生的姓名和该生 m 个科目的成绩（用空格隔开）。

    • 学生不会重名。
    • 学生姓名只包含英文字母，长度不超过10个字符。
    • 成绩是0~100的整数，依次对应第二行输入的科目。

  4. 第 n+2 行输入用作排名的科目名称。如果科目不存在，则按总分进行排序。

输出描述

输出一行，按成绩排序后的学生名字，用空格隔开。如果成绩相同，则按学生姓名的字典顺序排序。

示例

在这里插入图片描述

题目解析

本题的核心在于动态排序规则的应用。排序规则可能基于特定科目的成绩，也可能基于总分。排序过程需要考虑两个因素：

  1. 排序规则：根据最后一行输入的科目名称确定。如果科目存在，则按该科目成绩排序；如果不存在，则按总分排序。

  2. 排序细节：在成绩相同的情况下，需要按学生姓名的字典顺序进行排序。

C++代码实现

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

// 学生信息结构体
struct Student {
    string name;
    vector<int> scores;
    int totalScore;
};

// 自定义比较函数，用于排序
bool compareStudents(const Student& a, const Student& b, int sortIndex) {
    // 如果排序索引指向总分，则比较总分
    if (sortIndex == -1) {
        return (a.totalScore < b.totalScore) || (a.totalScore == b.totalScore && a.name < b.name);
    }
    // 否则，比较指定科目的成绩
    return (a.scores[sortIndex] < b.scores[sortIndex]) || (a.scores[sortIndex] == b.scores[sortIndex] && a.name < b.name);
}

int main() {
    int n, m;
    cin >> n >> m;

    vector<string> subjects(m);
    for (int i = 0; i < m; ++i) {
        cin >> subjects[i];
    }

    vector<Student> students(n);
    for (int i = 0; i < n; ++i) {
        cin >> students[i].name;
        students[i].scores.resize(m);
        students[i].totalScore = 0;
        for (int j = 0; j < m; ++j) {
            cin >> students[i].scores[j];
            students[i].totalScore += students[i].scores[j];
        }
    }

    string sortSubject;
    cin >> sortSubject;

    // 确定排序索引，如果科目不存在，则索引为-1，表示按总分排序
    int sortIndex = -1;
    for (int i = 0; i < m; ++i) {
        if (subjects[i] == sortSubject) {
            sortIndex = i;
            break;
        }
    }

    // 根据排序索引进行排序
    sort(students.begin(), students.end(), [&](const Student& a, const Student& b) {
        return compareStudents(a, b, sortIndex);
    });

    // 输出排序后的学生名字
    for (const auto& student : students) {
        cout << student.name << " ";
    }
    cout << endl;

    return 0;
}

Java代码实现

java">import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n, m;
        n = scanner.nextInt();
        m = scanner.nextInt();

        Vector<String> subjects = new Vector<>();
        for (int i = 0; i < m; ++i) {
            subjects.add(scanner.next());
        }

        Student[] students = new Student[n];
        for (int i = 0; i < n; ++i) {
            students[i] = new Student();
            students[i].name = scanner.next();
            students[i].scores = new int[m];
            students[i].totalScore = 0;
            for (int j = 0; j < m; ++j) {
                students[i].scores[j] = scanner.nextInt();
                students[i].totalScore += students[i].scores[j];
            }
        }

        String sortSubject = scanner.next();

        int sortIndex = -1;
        for (int i = 0; i < m; ++i) {
            if (subjects.get(i).equals(sortSubject)) {
                sortIndex = i;
                break;
            }
        }

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student a, Student b) {
                return compareStudents(a, b, sortIndex);
            }
        });

        for (Student student : students) {
            System.out.print(student.name + " ");
        }
        System.out.println();
    }

    public static boolean compareStudents(Student a, Student b, int sortIndex) {
        // 如果排序索引指向总分，则比较总分
        if (sortIndex == -1) {
            return (a.totalScore < b.totalScore) || (a.totalScore == b.totalScore && a.name.compareTo(b.name) < 0);
        }
        // 否则，比较指定科目的成绩
        return (a.scores[sortIndex] < b.scores[sortIndex]) || (a.scores[sortIndex] == b.scores[sortIndex] && a.name.compareTo(b.name) < 0);
    }
}

Python代码实现

python">import sys
from collections import Counter
from typing import List

class Main:
    def main(self):
        n, m = map(int, input().split())
        subjects = list(map(str, input().split()))
        students = []
        for i in range(n):
            students.append({"name": input(), "scores": list(map(int, input().split())), "totalScore": sum(students[-1]["scores"])})
        sort_subject = input()
        sort_index = -1
        for i, subject in enumerate(subjects):
            if subject == sort_subject:
                sort_index = i
                break
        students.sort(key=lambda x: (-x["totalScore"], x["name"]) if sort_index == -1 else (-x["scores"][sort_index], x["name"]))
        for student in students:
            print(student["name"], end=" ")
        print()

if __name__ == "__main__":
    Main().main()

C代码实现

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

typedef struct {
    char name[20];
    int scores[100];
    int totalScore;
} Student;

int compare(const void *a, const void *b) {
    Student *students = (Student *)a;
    Student *other = (Student *)b;
    int sort_index = -1;
    for (int i = 0; i < students[0].scores[0]; i++) {
        if (strcmp(students[0].scores[i + 1], sort_subject) == 0) {
            sort_index = i + 1;
            break;
        }
    }
    if (sort_index == -1) {
        return (-students[0].totalScore == -other[0].totalScore) ? strcmp(students[0].name, other[0].name) : -1;
    } else {
        return (-students[0].scores[sort_index] == -other[0].scores[sort_index]) ? strcmp(students[0].name, other[0].name) : -1;
    }
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    char sort_subject[20];
    scanf("%s", sort_subject);
    Student students[n];
    for (int i = 0; i < n; i++) {
        scanf("%s", students[i].name);
        for (int j = 0; j < m; j++) {
            scanf("%d", &students[i].scores[j]);
        }
        students[i].totalScore = 0;
        for (int j = 0; j < m; j++) {
            students[i].totalScore += students[i].scores[j];
        }
    }
    qsort(students, n, sizeof(students[0]), compare);
    for (int i = 0; i < n; i++) {
        printf("%s", students[i].name);
        if (i < n - 1) {
            printf(" ");
        }
    }
    printf("\n");
    return 0;
}

Go代码实现

package main

import (
	"fmt"
	"io"
	"strings"
	"sort"
)

// 学生信息结构体
type Student struct {
	name  string
	scores []int
	totalScore int
}

// 自定义比较函数，用于排序
func compareStudents(a, b Student, sortIndex int) bool {
	// 如果排序索引指向总分，则比较总分
	if sortIndex == -1 {
		return (a.totalScore < b.totalScore) || (a.totalScore == b.totalScore && a.name < b.name)
	}
	// 否则，比较指定科目的成绩
	return (a.scores[sortIndex] < b.scores[sortIndex]) || (a.scores[sortIndex] == b.scores[sortIndex] && a.name < b.name)
}

func main() {
	var reader io.Reader
	reader = os.Stdin

	var n, m int
	fmt.Fscanf(reader, "%d %d", &n, &m)

	var subjects []string
	for i := 0; i < m; i++ {
		var subject string
		fmt.Fscanf(reader, "%s", &subject)
		subjects = append(subjects, subject)
	}

	students := make([]Student, n)
	for i := 0; i < n; i++ {
		var name string
		fmt.Fscanf(reader, "%s", &name)
		students[i].name = name
		students[i].scores = make([]int, m)
		students[i].totalScore = 0
		for j := 0; j < m; j++ {
			fmt.Fscanf(reader, "%d", &students[i].scores[j])
			students[i].totalScore += students[i].scores[j]
		}
	}

	var sortSubject string
	fmt.Fscanf(reader, "%s", &sortSubject)

	// 确定排序索引，如果科目不存在，则索引为-1，表示按总分排序
	sortIndex := -1
	for i, subject := range subjects {
		if subject == sortSubject {
			sortIndex = i
			break
		}
	}

	// 根据排序索引进行排序
	sort.Slice(students, func(i, j int) bool {
		return compareStudents(students[i], students[j], sortIndex)
	})

	// 输出排序后的学生名字
	for _, student := range students {
		fmt.Println(student.name)
	}
}

PHP代码实现

<?php
$n = 0;
$m = 0;
$subjects = [];
$students = [];
$sortSubject = '';

// 学生信息结构体
class Student {
    public $name;
    public $scores;
    public $totalScore;

    public function __construct($name, $scores, $totalScore) {
        $this->name = $name;
        $this->scores = $scores;
        $this->totalScore = $totalScore;
    }
}

// 自定义比较函数，用于排序
function compareStudents($a, $b, $sortIndex) {
    // 如果排序索引指向总分，则比较总分
    if ($sortIndex == -1) {
        return $a->totalScore < $b->totalScore || ($a->totalScore == $b->totalScore && $a->name < $b->name);
    }
    // 否则，比较指定科目的成绩
    return $a->scores[$sortIndex] < $b->scores[$sortIndex] || ($a->scores[$sortIndex] == $b->scores[$sortIndex] && $a->name < $b->name);
}

function main() {
    $stdin = STDIN;
    fscanf($stdin, "%d %d", $n, $m);

    for ($i = 0; $i < $m; ++$i) {
        fscanf($stdin, "%s", $subjects[$i]);
    }

    for ($i = 0; $i < $n; ++$i) {
        fscanf($stdin, "%s", $students[$i]->name);
        $students[$i]->scores = array_fill(0, $m, 0);
        $students[$i]->totalScore = 0;
        for ($j = 0; $j < $m; ++$j) {
            fscanf($stdin, "%d", $students[$i]->scores[$j]);
            $students[$i]->totalScore += $students[$i]->scores[$j];
        }
    }

    fscanf($stdin, "%s", $sortSubject);

    // 确定排序索引，如果科目不存在，则索引为-1，表示按总分排序
    $sortIndex = -1;
    for ($i = 0; $i < $m; ++$i) {
        if ($subjects[$i] == $sortSubject) {
            $sortIndex = $i;
            break;
        }
    }

    // 根据排序索引进行排序
    usort($students, function($a, $b) use ($sortIndex) {
        return compareStudents($a, $b, $sortIndex);
    });

    // 输出排序后的学生名字
    foreach ($students as $student) {
        echo $student->name . " ";
    }
    echo PHP_EOL;
}

main();

JS代码实现

javascript">const { Your_function } = require(‘Your_script’);

// 学生信息结构体
class Student {
    constructor(name, scores) {
        this.name = name;
        this.scores = scores;
        this.totalScore = this.calculateTotalScore();
    }

    calculateTotalScore() {
        let totalScore = 0;
        for (let score of this.scores) {
            totalScore += score;
        }
        return totalScore;
    }
}

// 自定义比较函数，用于排序
function compareStudents(a, b, sortIndex) {
    // 如果排序索引指向总分，则比较总分
    if (sortIndex === -1) {
        return (a.totalScore < b.totalScore) || (a.totalScore === b.totalScore && a.name < b.name);
    }
    // 否则，比较指定科目的成绩
    return (a.scores[sortIndex] < b.scores[sortIndex]) || (a.scores[sortIndex] === b.scores[sortIndex] && a.name < b.name);
}

async function main() {
    const [n, m] = await readLine();
    const subjects = await readLine().join('').split(' ');
    const students = await Promise.all(Array.from({ length: n }, async (_, i) => {
        const [name] = await readLine();
        const scores = await readLine().map(Number);
        return new Student(name, scores);
    }));

    const sortSubject = await readLine().join('');
    const sortIndex = subjects.indexOf(sortSubject);

    students.sort((a, b) => {
        return compareStudents(a, b, sortIndex);
    });

    console.log(students.map(student => student.name).join(' '));
}

main().catch(error => {
    console.error(error);
    process.exit(1);
});

http://www.niftyadmin.cn/n/5370514.html

相关文章

Linux内核与驱动面试经典“小”问题集锦（3）

Linux内核与驱动面试经典“小”问题集锦（3）

接前一篇文章&#xff1a;Linux内核与驱动面试经典“小”问题集锦&#xff08;2&#xff09; 问题4 问&#xff1a;既然spin_lock可以在进程上下文和中断上下文中使用&#xff0c;那么一旦进入中断&#xff0c;被自旋住&#xff0c;那么CPU岂不是被死锁住了&#xff1f; 备注…
阅读更多...
机器学习——有监督学习和无监督学习

机器学习——有监督学习和无监督学习

有监督学习 简单来说&#xff0c;就是人教会计算机学会做一件事。 给算法一个数据集&#xff0c;其中数据集中包含了正确答案&#xff0c;根据这个数据集&#xff0c;可以对额外的数据希望得到一个正确判断&#xff08;详见下面的例子&#xff09; 回归问题 例如现在有一个…
阅读更多...
张楠辞任抖音集团CEO；东方甄选将开服饰号；小红书新增“附近”一级入口；华为分红770亿元

张楠辞任抖音集团CEO；东方甄选将开服饰号；小红书新增“附近”一级入口；华为分红770亿元

今日精选 • 张楠辞任抖音集团CEO&#xff0c;未来将聚焦剪映发展• 东方甄选将开服饰号 主打自营服饰• 小红书新增“附近”一级入口• 华为分红770亿元 大厂人事变动 • 上村健一出任中国U-16国家男子足球队主教练 投融资与企业动态 • 阿里大模型「通义千问」推出春节新…
阅读更多...
边缘计算第二版施巍松——第七章 边缘计算资源调度

边缘计算第二版施巍松——第七章 边缘计算资源调度

第7章 边缘计算资源调度 进行合理的边缘计算资源调度能够满足任务处理性能需求和利益最大化的目的 7.1 资源调度概述 7.1.1 背景 在边缘计算场景下&#xff0c;用户会产生大量的数据或者应用请求&#xff0c;由于请求类型和需求的不同&#xff0c;边缘设备的计算和存储能力…
阅读更多...
Thinkpad E550 安装 Ubuntu

Thinkpad E550 安装 Ubuntu

参考&#xff1a;使用U盘安装Ubuntu20.04 Thinkpad E550 使用 enterf1进入 bios&#xff0c; 使用 f12 进入 boot 选项。不知道这个和系统有啥关系&#xff0c;感觉之前不是这样。。。 下载镜像 下载镜像 22.04 可以下载相应的 torrent 文件&#xff0c;然后用 百度网盘或者…
阅读更多...
C++：哈希表的线性探测（模拟实现）

C++：哈希表的线性探测（模拟实现）

哈希表的增删查改的效率很高&#xff0c;是O&#xff08;1&#xff09;&#xff0c;比搜索二叉树要快很多。那么他是怎么实现的呢&#xff1f;他与计数排序有点相似就是通过映射的方式实现。不过在哈希表中不需要开这么的数据&#xff0c;它只需要开一部分空间然后使用除留余数…
阅读更多...
mysql 中文编码问题

mysql 中文编码问题

前言 最近在学springboot整合mybatisplus技术&#xff0c;用到mysql数据库&#xff0c;然后发现在windows下插入数据表会出现中文乱码现象 (例如 “我是谁” 在数据库中就成了 “???”) windows show variables like %char%;建表时, 设置默认charset为gbk create table u…
阅读更多...
P8772 [蓝桥杯 2022 省 A] 求和--2024蓝桥杯冲刺省一

P8772 [蓝桥杯 2022 省 A] 求和--2024蓝桥杯冲刺省一

点击跳转例题 思路&#xff1a;简单数乘法结合律&#xff0c;然后前缀和的模板题&#xff1a; 前缀和的知识&#xff1a; 本题的代码&#xff1a;前缀和知识--模板&#xff1b; #include <bits/stdc.h> #define int long long //(有超时风险) #define PII pair<in…
阅读更多...
最新文章

Copyright @ 2022~2023