HCF和LCM -实数

HCF和LCM是计算机科学中重要的数学概念。HCF (最大公因数) 表示两个或多个数的最大公约数，而LCM (最小公倍数) 表示两个或多个数的最小公倍数。在计算机编程中，使用HCF和LCM可以在解决数学问题时提供方便。下面介绍HCF和LCM的用法和示例。

HCF

HCF的多组算法。其中包括：

• 暴力枚举法
• 辗转相除法
• 辗转相减法
• 质因数分解法

暴力枚举法

暴力枚举法，也叫做试除法。它通过枚举所有可能的因子来找出两个数的最大公因数。暴力枚举法在两个数很小的时候能够很快的计算出结果，但是在两个大数之间计算会花费很多时间。

def hcf(x, y):
   """此函数返回两个整数的HCF"""

   # 获取较小的整数
   if x > y:
       smaller = y
   else:
       smaller = x

   for i in range(1, smaller+1):
       if((x % i == 0) and (y % i == 0)):
           hcf = i
 
   return hcf

辗转相除法

辗转相除法，又称欧几里德算法，是求两个正整数最大公约数的算法。方法是用大数除以小数，计算余数，然后将小数除以余数，如此重复直至余数为0，返回的商即为最大公约数。

def hcf(x, y):
   """此函数返回两个整数的HCF"""

   while(y):
       x, y = y, x % y
 
   return x

质因数分解法

质因数分解法是将两个数分别质因数分解，然后找到它们的公共部分。

def primeFactors(n, lst):
     
    # 利用质数的性质，将输入的数依次除以2到n中的每个质数，当剩下的就是大于n的数素数。
    while n % 2 == 0:
        lst.append(2)
        n = n / 2
         
    for i in range(3,int(math.sqrt(n))+1,2):
         
        while n % i== 0:
            lst.append(i)
            n = n / i
             
    # n是素数，且不在上面的分解结果里。
    if n > 2:
        lst.append(n)
 
def findHCF(arr):
    lst = []
    mini = min(arr)
    #对最小的进行质因数分解
    primeFactors(mini,lst)
     
    # 找到公共因子
    for i in range(len(lst)-1,-1,-1):
        for j in range(0,len(arr)):
            if arr[j] % lst[i] != 0:
                lst[i] = 0
                break
 
    hcf = 1
    for i in range(0,len(lst)):
        hcf = hcf*lst[i]
         
    return hcf

LCM

LCM的多组算法，其中包括：

• 通过HCF求LCM
• 直接求
• 树型分解法

通过HCF求LCM

在计算LCM时，我们可以使用以下公式：

LCM = (x*y) / HCF(x,y)

def lcm(x, y):
   """返回两个数的LCM"""

   # 获取最大的数
   if x > y:
       greater = x
   else:
       greater = y

   while True:
       if((greater % x == 0) and (greater % y == 0)):
           lcm = greater
           break
       greater += 1

   return lcm

直接求

要计算多个数的LCM时，我们可以使用如下方法，首先利用辗转相减法计算两个数的最大公约数，然后再根据以下公式计算LCM：

LCM(x,y) = |x*y| / HCF(x,y)

def lcm_lst(lst):
   """返回一个列表中所有数字的LCM"""

   lcm = lst[0]
   for i in range(1, len(lst)):
       lcm = lcm * lst[i] / hcf(lcm, lst[i])

   return lcm

树型分解法

树型分解法是一种比较高效的计算多个数的LCM的方法。该算法的具体步骤如下：

1. 找出所有数字中的最大素因子，并将其乘到LCM中。
2. 删除所有数字中的最大素因子，并将剩余数字代替原来的数字数组。
3. 重复前两步，直到所有数字都为1。

def get_next(lst):
   """Finds next potential prime for list"""

   #if empty initialize
   if lst == []:
       return 2

   #if 2 present then return 3
   if lst[-1] == 2:
       return 3

   i = lst[-1] + 2

   #comfirms if its prime
   while True:
       if all([(i % l != 0) for l in lst]):
           return i
       else:
           i += 2

def prime_list(n):
   """Returns the list of prime from [0,n-1]"""

   primes = []
   a = [True] * n
   for p in range(2, n):
       if a[p]:
           primes.append(p)
           for i in range(p * p, n, p):
               a[i] = False
   return primes


def accumulate(n, lst):

   factors = []
   i = 0
   while n > 1:
       if n % lst[i] == 0:
           factors.append(lst[i])
           n = n / lst[i]
       else:
           if i == len(lst) - 1:
               return factors + [int(n)]
           else:
               i += 1
   return factors


def lcm_seq(n):

   primes = prime_list(n + 1)
   remaining = range(2, n + 1)
   factors = []
   while remaining != []:
       new_remain = []
       while remaining != []:
           nex = get_next(factors + [remaining[0]])
           test_accumulate = accumulate(nex, primes)
           if remaining[0] != nex:
               new_remain.append(remaining[0])
           new_remain += test_accumulate

       factors += [nex]
       remaining = list(set(new_remain))

   return functools.reduce(operator.mul, factors, 1)

总结

本文介绍了HCF和LCM的概念以及它们的应用。我们讨论了多种算法来计算HCF和LCM，并提供了一些代码示例。这些算法因其特定的用例而受欢迎，例如质因数分解法用于计算多个数字的HCF，树型分解法用于计算多个数字的LCM。