如何找到最小整数乘数以将浮点数列表转换为整数

def get_simplified_denominators(float_list):
    """
    为浮点数列表中的每个元素提取并简化其隐式分母。
    例如，2.25 -> 4, 3.5 -> 2。
    """
    denominators = []
    for item in float_list:
        # 将浮点数转换为字符串以精确处理小数部分
        splitted_item = str(item).split('.')

        # 整数部分
        # int_part = splitted_item[0] # 实际计算中用不到，但有助于理解

        # 小数部分
        try:
            fraction_part = splitted_item[1]
        except IndexError:
            # 如果没有小数部分，则分母为1
            denominators.append(1)
            continue

        # 初始分母为10的幂，取决于小数位数
        d = 10**len(fraction_part)
        # 将浮点数转换为整数形式的分子（例如 2.25 -> 225）
        int_item = int(d * item)

        # 循环简化分子和分母：同时除以2
        while int_item % 2 == 0 and d % 2 == 0:
            int_item //= 2
            d //= 2
        # 循环简化分子和分母：同时除以5
        while int_item % 5 == 0 and d % 5 == 0:
            int_item //= 5
            d //= 5

        denominators.append(int(d))
    return denominators

# 示例
my_list = [2.25, 3.5, 1.875, 7.0]
simplified_denoms = get_simplified_denominators(my_list)
print(f"简化后的分母列表: {simplified_denoms}") # 输出: 简化后的分母列表: [4, 2, 8, 1]

from math import gcd as get_gcd

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

    lcm_val = 1
    for num in numbers:
        lcm_val = (lcm_val * num) // get_gcd(lcm_val, num)
    return lcm_val

# 示例
min_multiplier = calculate_lcm_of_list(simplified_denoms)
print(f"最小整数乘数: {min_multiplier}") # 输出: 最小整数乘数: 8

def apply_multiplier(float_list, multiplier):
    """
    将列表中的所有元素乘以给定的乘数。
    """
    return [item * multiplier for item in float_list]

# 示例
final_integer_list = apply_multiplier(my_list, min_multiplier)
print(f"转换后的整数列表: {final_integer_list}") # 输出: 转换后的整数列表: [18.0, 28.0, 15.0, 56.0]

from math import gcd as get_gcd

def find_lowest_multiplier_and_convert(float_list):
    """
    找到最小整数乘数，将浮点数列表转换为整数列表。
    """
    if not float_list:
        return 1, []

    # 步骤一：提取并简化分母
    denominators = []
    for item in float_list:
        splitted_item = str(item).split('.')
        try:
            fraction_part = splitted_item[1]
        except IndexError:
            denominators.append(1)
            continue

        d = 10**len(fraction_part)
        int_item = int(d * item)

        while int_item % 2 == 0 and d % 2 == 0:
            int_item //= 2
            d //= 2
        while int_item % 5 == 0 and d % 5 == 0:
            int_item //= 5
            d //= 5

        denominators.append(int(d))

    # 步骤二：计算最小公倍数
    lcm = 1
    for num in denominators:
        lcm = (lcm * num) // get_gcd(lcm, num)

    # 步骤三：应用乘数
    converted_list = [item * lcm for item in float_list]

    return lcm, converted_list

# 测试
my_list = [2.25, 3.5, 1.875, 7.0]
multiplier, result_list = find_lowest_multiplier_and_convert(my_list)
print(f"原始列表: {my_list}")
print(f"最小整数乘数: {multiplier}")
print(f"转换后的整数列表: {result_list}")
# 预期输出:
# 原始列表: [2.25, 3.5, 1.875, 7.0]
# 最小整数乘数: 8
# 转换后的整数列表: [18.0, 28.0, 15.0, 56.0]

def get_simplified_denominators_optimized(float_list):
    """
    优化版：为浮点数列表中的每个元素提取并简化其隐式分母。
    """
    denominators = []
    for item in float_list:
        splitted_item = str(item).split('.')
        try:
            fraction_part = splitted_item[1]
        except IndexError:
            denominators.append(1)
            continue

        # d[0] 存储需要被移除的因子2的幂次，d[1] 存储因子5的幂次
        # 初始时，分母 10^k = (2*5)^k，所以2和5的幂次都是k
        power_of_10 = len(fraction_part)
        d_factors = [power_of_10, power_of_10] 

        # 将 "X.Y" 转换为整数 "XY" (例如 "2.25" -> "225")
        str_int_item = ''.join(splitted_item)
        int_item = int(str_int_item)

        # 优化：计算可以从分母中移除的因子2的幂次
        # 只要还有因子2可以移除 (d_factors[0] > 0) 且当前数字是偶数
        while d_factors[0] > 0 and int_item % 2 == 0:
            d_factors[0] -= 1
            int_item //= 2

        # 优化：计算可以从分母中移除的因子5的幂次
        # 只要还有因子5可以移除 (d_factors[1] > 0) 且当前数字能被5整除
        while d_factors[1] > 0 and int_item % 5 == 0:
            d_factors[1] -= 1
            int_item //= 5

        # 最终的简化分母是 2^剩余2的幂次 * 5^剩余5的幂次
        min_d_amount = (2**d_factors[0]) * (5**d_factors[1])
        denominators.append(min_d_amount)
    return denominators

# 示例
my_list_optimized = [2.25, 3.5, 1.875, 7.0]
simplified_denoms_optimized = get_simplified_denominators_optimized(my_list_optimized)
print(f"优化后简化分母列表: {simplified_denoms_optimized}")
# 预期输出: 优化后简化分母列表: [4, 2, 8, 1]