# 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

Source: codewars | Difficulty: EASY
Tags: Fundamentals

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):
	(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))