# Task
 Your task is to find the smallest number which is evenly divided by all numbers between `m` and `n` (both inclusive).

# Example

 For `m = 1, n = 2`, the output should be `2`.
 
 For `m = 2, n = 3`, the output should be `6`.
 
 For `m = 3, n = 2`, the output should be `6` too.
 
 For `m = 1, n = 10`, the output should be `2520`.

# Input/Output


 - `[input]` integer `m`

  `1 ≤ m ≤ 25`


 - `[input]` integer `n`

  `1 ≤ n ≤ 25`


 - `[output]` an integer

Difficulty: introductory

Starter code:

def mn_lcm(m, n):
	

Solutions:
from fractions import gcd
from functools import reduce

def mn_lcm(m, n):
    return reduce(lambda x, y: (x * y) / gcd(x, y), list(range(min(m, n), max(m, n) + 1)))



from fractions import gcd
from functools import reduce
def mn_lcm(m, n):
    return reduce(lambda x, y: (x * y) / gcd(x, y), range(min(m, n), max(m, n) + 1))

from fractions import gcd
from functools import reduce

def mn_lcm(m, n):
    m, n = sorted([m, n])
    return reduce(lambda x, y: x * y / gcd(x, y), range(m, n + 1))

def gcd(a,b):
    return a if b == 0 else gcd(b,a%b)
    
def mn_lcm(m,n):
    if n < m:
        m, n = n, m
    ans = m
    for i in range(m,n+1):
        ans = ((i*ans)) / (gcd(i, ans)) 
    return ans

from fractions import gcd
from functools import reduce

def _lcm(a, b):
    return a and b and (a * b // gcd(a, b)) or 0

def lcm(*args):
    return args and reduce(_lcm, args) or 0

def mn_lcm(m,n):
    low, high = sorted((m, n))
    return lcm(*range(low, high+1))

import functools
def gcd_rec(a, b): 
    if b:
        return gcd_rec(b, a % b)
    else:
        return a

def mn_lcm(m,n):
  lst = list(range(min(n,m),max(n,m)+1))
  return functools.reduce(lambda a,b : a*b/gcd_rec(a,b),lst ) 

def gcd(a, b):
    if a < b: 
        b, a = a, b
    while b != 0:
        a, b = b, a % b
    return a

def mn_lcm(m, n):
    m, n = sorted([m, n])
    f = 1
    for i in range(m, n + 1):
        f = abs(i * f) // gcd(i, f)
    return f

from fractions import gcd
from functools import reduce
def lcm(a,b):
    return a//gcd(a,b)*b

def mn_lcm(m,n):
    m,n = sorted([m,n])
    return reduce(lcm, range(m,n+1))