Нахождение LCM диапазона чисел

В том, чтобы подробно останавливаться на комментарии @Alexander я указал бы, что, если можно учесть числа к их началам, удалить дубликаты, затем умножение, у Вас будет свой ответ.

, Например, 1-5 имеют простые множители 2,3,2,2,5. Удалите дублированный '2' из факторного списка эти '4', и Вы имеете 2,2,3,5. Умножение их вместе уступает 60, который является Вашим ответом.

ссылка Вольфрама, предоставленная в предыдущем комментарии, , http://mathworld.wolfram.com/LeastCommonMultiple.html входит в намного более формальный подход, но короткая версия выше.

Аплодисменты.

Алгоритм в Haskell. Это - язык, в котором я думаю в наше время для алгоритмических взглядов. Это могло бы казаться странным, сложным и непривлекательным - нравящийся Haskell!

primes :: (Integral a) => [a]
--implementation of primes is to be left for another day.

primeFactors :: (Integral a) => a -> [a]
primeFactors n = go n primes where
    go n ps@(p : pt) =
        if q < 1 then [] else
        if r == 0 then p : go q ps else
        go n pt
        where (q, r) = quotRem n p

multiFactors :: (Integral a) => a -> [(a, Int)]
multiFactors n = [ (head xs, length xs) | xs <- group $ primeFactors $ n ]

multiProduct :: (Integral a) => [(a, Int)] -> a
multiProduct xs = product $ map (uncurry (^)) $ xs

mergeFactorsPairwise [] bs = bs
mergeFactorsPairwise as [] = as
mergeFactorsPairwise a@((an, am) : _) b@((bn, bm) : _) =
    case compare an bn of
        LT -> (head a) : mergeFactorsPairwise (tail a) b
        GT -> (head b) : mergeFactorsPairwise a (tail b)
        EQ -> (an, max am bm) : mergeFactorsPairwise (tail a) (tail b)

wideLCM :: (Integral a) => [a] -> a
wideLCM nums = multiProduct $ foldl mergeFactorsPairwise [] $ map multiFactors $ nums

Острота в Haskell.

wideLCM = foldl lcm 1

Это - то, что я использовал для своей собственной Euler проблемы Проекта 5.

Ответ не требует никаких необычных активных действий вообще с точки зрения факторинга или главных полномочий, и несомненно не требует Решета Эратосфена.

Вместо этого необходимо вычислить LCM единственной пары путем вычислений GCD с помощью алгоритма Euclid (который НЕ требует факторизации и на самом деле значительно быстрее):

def lcm(a,b):
    gcd, tmp = a,b
    while tmp != 0:
        gcd,tmp = tmp, gcd % tmp
    return a*b/gcd

затем можно найти общий LCM моим сокращением массива с помощью вышеупомянутого LCM () функция:

reduce(lcm, range(1,21))

LCM одного или нескольких чисел является продуктом всех отличных простых множителей во всех числах, каждом начале к питанию макс. из всех полномочий, к которым то начало появляется в числах, из которых каждый берет LCM.

Говорят 900 = 2^3 * 3^2 * 5^2, 26460 = 2^2 * 3^3 * 5^1 * 7^2. Макс. питание 2 равняется 3, макс. питание 3 равняется 3, макс. питание 5 равняется 1, макс. питание 7 равняется 2, и макс. питание любого более высокого начала 0. Таким образом, LCM: 264600 = 2^3 * 3^3 * 5^2 * 7^2.

Вот мой удар Python в нем:

#!/usr/bin/env python

from operator import mul

def factor(n):
    factors = {}
    i = 2 
    while i <= n and n != 1:
        while n % i == 0:
            try:
                factors[i] += 1
            except KeyError:
                factors[i] = 1
            n = n / i
        i += 1
    return factors

base = {}
for i in range(2, 2000):
    for f, n in factor(i).items():
        try:
            base[f] = max(base[f], n)
        except KeyError:
            base[f] = n

print reduce(mul, [f**n for f, n in base.items()], 1)

Шаг каждый получает простые множители числа. Шаг две сборки хеш-таблица максимального количества раз, каждый фактор был замечен, затем умножает их всех вместе.