充电总时间计算 | 豆包MarsCode AI刷题

充电总时间计算 | 豆包MarsCode AI刷题

充电总时间计算 - MarsCode

简单题，但是可以学习golang控制小数点后位数的方法

摘要

本文介绍了如何计算总充电时间以确保所有设备充满电。在已知设备的电池容量和闪充速度的情况下，总时间可以通过计算所有电池容量的总和并除以总的充电效率来获得。结果保留两位小数。

问题描述

小R希望使用闪充为$n$台电脑充满电，闪充速率为$x$单位时间$4x$的电量。目标是计算总充电时间。

示例

• 输入：n = 4, x = 1, a = [2, 3, 4, 5] 输出：3.50

• 输入：n = 3, x = 2, a = [4, 6, 8] 输出：2.25

• 输入：n = 2, x = 1, a = [10, 5] 输出：3.75

---

原理分析

1. 计算总电量

将所有电脑的电池容量累加，得到需要充电的总电量：

2. 计算充电效率

闪充每单位时间可以为$4x$单位电量充电。

3. 计算总时间

总充电时间通过将总电量除以充电效率计算得到：

4. 保留两位小数

通过格式化字符串保留结果的小数点后两位。

在 Go 中，控制小数点后的位数主要通过以下方法实现：

方法 1：使用 fmt.Sprintf 或 fmt.Printf

fmt 包可以格式化浮点数并控制小数点后的位数。

package main

import (
	"fmt"
)

func main() {
	num := 123.456789

	// 使用 fmt.Sprintf 格式化为字符串，保留两位小数
	str := fmt.Sprintf("%.2f", num)
	fmt.Println("Formatted string:", str)

	// 使用 fmt.Printf 直接打印，保留两位小数
	fmt.Printf("Formatted output: %.2f\n", num)
}

输出：

Formatted string: 123.46
Formatted output: 123.46

格式说明：

• %.2f 表示保留两位小数，四舍五入。
• 如果需要保留更多位小数，可以调整 2 为所需的位数，例如 %.4f。

---

方法 2：使用 math.Round 实现四舍五入

如果需要将浮点数直接四舍五入为指定小数位数，可以使用 math.Round，结合乘法和除法实现。

package main

import (
	"fmt"
	"math"
)

func roundToNDecimal(num float64, n int) float64 {
	scale := math.Pow(10, float64(n))
	return math.Round(num*scale) / scale
}

func main() {
	num := 123.456789

	// 四舍五入到两位小数
	rounded := roundToNDecimal(num, 2)
	fmt.Println("Rounded number:", rounded)

	// 四舍五入到三位小数
	rounded3 := roundToNDecimal(num, 3)
	fmt.Println("Rounded to 3 decimals:", rounded3)
}

输出：

Rounded number: 123.46
Rounded to 3 decimals: 123.457

---

方法 3：使用 strconv.FormatFloat 转换为字符串

strconv 包中的 FormatFloat 可以将浮点数转换为字符串，同时指定精度。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := 123.456789

	// 使用 strconv.FormatFloat 格式化浮点数
	formatted := strconv.FormatFloat(num, 'f', 2, 64) // 保留两位小数
	fmt.Println("Formatted with strconv:", formatted)
}

输出：

Formatted with strconv: 123.46

参数说明：

• 第一个参数：浮点数。
• 第二个参数：格式化模式，'f' 表示定点格式。
• 第三个参数：保留的小数位数（如 2 表示保留两位小数）。
• 第四个参数：浮点数的位数，通常用 64 表示 float64。

---

方法 4：直接截断小数位

如果不需要四舍五入，可以直接截断多余的小数位。

package main

import (
	"fmt"
	"math"
)

func truncateToNDecimal(num float64, n int) float64 {
	scale := math.Pow(10, float64(n))
	return math.Floor(num*scale) / scale
}

func main() {
	num := 123.456789

	// 截断到两位小数
	truncated := truncateToNDecimal(num, 2)
	fmt.Println("Truncated number:", truncated)
}

输出：

Truncated number: 123.45

---

总结

方法	适用场景
fmt.Sprintf / fmt.Printf	格式化输出为字符串，常用于展示或打印
math.Round	数值计算，四舍五入
strconv.FormatFloat	转换为字符串并控制精度
math.Floor	截断多余小数位，适用于不需要四舍五入的场景

---

代码实现

Python代码

def solution(n: int, x: int, a: list) -> str:
    """
    计算给定数组 a 的元素总和与 (x * 4) 的比值，保留两位小数并返回字符串格式的结果。
    """
    # 计算元素总和
    sum_power = sum(a)

    # 计算结果并格式化为两位小数
    result = "{:.2f}".format(sum_power / (x * 4))

    return result


if __name__ == "__main__":
    # 测试用例
    print(solution(4, 1, [2, 3, 4, 5]) == "3.50")  # 应输出 True
    print(solution(3, 2, [4, 6, 8]) == "2.25")    # 应输出 True
    print(solution(2, 1, [10, 5]) == "3.75")     # 应输出 True

---

Go语言代码

package main

import "fmt"

func solution(n int, x int, a []int) string {
    sumPower := 0
    for i := 0; i < len(a); i++ {
        sumPower += a[i]
    }
    str := fmt.Sprintf("%.2f", float64(sumPower)/float64(x*4))
    return str
}

func main() {
    fmt.Println(solution(4, 1, []int{2, 3, 4, 5}) == "3.50")
    fmt.Println(solution(3, 2, []int{4, 6, 8}) == "2.25")
    fmt.Println(solution(2, 1, []int{10, 5}) == "3.75")
}