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，天然就是非递减顺序
返回包含三个浮点数的数组

具体示例（边长为 3、4、5）

排序：得到 a=3, b=4, c=5
判断：3+4=7 > 5，可以构成三角形
计算角 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°
计算角 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°
计算角 C：C = 180 - 36.869897646 - 53.130102354 = 90°
返回：[36.869897646, 53.130102354, 90]

复杂度分析

时间复杂度：O(1)
- 排序操作对固定 3 个元素进行，可视为常数时间
- 余弦定理计算也是常数次数学运算
- 整体不随输入规模变化
额外空间复杂度：O(1)
- 只使用了少量固定数量的变量（a、b、c、A、B、C 等）
- 返回的数组大小固定为 3
- 没有使用随输入规模增长的额外数据结构

Go完整代码如下：

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 <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

std::vector<double> internalAngles(std::vector<int> 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<int> sides = {3, 4, 5};
    std::vector<double> result = internalAngles(sides);

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

    return 0;
}

在这里插入图片描述