华为校招机试 - 云服务计费（20240410）

2024-04-15 04:12
文章标签 服务 华为 校招 机试 计费 20240410

本文主要是介绍华为校招机试 - 云服务计费（20240410），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在线OJ测试

题目详情 - 云服务计费 - HydroOJ​​​​​​​

题目描述

编写一个程序为某云服务计算客户话单，输入为某云服务的计费日志和各种计费因子的计费单价的列表，计费日志内容包含 4 个字段：

  • 时间戳
  • 客户标识
  • 计费因子
  • 计费时长

日志中如果同一客户、同一计费因子、在相同时间戳上报多次话单只能计费一次，选先上报的日志计费。

计算每个客户的话单总费用。

输入描述

第 1 行表示计费日志的条数 n

  • n 是一个正整数，范围是：1 ≤ n ≤ 1000

第 2 到 n+1 行表示云服务的计费日志，共 4 列：

  • 第 1 列表示时间戳（是一个数字字符串，长度为10） 
  • 第 2 列表示客户标识（是一个字符串，长度为1-16）
  • 第 3 列表示计费因子（是一个字符串，长度为1-16，计费因子查不到时认为计费因子单价是0）
  • 第 4 列表示计费时长（范围为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,client1,factorA,5
1627845610,client1,factorB,8
1627845620,client2,factorB,20
2
factorA,5
factorB,7
输出client1,131
client2,245
说明client1 = 15 × 5 + 8 × 7 = 131
client2 = 0 × 5 + 35 × 7 = 245

题目解析

本题是一道逻辑模拟题。

主要难点在于细节把握，有如下细节

  1. 日志中如果同一客户、同一计费因子、在相同时间戳上报多次话单只能计费一次，选先上报的日志计费。
  2. 计费因子查不到时认为计费因子单价是0
  3. 计费时长（范围为0-100，当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理)
  4. 输出按客户标识字典序升序排序

对于1，其实就是让我们去除客户的重复日志信息，而日志是否重复的判断标准是：

同一客户、同一计费因子、相同时间戳

因此根据第 2 到 n+1 行输入的日志信息，一旦后面的日志和前面的日志上面三要素相同，则后面的日志就是重复的，可以忽略。

具体去重实现，针对不同语言有不同办法，大家可以看下面源码的具体实现。

对于2，即某个客户名下某个日志的计费因子不存在（即不存在于第 n+3 到 n+3+m 行），那么此时计费因子单价为0，即对应日志不产生费用。

对于3，需要我们日志的计算时长进行范围判断，如果不在指定范围，则对应日志不产生费用。

对于4，输出按客户标识字典序升序排序

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 = parseInt(await readline());// key是客户id，val是客户的计费日志容器const logs = {};for (let i = 0; i < n; i++) {// 时间戳,客户标识,计费因子,计费时长const [timestamp, custId, factor, duration] = (await readline()).split(",");// 初始化客户的日志容器（对象作为容器）if (logs[custId] == undefined) {logs[custId] = {};}const key = timestamp + factor;// 若日志的客户标识、时间戳、计费因子三要素相同，则认为日志重复，不加入重复日志if (logs[custId][key] != undefined) {continue;}// 日志不重复，则记录日志信息[计费因子，计费时长]logs[custId][key] = [factor, parseInt(duration)];}// 计费因子的数量const m = parseInt(await readline());// key是计费因子，val是计费因子单价const unit_price = {};for (let j = 0; j < m; j++) {// 计费因子,单价const [factor, price] = (await readline()).split(",");unit_price[factor] = parseInt(price);}// 客户花费,key是客户id，val是客户所有log的花费之和const fees = {};for (let custId in logs) {for (let key in logs[custId]) {let [factor, duration] = logs[custId][key];// 计费时长（范围为0-100), 当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理if (duration > 100 || duration < 0) {duration = 0;}// 计费因子查不到时认为计费因子单价是0const price = unit_price[factor] ?? 0;fees[custId] = (fees[custId] ?? 0) + duration * price;}}// 结果按照客户标识（fees的key）进行升序Object.keys(fees).sort().forEach((custId) => {console.log(`${custId},${fees[custId]}`);});
})();

Java算法源码

import java.util.*;public class Main {static class Log {String custId;String timestamp;String factor;int duration;@Overridepublic int hashCode() {// 日志中如果同一客户、同一计费因子、在相同时间戳上报多次话单只能计费一次，选先上报的日志计费// 因此若日志的客户表示、时间戳、计费因子三要素相同，则认为日志重复return custId.hashCode() + timestamp.hashCode() + factor.hashCode();}@Overridepublic boolean equals(Object obj) {if (this == obj) {return true;}if (obj == null || getClass() != obj.getClass()) {return false;}Log log = (Log) obj;// 日志中如果同一客户、同一计费因子、在相同时间戳上报多次话单只能计费一次，选先上报的日志计费// 因此若日志的客户表示、时间戳、计费因子三要素相同，则认为日志重复return custId.equals(log.custId) && timestamp.equals(log.timestamp) && factor.equals(log.factor);}}public static void main(String[] args) {// 设置逗号和换行符作为读取分隔符Scanner sc = new Scanner(System.in).useDelimiter("[,\n]");// 计费日志的条数int n = sc.nextInt();// key是客户id，val是客户的计费日志HashMap<String, HashSet<Log>> logs = new HashMap<>();for (int i = 0; i < n; i++) {Log log = new Log();// 时间戳log.timestamp = sc.next();// 客户标识log.custId = sc.next();// 计费因子log.factor = sc.next();// 计费时长log.duration = sc.nextInt();logs.putIfAbsent(log.custId, new HashSet<>());logs.get(log.custId).add(log);}// 计费因子的数量int m = sc.nextInt();// key是计费因子，val是计费因子单价HashMap<String, Integer> unit_price = new HashMap<>();for (int i = 0; i < m; i++) {// 计费因子String factor = sc.next();// 单价int price = sc.nextInt();unit_price.put(factor, price);}// 客户花费,key是客户id，val是客户所有log的花费之和TreeMap<String, Integer> fees = new TreeMap<>(); // TreeMap会根据key的自然顺序进行排序，这里的key是custId字符串，自然顺序就是字典序升序for (String custId : logs.keySet()) {for (Log log : logs.get(custId)) {// 计费时长（范围为0-100), 当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理if (log.duration > 100 || log.duration < 0) {log.duration = 0;}// 计费因子查不到时认为计费因子单价是0int price = unit_price.getOrDefault(log.factor, 0);fees.put(custId, fees.getOrDefault(custId, 0) + log.duration * price);}}for (String custId : fees.keySet()) {System.out.println(custId + "," + fees.get(custId));}}
}

Python算法源码

# 算法入口
def solution():# 计费日志的条数n = int(input())# key是客户id，val是客户的计费日志容器logs = {}for _ in range(n):# 时间戳,客户标识,计费因子,计费时长timestamp, custId, factor, duration = input().split(",")# 初始化客户的日志容器（对象作为容器）if custId not in logs:logs[custId] = {}key = timestamp + factor# 若日志的客户标识、时间戳、计费因子三要素相同，则认为日志重复，不加入重复日志if key in logs[custId]:continue# 日志不重复，则记录日志信息[计费因子，计费时长]logs[custId][key] = (factor, int(duration))# 计费因子的数量m = int(input())# key是计费因子，val是计费因子单价unit_price = {}for _ in range(m):# 计费因子,单价factor, price = input().split(",")unit_price[factor] = int(price)# 客户花费,key是客户id，val是客户所有log的花费之和fees = {}for custId in logs:for factor, duration in logs[custId].values():# 计费时长（范围为0-100), 当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理if duration > 100 or duration < 0:duration = 0# 计费因子查不到时认为计费因子单价是0price = unit_price.get(factor, 0)fees[custId] = fees.get(custId, 0) + price * duration# 结果按照客户标识（fees的key）进行升序for custId in sorted(fees.keys()):print(f"{custId},{fees[custId]}")# 算法调用
solution()

C算法源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define MAX_N 1000
#define MAX_SIZE 20typedef struct {char *timestamp;char *custId;char *factor;int duration;
} Log;Log *new_Log() {Log *log = (Log *) malloc(sizeof(Log));log->timestamp = (char *) calloc(MAX_SIZE, sizeof(char));log->custId = (char *) calloc(MAX_SIZE, sizeof(char));log->factor = (char *) calloc(MAX_SIZE, sizeof(char));log->duration = 0;return log;
}typedef struct {char *custId;Log **logs;int logs_size;int fee;
} Customer;Customer *new_Customer(char *custId) {Customer *customer = (Customer *) malloc(sizeof(Customer));customer->custId = (char *) calloc(MAX_SIZE, sizeof(char));strcpy(customer->custId, custId);customer->logs = (Log **) calloc(MAX_N, sizeof(Log *));customer->logs_size = 0;customer->fee = 0;return customer;
}void add_Log(Customer *customer, Log *log) {for (int i = 0; i < customer->logs_size; i++) {char *custId = customer->logs[i]->custId;char *timestamp = customer->logs[i]->timestamp;char *factor = customer->logs[i]->factor;// 日志中如果同一客户、同一计费因子、在相同时间戳上报多次话单只能计费一次，选先上报的日志计费// 因此若日志的客户表示、时间戳、计费因子三要素相同，则认为日志重复if (strcmp(custId, log->custId) == 0 && strcmp(timestamp, log->timestamp) == 0 &&strcmp(factor, log->factor) == 0) {// 重复日志不加入return;}}// 不重复日志加入customer->logs[customer->logs_size++] = log;
}int cmp(const void *a, const void *b) {Customer *A = *((Customer **) a);Customer *B = *((Customer **) b);return strcmp(A->custId, B->custId);
}int main() {// 计费日志的条数int n;scanf("%d", &n);// 收集客户对象Customer *customers[MAX_N] = {NULL};int customers_size = 0;for (int i = 0; i < n; i++) {getchar();// 日志对象Log *log = new_Log();scanf("%[^,],%[^,],%[^,],%d", log->timestamp, log->custId, log->factor, &log->duration);// 检查该日志对应的客户是否已记录到customers数组int j = 0;for (; j < customers_size; j++) {if (strcmp(customers[j]->custId, log->custId) == 0) {break;}}// 如果未记录过该客户，则新建该客户对象if (j == customers_size) {customers[customers_size++] = new_Customer(log->custId);}// 加入该日志到该客户对象中add_Log(customers[j], log);}// 计费因子的数量int m;scanf("%d", &m);for (int i = 0; i < m; i++) {getchar();// 计费因子char factor[MAX_SIZE];// 单价int price;scanf("%[^,],%d", factor, &price);// 遍历客户对象for (int j = 0; j < customers_size; j++) {Customer *customer = customers[j];// 遍历客户对象下的日志集合for (int k = 0; k < customer->logs_size; k++) {Log *log = customer->logs[k];// 如果该日志的计费因子和当前计费因子相同，则计算当前日志的花费，并求和到客户总费用fee中// 注意：// 1、计费时长（范围为0-100), 当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理// 2、计费因子查不到时认为计费因子单价是0if (log->duration >= 0 && log->duration <= 100 && strcmp(log->factor, factor) == 0) {customer->fee += log->duration * price;}}}}// 结果按照客户标识进行升序qsort(customers, customers_size, sizeof(customers[0]), cmp);for (int i = 0; i < customers_size; i++) {printf("%s,%d\n", customers[i]->custId, customers[i]->fee);}return 0;
}

C++算法源码

#include <bits/stdc++.h>
using namespace std;vector<string> splitCin(char delimiter) {string s;cin >> s;stringstream ss(s);string token;vector<string> res;while (getline(ss, token, delimiter)) {res.emplace_back(token);}return res;
}int main() {// 计费日志的条数int n;cin >> n;// key是客户id，val是客户的计费日志map<string, map<string, vector<string>>> logs;for (int i = 0; i < n; i++) {vector<string> tmp = splitCin(',');// 时间戳string timestamp = tmp[0];// 客户标识string custId = tmp[1];// 计费因子string factor = tmp[2];// 计费时长string duration = tmp[3];if (logs.count(custId) == 0) {logs[custId] = map<string, vector<string>>();}// 若日志的客户标识、时间戳、计费因子三要素相同，则认为日志重复，不加入重复日志string key = timestamp + factor;if (logs[custId].count(key) > 0) {continue;}// 日志不重复，则记录日志信息[计费因子，计费时长]logs[custId][key] = vector<string>{factor, duration};}// 计费因子的数量int m;cin >> m;// key是计费因子，val是计费因子单价map<string, int> unit_price;for (int i = 0; i < m; i++) {vector<string> tmp = splitCin(',');// 计费因子string factor = tmp[0];// 单价string price = tmp[1];unit_price[factor] = stoi(price);}// 客户花费,key是客户id，val是客户所有log的花费之和map<string, int> fees;for (const auto &pair: logs) {string custId = pair.first;for (const auto &item: logs[custId]) {vector<string> log = item.second;string factor = log[0];int duration = stoi(log[1]);// 计费时长（范围为0-100), 当计费时长不在范围内要认为是计费日志有问题，当成计费为 0 处理if (duration > 100 || duration < 0) {duration = 0;}// 计费因子查不到时认为计费因子单价是0int price = unit_price[factor];fees[custId] += duration * price;}}// 结果按照客户标识（fees的key）进行升序, map自动按照key升序for (const auto &pair: fees) {cout << pair.first << "," << pair.second << endl;}return 0;
}

这篇关于华为校招机试 - 云服务计费（20240410）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/904825。

相关文章

springboot家政服务管理平台 LW +PPT+源码+讲解

springboot家政服务管理平台 LW +PPT+源码+讲解

3系统的可行性研究及需求分析 3.1可行性研究 3.1.1技术可行性分析 经过大学四年的学习，已经掌握了JAVA、Mysql数据库等方面的编程技巧和方法，对于这些技术该有的软硬件配置也是齐全的，能够满足开发的需要。 本家政服务管理平台采用的是Mysql作为数据库，可以绝对地保证用户数据的安全；可以与Mysql数据库进行无缝连接。 所以，家政服务管理平台在技术上是可以实施的。 3.1
阅读更多...
华为---OSPF的DR与BDR（六）

华为---OSPF的DR与BDR（六）

9.6 OSPF的DR与BDR 9.6.1 原理概述 在OSPF的广播类型网络和NBMA类型网络中，如果网络中有n台路由器，若任意两台路由器之间都要建立邻接关系，则需要建立n×(n-1)/2个邻接关系，即当路由器很多时，则需要建立和维护的邻接关系就很多，两两之间需要发送的报文也就很多，这会造成很多内容重复的报文在网络中传递，浪费了设备的带宽资源。因此在广播和NBMA类型网络中，OSPF协议定义
阅读更多...
华为某员工爆料：偷偷跑出去面试，被面试官鄙视了。第一句话就问：华为淘汰的吧，35岁了，这个年龄在华为能混得下去吗？身体没啥毛病吧

华为某员工爆料：偷偷跑出去面试，被面试官鄙视了。第一句话就问：华为淘汰的吧，35岁了，这个年龄在华为能混得下去吗？身体没啥毛病吧

“你都35岁了，难不成是被华为淘汰的？在华为混不下去了吧？身体没啥毛病吧，我们这体检可是很严的。” 近日，一位华为员工在朋友圈爆料，自己在面试时遭到了面试官的无理取闹和人身攻击，原因仅仅是因为他35岁了，曾经在华为工作过。 这番话，充满了傲慢与偏见，让人听了义愤填膺。这位面试官的言行，不仅是对求职者的不尊重，更是对职场规则的践踏。 面试本应是双向选择的过程，企业和求职者在相互了解的基
阅读更多...
微服务中RPC的强类型检查与HTTP的弱类型对比

微服务中RPC的强类型检查与HTTP的弱类型对比

在微服务架构中，服务间的通信是一个至关重要的环节。其中，远程过程调用（RPC）和HTTP是两种最常见的通信方式。虽然它们都能实现服务间的数据交换，但在类型检查方面，RPC的强类型检查和HTTP的弱类型之间有着显著的差异。本文将深入探讨这两种通信方式在类型检查方面的优缺点，以及它们对微服务架构的影响。 一、RPC的强类型检查 RPC的强类型检查是其核心优势之一。在RPC通信中，客户端和服务端都使
阅读更多...
高性能并行计算华为云实验五：

高性能并行计算华为云实验五：

目录 一、实验目的 二、实验说明 三、实验过程 3.1 创建PageRank源码 3.2 makefile的创建和编译 3.3 主机配置文件建立与运行监测 四、实验结果与分析 4.1 采用默认的节点数量及迭代次数进行测试 4.2 分析并行化下节点数量与耗时的变化规律 4.3 分析迭代次数与耗时的变化规律 五、实验思考与总结 5.1 实验思考 5.2 实验总结 E
阅读更多...
中国341城市生态系统服务价值数据集（2000-2020年）

中国341城市生态系统服务价值数据集（2000-2020年）

生态系统服务反映了人类直接或者间接从自然生态系统中获得的各种惠益，对支撑和维持人类生存和福祉起着重要基础作用。目前针对全国城市尺度的生态系统服务价值的长期评估还相对较少。我们在Xie等（2017）的静态生态系统服务当量因子表基础上，选取净初级生产力，降水量，生物迁移阻力，土壤侵蚀度和道路密度五个变量，对生态系统供给服务、调节服务、支持服务和文化服务共4大类和11小类的当量因子进行了时空调整，计算了
阅读更多...
SpringCloud - 微服务

SpringCloud - 微服务

1、微服务介绍         参考： 微服务百度百科 1.1 概念         微服务（或称微服务架构）是一种云原生架构方法，在单个应用中包含众多松散耦合且可单独部署的小型组件或服务。 这些服务通常拥有自己的技术栈，包括数据库和数据管理模型；通过一个REST API、事件流和消息代理组合彼此通信；以及按照业务能力进行组织，具有通常称为有界上下文的服务分隔线。         微服务特
阅读更多...
HarmonyOS NEXT：华为开启全新操作系统时代

HarmonyOS NEXT：华为开启全新操作系统时代

在全球科技浪潮的汹涌澎湃中，华为再次以创新者的姿态，引领了一场关于操作系统的革命。HarmonyOS NEXT，这一由华为倾力打造的分布式操作系统，不仅是对现有技术的一次大胆突破，更是对未来智能生活的一次深邃展望。 HarmonyOS NEXT并非简单的迭代升级，而是在华为多年技术积淀的基础上，对操作系统的一次彻底重构。它采用微内核架构，摒弃了传统的宏内核模式，实现了模块化和组件化的设计理念
阅读更多...
微服务（服务治理）

微服务（服务治理）

服务远程调用时存在的问题 注册中心原理 服务治理中的三个角色分别是什么？ 服务提供者：暴露服务接口，供其它服务调用服务消费者：调用其它服务提供的接口注册中心：记录并监控微服务各实例状态，推送服务变更信息 消费者如何知道提供者的地址？ 服务提供者会在启动时注册自己信息到注册中心，消费者可以从注册中心订阅和拉取服务信息 消费者如何得知服务状态变更？ 服务提供者通过心
阅读更多...
海思3518c平台 实现 华为WCDMA 拨号

海思3518c平台 实现 华为WCDMA 拨号

硬件：海思3518c平台 软件：linux version 3.0.8    SVN 一、修改内核文件：         注册“设备ID（vendor_ID）” 和 “ 厂商ID(productor_ID)”   二、配置内核选项：      a、  配置网络选项：WCDMA通过pppd和 chat实现拨号，所以要将ppp相关选项选上。       b、选上USB相关选项：因为3
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2