2026-07-29：三角形的内角度数。用go语言，输入是一个包含三个正整数的数组，代表三条边的长度。需要判断这三条边能否组成一个面积大于零

2026-07-29：三角形的内角度数。用go语言，输入是一个包含三个正整数的数组，代表三条边的长度。需要判断这三条边能否组成一个面积大于零的三角形。如果可以，就计算出这个三角形的三个内角，单位用度，并把它们从小到大排好，作为三个浮点数返回；如果不能组成这样的三角形，就返回一个空数组。最终结果的精度要求是，与标准答案的误差不超过 10⁻⁵ 即可。

sides.length == 3。

1 <= sides[i] <= 1000。

输入： sides = [3,4,5]。

输出： [36.86990,53.13010,90.00000]。

解释：

边长为 3、4、5 时，可以构成一个直角三角形。该三角形的三个内角分别约为 36.869897646°、53.130102354° 和 90°。

题目来自力扣3899。

大体过程 第一步：边长排序

• • 接收一个包含三个正整数的数组

• • 将这三个数按照从小到大进行排序

• • 排序后得到 a ≤ b ≤ c，其中 a 是最短边，c 是最长边

• • 根据三角形的基本性质：任意两边之和大于第三边

• • 由于已经排序，只需要检查最短的两条边之和是否大于最长边，即a + b > c

• • 如果a + b ≤ c，说明无法构成三角形（退化或不存在），直接返回空数组

• • 如果a + b > c，继续执行后续计算

• • 使用余弦定理计算角度，余弦定理公式：cos(A) = (b² + c² - a²) / (2bc)，其中 A 是边 a 所对的角

• • 先计算角 A（最短边 a 对应的角）：

• • • 分子：b² + c² - a²

  • • 分母：2 × b × c

  • • 将分子除以分母，得到余弦值

  • • 用反余弦函数acos得到弧度值

  • • 乘以180/π转换为度数

• • 再计算角 B（中间边 b 对应的角）：

• • • 分子：a² + c² - b²

  • • 分母：2 × a × c

  • • 同样用反余弦函数转换后乘以180/π

• • 角 C（最长边 c 对应的角）无需再用余弦定理：

• • • 因为三角形内角和为 180 度

  • • 所以C = 180 - A - B

• • 按照[A, B, C]的顺序返回三个角度

• • 因为排序保证了 a ≤ b ≤ c，根据"大边对大角"原理，对应的角度满足 A ≤ B ≤ C，天然就是非递减顺序

• • 返回包含三个浮点数的数组

1. 1.排序：得到 a=3, b=4, c=5

2. 2.判断：3+4=7 > 5，可以构成三角形

3. 3.计算角 A（3 对应的角）：

• • cos(A) = (4² + 5² - 3²) / (2×4×5) = (16+25-9)/40 = 32/40 = 0.8

• • A = arccos(0.8) × 180/π ≈ 36.869897646°

4.计算角 B（4 对应的角）：

• • cos(B) = (3² + 5² - 4²) / (2×3×5) = (9+25-16)/30 = 18/30 = 0.6

• • B = arccos(0.6) × 180/π ≈ 53.130102354°

5.计算角 C：C = 180 - 36.869897646 - 53.130102354 = 90°

6.返回：[36.869897646, 53.130102354, 90]

复杂度分析

• •时间复杂度：O(1)

• • • 排序操作对固定 3 个元素进行，可视为常数时间

  • • 余弦定理计算也是常数次数学运算

  • • 整体不随输入规模变化

• •额外空间复杂度：O(1)

• • • 只使用了少量固定数量的变量（a、b、c、A、B、C 等）

  • • 返回的数组大小固定为 3

  • • 没有使用随输入规模增长的额外数据结构

package main

 import (
    "fmt"
    "math"
    "slices"
)

 func internalAngles(sides []int) []float64 {
    slices.Sort(sides)
    a, b, c := sides[0], sides[1], sides[2]
    if a+b <= c {
        return nil
    }

     const rad = 180 / math.Pi
    A := math.Acos(float64(b*b+c*c-a*a)/float64(b*c*2)) * rad
    B := math.Acos(float64(a*a+c*c-b*b)/float64(a*c*2)) * rad
    return []float64{A, B, 180 - A - B} // 小边对小角
}

 func main() {
    sides := []int{3, 4, 5}
    result := internalAngles(sides)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 import math

 def internal_angles(sides):
    # 对边长排序
    sides.sort()
    a, b, c = sides[0], sides[1], sides[2]
    # 三角形不等式：两边之和必须大于第三边
    if a + b <= c:
        return []
    # 弧度转角度系数
    rad_to_deg = 180.0 / math.pi
    # 使用余弦定理计算角 A（对应边 a）和角 B（对应边 b）
    # 注意：因为 a <= b <= c，所以 A <= B <= C，天然满足非递减顺序
    A = math.acos((b*b + c*c - a*a) / (2.0 * b * c)) * rad_to_deg
    B = math.acos((a*a + c*c - b*b) / (2.0 * a * c)) * rad_to_deg
    # 第三个角通过三角形内角和 180 度得到
    C = 180.0 - A - B
    return [A, B, C]

 # 测试
if __name__ == "__main__":
    sides = [3, 4, 5]
    result = internal_angles(sides)
    print(result)  

C++完整代码如下：

#include  

#include  

#include  

#include  


 std::vector internalAngles(std::vector sides) {
    // 对边长排序
    std::sort(sides.begin(), sides.end());
    int a = sides[0], b = sides[1], c = sides[2];

     // 三角形不等式：两边之和必须大于第三边
    if (a + b <= c) {
        return {};
    }

     // 弧度转角度系数
    const double rad_to_deg = 180.0 / M_PI;

     // 使用余弦定理计算角 A（对应边 a）和角 B（对应边 b）
    // 因为 a <= b <= c，所以 A <= B <= C，天然满足非递减顺序
    double A = acos((b*b + c*c - a*a) / (2.0 * b * c)) * rad_to_deg;
    double B = acos((a*a + c*c - b*b) / (2.0 * a * c)) * rad_to_deg;

     // 第三个角通过三角形内角和 180 度得到
    double C = 180.0 - A - B;

     return {A, B, C};
}

 int main() {
    std::vector sides = {3, 4, 5};
    std::vector result = internalAngles(sides);

     // 输出结果
    for (double angle : result) {
        std::cout << angle << " ";
    }
    std::cout << std::endl;

     return 0;
}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。