笔试时间：2024年04月10日

历史笔试传送门：2023秋招笔试合集

第一题

题目：云服务计费

编写一个程序为某云服务计算客户话单，输入为某云服务的计费日志和各种计费因子的计费单价的列表，计费日志内容包含时间戳、客户标识、计费因子、计费时长4个字段。日志中如果同一客户同一计费因子在相同时间戳上报多次话单只能计费一次，选先上报的日志计费。计算每个客户的话单总费用。

输入描述

第1行表示计费日志的条数n，是一个正整数，范围是1<=n<=1000；

第2到n+1行表示云服务的计费日志，共4列，第1列表示时间戳(是一个数字字符串，长度为10) 、第2列表示客户标识(是一个字符串，长度为1-16)，第3列表示计费因子 (是一个字符串，长度为1-16，计费因子查不到时认为计费因子单价是0），第四列表示计费时长时长（范围为0-100，当计费时长不在范围内要认为是计费日志有问题，当成计费为0处理)，这4个字段使用迈号分隔；

第n+2行表示计费因子的数量m，m是一个正整数，范围是1<=m<=100；

第n+3到n+3+m行表示各种计费因子的计费单价的列表，该表有2列,第1列表示计费因子 (是一个字符串，长度为1-16)，第2列表示单价(是一个正整数，范围为1~100)，这2个字段使用逗号分。

输出描述

每个客户的话单总费用,共2列，第1列表示客户名，第2列表示话单费用，2列用逗号分割，输出按客户标识字典序升序排序。

样例输入

5

1627845600,client1,factorA,10

1627845605,client2,factorB,15

1627845610,ciient1,factorA,5

1627845610,client1,factorB,8

1627845620.client2,factorB,20

2

factorA,5

factorB,7

样例输出

client1,131

client2，245

参考题解

通过stringstream对输入的字符串进行拆分；通过set进行判断是否存在相同的时间戳客户和计费因子；通过map进行存储不同的客户和计费因子；最后合并统计出各个用户的消费。

C++：[此代码未进行大量数据的测试，仅供参考]

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n; cin >> n;
    
    string a[5];
    
    map<pair<string, string>, int> h1;
    
    set<string> ses;
    
    while (n -- )
    {
        string s, t;
        cin >> s;
        
        stringstream ss(s);
        int k = 0;
        while(getline(ss, t, ','))
            a[k ++] = t;
        
        string ts = a[0] + a[1] + a[2];
        
        if(ses.count(ts)) continue;
        else ses.insert(ts);
        
        int tt = stoi(a[3]);
        if(tt< 0 || tt > 100) continue;
        
        h1[{a[1], a[2]}] += tt;
    }
    
    int m; cin >> m;
    unordered_map<string, int> h2;
    
    while (m -- )
    {
        string s, t;
        cin >> s;
        
        int k = 0;
        stringstream ss(s);
        while(getline(ss, t, ','))
            a[k ++] = t;
        
        h2[a[0]] = stoi(a[1]);
    }
    
    map<string, int> h3;
    for(auto &[k, v] : h1)
    {
        string client = k.first, factor = k.second;
        h3[client] += (h2[factor] * v);
    }
    vector<pair<string, int>> res;
    for(auto &[k, v] : h3) res.push_back({k, v});
    
    sort(res.begin(), res.end());
    
    for(int i = 0; i < res.size(); i ++)
        cout << res[i].first << "," << res[i].second << endl;
        
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        
        String[] a = new String[5];
        
        Map<Map.Entry<String, String>, Integer> h1 = new HashMap<>();
        
        Set<String> ses = new HashSet<>();
        
        while (n-- > 0) {
            String s = br.readLine();
            
            String[] parts = s.split(",");
            for (int i = 0; i < parts.length; i++) {
                a[i] = parts[i];
            }
            
            String ts = a[0] + a[1] + a[2];
            
            if (ses.contains(ts)) continue;
            else ses.add(ts);
            
            int tt = Integer.parseInt(a[3]);
            if (tt < 0 || tt > 100) continue;
            
            Map.Entry<String, String> key = new AbstractMap.SimpleEntry<>(a[1], a[2]);
            h1.put(key, h1.getOrDefault(key, 0) + tt);
        }
        
        int m = Integer.parseInt(br.readLine());
        Map<String, Integer> h2 = new HashMap<>();
        
        while (m-- > 0) {
            String s = br.readLine();
            
            String[] parts = s.split(",");
            for (int i = 0; i < parts.length; i++) {
                a[i] = parts[i];
            }
            
            h2.put(a[0], Integer.parseInt(a[1]));
        }
        
        Map<String, Integer> h3 = new HashMap<>();
        for (Map.Entry<Map.Entry<String, String>, Integer> entry : h1.entrySet()) {
            String client = entry.getKey().getKey();
            String factor = entry.getKey().getValue();
            h3.put(client, h3.getOrDefault(client, 0) + (h2.get(factor) * entry.getValue()));
        }
        
        List<Map.Entry<String, Integer>> res = new ArrayList<>(h3.entrySet());
        
        res.sort(Map.Entry.comparingByKey());
        
        for (Map.Entry<String, Integer> entry : res) {
            System.out.println(entry.getKey() + "," + entry.getValue());
        }
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

import sys
input = sys.stdin.read
from collections import defaultdict

def main():
    data = input().splitlines()
    n = int(data[0])
    
    a = [""] * 5
    
    h1 = defaultdict(int)
    
    ses = set()
    
    index = 1
    for _ in range(n):
        s = data[index]
        index += 1
        
        parts = s.split(',')
        for i in range(len(parts)):
            a[i] = parts[i]
        
        ts = a[0] + a[1] + a[2]
        
        if ts in ses:
            continue
        else:
            ses.add(ts)
        
        tt = int(a[3])
        if tt < 0 or tt > 100:
            continue
        
        h1[(a[1], a[2])] += tt
    
    m = int(data[index])
    index += 1
    h2 = {}
    
    for _ in range(m):
        s = data[index]
        index += 1
        
        parts = s.split(',')
        for i in range(len(parts)):
            a[i] = parts[i]
        
        h2[a[0]] = int(a[1])
    
    h3 = defaultdict(int)
    for (client, factor), v in h1.items():
        h3[client] += h2.get(factor, 0) * v
    
    res = sorted(h3.items())
    
    for k, v in res:
        print(f"