Módulo incorporado para calcular el mínimo común múltiplo

3 minutos de lectura

Avatar de usuario de MaverickD
MaverickD

Actualmente estoy usando una función que acepta dos números y usa un ciclo para encontrar el mínimo común múltiplo de esos números,

def lcm(x, y):
   """This function takes two
   integers and returns the L.C.M."""

   # Choose the greater number
   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

¿Hay un módulo incorporado en Python que lo haga en lugar de escribir una función personalizada?

avatar de usuario de abarnert
abarnert

En Python 3.8 y anteriores

No existe tal cosa integrada en stdlib.

Sin embargo, hay un Máximo común divisor función en el math biblioteca. (Para Python 3.4 o 2.7, está enterrado en fractions en su lugar.) Y escribir un LCM encima de un GCD es bastante trivial:

def lcm(a, b):
    return abs(a*b) // math.gcd(a, b)

O, si está usando NumPy, viene con un lcm función desde hace bastante tiempo.

  • Desde Py3.9 ahora hay matemáticas.lcm()

    – PhilR

    15 de junio de 2020 a las 12:57

  • El tema de esta metapregunta.

    -Peter Mortensen

    18 de noviembre de 2020 a las 4:02

Avatar de usuario de orangután
Orangután

En Python 3.9+

Esto está disponible como math.lcm(). También toma cualquier cantidad de argumentos, lo que le permite encontrar el múltiplo común más bajo de más de 2 enteros.

Por ejemplo:

>>> from math import lcm
>>> lcm(2, 5, 7)
70

Prueba esto en su lugar:

def lcm(x, y):
    from fractions import gcd # or can import gcd from `math` in Python 3
    return x * y // gcd(x, y)

  • ¿Por qué pones la importación en la función?

    – wjandrea

    2 de enero de 2020 a las 17:14

  • ¿Por qué no? Es mejor publicar una solución independiente que asumir el usuario está de acuerdo con ensuciar un alcance contenedor con nombres (como “gcd”) que son irrelevantes para resolver el problema en cuestión. Si Uds quiere mover la importación a un ámbito contenedor, está bien.

    – Tim Peters

    2 de enero de 2020 a las 17:26


  • Hay una desventaja en tener importaciones dentro de las funciones: cualquier módulo faltante solo se descubrirá cuando se ejecute dicha función. Tener todas las importaciones incondicionalmente en la parte superior de un módulo garantiza que todas las dependencias estén disponibles en el momento en que se carga el módulo. (Claro, esto no es un problema para los módulos lib estándar).

    – Denilson Sá Maia

    5 de enero de 2020 a las 14:43

  • ^^ Además, el tiempo de importación puede ser costoso. Por lo general, es recomendable pagar el costo en el momento de la importación del módulo en lugar de la llamada a la función.

    – anon01

    15 oct 2020 a las 9:32

  • @TimPeters He entendido que el nivel del módulo __all__ está destinado a anunciar nombres públicos, y algunos nombres adicionales en los ámbitos que contienen realmente no dañan nada. En cuanto a “por qué no”, la guía de estilo dice Las importaciones siempre se colocan en la parte superior del archivo. pero creo que la razón más importante es que el código sea sincero sobre sus dependencias. Eso hace que navegar por una gran base de código sea más fácil, y durante la prueba significa que simular/parchar una dependencia del espacio de nombres del módulo es más simple.

    – Wim

    17 de noviembre de 2020 a las 17:29


Para simplificar un poco tu código:

def lcm(x, y):
    for currentPossibleLCM in range(max(x,y), (x*y)+1)
         if((currentPossibleLCM % x == 0) and (currentPossibleLCM % y == 0)):
              return currentPossibleLCM

Tiempo de ejecución: O(x*y)

Avatar de usuario de Vinura
Vinura

Esto no es solo para dos números específicamente, sino para encontrar MCM de una matriz de enteros. (sin usar matemáticas.lcm())

import math
from functools import reduce

def lcm(arr):

    l=reduce(lambda x,y:(x*y)//math.gcd(x,y),arr)
    return l

¿Ha sido útil esta solución?