如何为浮点数列表找到最小整数乘数使其全变为整数

import math

def get_simplified_denominator(item):
    """
    获取浮点数对应的最简分数的分母。
    """
    s_item = str(item)
    parts = s_item.split('.')

    # 整数部分
    int_part = parts[0]
    # 小数部分，如果没有则为空字符串
    fraction_part = parts[1] if len(parts) > 1 else ""

    # 初始分母为10的k次方，k为小数位数
    denominator = 10**len(fraction_part)
    # 初始分子为原数乘以分母，转换为整数
    numerator_as_int = int(denominator * item)

    # 循环去除2的公因子
    while numerator_as_int % 2 == 0 and denominator % 2 == 0:
        numerator_as_int //= 2
        denominator //= 2

    # 循环去除5的公因子
    while numerator_as_int % 5 == 0 and denominator % 5 == 0:
        numerator_as_int //= 5
        denominator //= 5

    return int(denominator)

# 示例
my_list = [2.25, 3.5, 1.8]
denominators = [get_simplified_denominator(item) for item in my_list]
print(f"简化后的分母列表: {denominators}") # 输出: [4, 2, 5]

def get_simplified_denominator_optimized(item):
    """
    优化版：获取浮点数对应的最简分数的分母。
    通过直接计算2和5的幂次。
    """
    s_item = str(item)
    parts = s_item.split('.')

    fraction_part = parts[1] if len(parts) > 1 else ""

    # 初始分母为 10^len(fraction_part)
    # 我们可以将其看作 2^k * 5^k

    # d[0] 存储分母中因子2的幂次
    # d[1] 存储分母中因子5的幂次
    power_of_2 = len(fraction_part)
    power_of_5 = len(fraction_part)

    # 将浮点数转换为不带小数点的整数，例如 2.25 -> 225
    # 注意：直接使用 int(s_item.replace('.', '')) 可能会丢失前导零，
    # 但对于本问题场景，小数部分通常不会有前导零，且整数部分转换为字符串后直接拼接是安全的。
    str_int_item = ''.join(parts)
    current_numerator = int(str_int_item) # 这是分子乘以10^k后的结果

    # 减少分母中因子2的幂次，如果分子也能被2整除
    temp_numerator = current_numerator
    while power_of_2 > 0 and temp_numerator % 2 == 0:
        power_of_2 -= 1
        temp_numerator //= 2

    # 减少分母中因子5的幂次，如果分子也能被5整除
    while power_of_5 > 0 and temp_numerator % 5 == 0:
        power_of_5 -= 1
        temp_numerator //= 5

    # 最终的简化分母是 2^power_of_2 * 5^power_of_5
    min_denominator = (2**power_of_2) * (5**power_of_5)
    return min_denominator

# 示例
my_list = [2.25, 3.5, 1.8]
denominators_optimized = [get_simplified_denominator_optimized(item) for item in my_list]
print(f"优化后简化分母列表: {denominators_optimized}") # 输出: [4, 2, 5]

from math import gcd

def calculate_lcm_of_list(numbers):
    """
    计算列表中所有数字的最小公倍数。
    """
    if not numbers:
        return 1 # 空列表的LCM可以定义为1

    current_lcm = 1
    for num in numbers:
        current_lcm = (current_lcm * num) // gcd(current_lcm, num)
    return current_lcm

# 示例
# 假设我们从上面得到了 denominators = [4, 2, 5]
denominators = [4, 2, 5] 
lowest_common_multiplier = calculate_lcm_of_list(denominators)
print(f"最小公倍数 (LCM): {lowest_common_multiplier}") # 输出: 20

# 示例：继续使用之前的 my_list 和 lowest_common_multiplier
my_list = [2.25, 3.5, 1.8]
lowest_common_multiplier = 20 # 从上一步计算得到

my_new_list = [item * lowest_common_multiplier for item in my_list]
print(f"原始列表: {my_list}")
print(f"转换后的整数列表: {my_new_list}") # 输出: [45.0, 70.0, 36.0]
# 注意：浮点数乘法结果可能仍为浮点类型（如 45.0），如果需要严格的整数类型，可以再次进行类型转换
my_new_list_int = [int(item * lowest_common_multiplier) for item in my_list]
print(f"转换为整数类型后的列表: {my_new_list_int}") # 输出: [45, 70, 36]