首页/资讯中心/详情

华为OD机试新系统真题【计算电动车续航里程】

华为OD机试新系统真题【计算电动车续航里程】
📅 发布时间：2026/8/3 14:27:24

计算电动车续航里程(C/C++/Py/Java/Js/Go)题解

华为OD机试新系统真题 华为OD上机考试新系统真题 8月2号 100分题型

华为OD机试新系统真题目录点击查看: 华为OD机试新系统真题题库目录｜机考题库 + 算法考点详解

题目内容

给定电动车的电池容量capacity（kWh）、能耗效率efficiency（kWh/100km）、驾驶场景（城市 / 高速 / 山路，int类型，分别是0/1/2），计算该车的有效续航里程（km）。

核心公式：理论续航里程= (电池容量 * 容量能耗修正系数) / 能耗效率 *100；（结果按四舍五入保留4位小数）

有效续航里程= 理论续航里程 * 总体损耗系数 ，相关系数计算规则如下：

容量能耗修正数 Kp：不同容量下，能效效率不同，分段进行能效效率修正

  • 零段：电池容量capacity>=160kWh时，kp0 = 1(无损耗)
  • 一段：电池容量160kWh>capacity>80kWh时，kp1 = 0.98
  • 二段：电池容量capacity<=80kWh时，kp2 = 0.95

总体损耗系数 kd：基础损耗系数为kb (0.956)* 场景修正系数kc（结果按四舍五入保留4位小数）

补充约束:

  1. 电池容量范围：20 ≤ capacity ≤ 200 20 \le \text{capacity} \le 20020≤capacity≤200（非整数需向下取整）；
  2. 标准能耗效率范围：5 ≤ efficiency ≤ 30 5 \le \text{efficiency} \le 305≤efficiency≤30；
  3. 驾驶场景仅支持：“city”（城市）0/场景修正系数kc0 = 1 \text{kc0}=1kc0=1、“highway”（高速）1/场景修正系数kc1 = 0.92 \text{kc1}=0.92kc1=0.92、“mountain”（山路）2/场景修正系数kc2 = 0.85 \text{kc2}=0.85kc2=0.85；
  4. 结果要求：有效续航里程需四舍五入为整数，输出里程km。

输入描述

输入为一行，包含三个值：电池容量（可能含小数）、能耗效率（可能含小数）、驾驶场景（整数0/1/2），以逗号分隔。

输出描述

输出一个整数，表示四舍五入后的有效续航里程（单位：km）。

样例1

输入

75.8 14.3 1

输出

438

说明
电池容量向下取整：75.8 → 75 75.8 \rightarrow 7575.8→75；能耗效率：14.3 14.314.3

  • 零段：电池容量capacity > = 160 kWh \text{capacity}>=160\text{kWh}capacity>=160kWh时，kp0 = 1 \text{kp0}=1kp0=1（无损耗），75 7575不在此段内，电池容量等效为0 ∗ 1 0*10∗1
  • 一段：电池容量160 kWh > capacity > 80 kWh 160\text{kWh}>\text{capacity}>80\text{kWh}160kWh>capacity>80kWh时，kp1 = 0.98 \text{kp1}=0.98kp1=0.9875 7575不在此段内，电池容量等效为0 ∗ 0.98 0*0.980∗0.98
  • 二段：电池容量capacity < = 80 kWh \text{capacity}<=80\text{kWh}capacity<=80kWh时，kp2 = 0.95 \text{kp2}=0.95kp2=0.9575 7575在此段内，电池容量等效为75 ∗ 0.95 75*0.9575∗0.95
  • 理论里程= ( 0 ∗ 1 + 0 ∗ 0.98 + 75 ∗ 0.95 ) / 14.3 ∗ 100 = 498.2517 km =(0*1+0*0.98+75*0.95)/14.3*100=498.2517\text{km}=(0∗1+0∗0.98+75∗0.95)/14.3∗100=498.2517km(保留4 44位)；
  • 总体损耗系数计算：0.956 0.9560.956（基础）∗ 0.92 * 0.92∗0.92（高速）= 0.8795 =0.8795=0.8795(保留4 44位)；
  • 里程= 498.2517 ∗ 0.8795 = 438.2124126 =498.2517*0.8795=438.2124126=498.2517∗0.8795=438.2124126
  • 四舍五入后的有效里程= 438 =438=438

样例2

输入

135.1 12.3 2

输出

858

说明
电池容量向下取整：135.1 → 135 135.1 \rightarrow 135135.1→135；能耗效率：12.3 12.312.3

  • 零段：电池容量capacity > = 160 kWh \text{capacity}>=160\text{kWh}capacity>=160kWh时，kp0 = 1 \text{kp0}=1kp0=1（无损耗），135 135135不在此段内，电池容量等效为0 ∗ 1 0*10∗1
  • 一段：电池容量160 kWh > capacity > 80 kWh 160\text{kWh}>\text{capacity}>80\text{kWh}160kWh>capacity>80kWh时，kp1 = 0.98 \text{kp1}=0.98kp1=0.98135 135135在此段内，电池容量等效为( 135 − 80 ) ∗ 0.98 (135-80)*0.98(135−80)∗0.98
  • 二段：电池容量capacity < = 80 kWh \text{capacity}<=80\text{kWh}capacity<=80kWh时，kp2 = 0.95 \text{kp2}=0.95kp2=0.95剩余的电池容量80 8080在此段内，电池容量等效为80 ∗ 0.95 80*0.9580∗0.95
  • 理论里程= ( 0 ∗ 1 + ( 135 − 80 ) ∗ 0.98 + 80 ∗ 0.95 ) / 12.3 ∗ 100 = 1056.0976 km =(0*1+(135-80)*0.98+80*0.95)/12.3*100=1056.0976\text{km}=(0∗1+(135−80)∗0.98+80∗0.95)/12.3∗100=1056.0976km(保留4 44位)
  • 总体损耗系数：0.956 0.9560.956（基础）∗ 0.85 * 0.85∗0.85（山地）= 0.8126 =0.8126=0.8126(保留4 44位)；
  • 里程= 1056.0976 ∗ 0.8126 = 858.1840908 =1056.0976*0.8126=858.1840908=1056.0976∗0.8126=858.1840908
  • 四舍五入后的有效里程= 858 =858=858

题解

思路：模拟

  1. 将电池容量向下取整

  2. 分段计算每一段能耗修正数，得到能耗修正数总和。

  3. 依照公式理论续航里程 = (电池容量 * 容量能耗修正系数) / 能耗效率 * 100得到理论续航里程并四舍五入保留4位小数。

  4. 计算总体损耗系数按照公式基础损耗系数为 kb (0.956) * 场景修正系数 kc，四舍五入保留4位小数

  5. 总体损耗系数 * 理论续航里程计算实际里程，并四舍五入保留整数。

c++

#include<bits/stdc++.h>usingnamespacestd;intsolve(doublecapacity,doubleefficiency,inttype){// 向下取整intrealCapacity=(int)floor(capacity);// 计算每一段能耗修正数doubleseg0=max(0,realCapacity-160)*1.0;doubleseg1=max(0,min(realCapacity,160)-80)*0.98;doubleseg2=min(realCapacity,80)*0.95;doublecoefficient=seg0+seg1+seg2;// 计算理论续航里程doubletheoryDistance=coefficient/efficiency*100;// 四舍五入保留4位小数theoryDistance=round(theoryDistance*10000)/10000.0;doublekc[3]={1.0,0.92,0.85};// 计算总体损耗系数 并保留4位小数doublekd=round(0.956*kc[type]*10000)/10000.0;// 有效续航里程 并四舍五入保留正数returnround(theoryDistance*kd);}intmain(){doublecapacity,efficiency;inttype;cin>>capacity>>efficiency>>type;cout<<solve(capacity,efficiency,type);return0;}

Java

importjava.util.*;publicclassMain{staticintsolve(doublecapacity,doubleefficiency,inttype){// 向下取整intrealCapacity=(int)Math.floor(capacity);// 计算每一段能耗修正数doubleseg0=Math.max(0,realCapacity-160)*1.0;doubleseg1=Math.max(0,Math.min(realCapacity,160)-80)*0.98;doubleseg2=Math.min(realCapacity,80)*0.95;doublecoefficient=seg0+seg1+seg2;// 计算理论续航里程doubletheoryDistance=coefficient/efficiency*100;// 四舍五入保留4位小数theoryDistance=Math.round(theoryDistance*10000)/10000.0;double[]kc={1.0,0.92,0.85};// 计算总体损耗系数 并保留4位小数doublekd=Math.round(0.956*kc[type]*10000)/10000.0;// 有效续航里程 并四舍五入保留正数return(int)Math.round(theoryDistance*kd);}publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);doublecapacity=sc.nextDouble();doubleefficiency=sc.nextDouble();inttype=sc.nextInt();System.out.println(solve(capacity,efficiency,type));sc.close();}}

Python

importmathdefsolve(capacity,efficiency,type):# 向下取整real_capacity=int(math.floor(capacity))# 计算每一段能耗修正数seg0=max(0,real_capacity-160)*1.0seg1=max(0,min(real_capacity,160)-80)*0.98seg2=min(real_capacity,80)*0.95coefficient=seg0+seg1+seg2# 计算理论续航里程theory_distance=coefficient/efficiency*100# 四舍五入保留4位小数theory_distance=round(theory_distance,4)kc=[1.0,0.92,0.85]# 计算总体损耗系数 并保留4位小数kd=round(0.956*kc[type],4)# 有效续航里程 并四舍五入保留正数returnround(theory_distance*kd)if__name__=="__main__":capacity,efficiency,type=input().split()capacity=float(capacity)efficiency=float(efficiency)type=int(type)print(solve(capacity,efficiency,type))

JavaScript

constreadline=require("readline");constrl=readline.createInterface({input:process.stdin,output:process.stdout});rl.on("line",function(line){letarr=line.trim().split(/\s+/);letcapacity=Number(arr[0]);letefficiency=Number(arr[1]);lettype=Number(arr[2]);functionsolve(capacity,efficiency,type){// 向下取整letrealCapacity=Math.floor(capacity);// 计算每一段能耗修正数letseg0=Math.max(0,realCapacity-160)*1.0;letseg1=Math.max(0,Math.min(realCapacity,160)-80)*0.98;letseg2=Math.min(realCapacity,80)*0.95;letcoefficient=seg0+seg1+seg2;// 计算理论续航里程lettheoryDistance=coefficient/efficiency*100;// 四舍五入保留4位小数theoryDistance=Math.round(theoryDistance*10000)/10000.0;letkc=[1.0,0.92,0.85];// 计算总体损耗系数 并保留4位小数letkd=Math.round(0.956*kc[type]*10000)/10000.0;// 有效续航里程 并四舍五入保留正数returnMath.round(theoryDistance*kd);}console.log(solve(capacity,efficiency,type));rl.close();});

Go

packagemainimport("bufio""fmt""math""os")funcsolve(capacityfloat64,efficiencyfloat64,typint)int{// 向下取整realCapacity:=int(math.Floor(capacity))// 计算每一段能耗修正数seg0:=math.Max(0,float64(realCapacity-160))*1.0seg1:=math.Max(0,math.Min(float64(realCapacity),160)-80)*0.98seg2:=math.Min(float64(realCapacity),80)*0.95coefficient:=seg0+seg1+seg2// 计算理论续航里程theoryDistance:=coefficient/efficiency*100// 四舍五入保留4位小数theoryDistance=math.Round(theoryDistance*10000)/10000.0kc:=[]float64{1.0,0.92,0.85}// 计算总体损耗系数 并保留4位小数kd:=math.Round(0.956*kc[typ]*10000)/10000.0// 有效续航里程 并四舍五入保留正数returnint(math.Round(theoryDistance*kd))}funcmain(){in:=bufio.NewReader(os.Stdin)varcapacity,efficiencyfloat64vartypintfmt.Fscan(in,&capacity,&efficiency,&typ)fmt.Println(solve(capacity,efficiency,typ))}

C语言

#include<stdio.h>#include<math.h>intsolve(doublecapacity,doubleefficiency,inttype){// 向下取整intrealCapacity=(int)floor(capacity);// 计算每一段能耗修正数doubleseg0=fmax(0,realCapacity-160)*1.0;doubleseg1=fmax(0,fmin(realCapacity,160)-80)*0.98;doubleseg2=fmin(realCapacity,80)*0.95;doublecoefficient=seg0+seg1+seg2;// 计算理论续航里程doubletheoryDistance=coefficient/efficiency*100;// 四舍五入保留4位小数theoryDistance=round(theoryDistance*10000)/10000.0;doublekc[3]={1.0,0.92,0.85};// 计算总体损耗系数 并保留4位小数doublekd=round(0.956*kc[type]*10000)/10000.0;// 有效续航里程 并四舍五入保留正数return(int)round(theoryDistance*kd);}intmain(){doublecapacity,efficiency;inttype;scanf("%lf %lf %d",&capacity,&efficiency,&type);printf("%d",solve(capacity,efficiency,type));return0;}