Create a function that checks if a number `n` is divisible by two numbers `x` **AND** `y`. All inputs are positive, non-zero digits.

```JS
Examples:
1) n =   3, x = 1, y = 3 =>  true because   3 is divisible by 1 and 3
2) n =  12, x = 2, y = 6 =>  true because  12 is divisible by 2 and 6
3) n = 100, x = 5, y = 3 => false because 100 is not divisible by 3
4) n =  12, x = 7, y = 5 => false because  12 is neither divisible by 7 nor 5
```

Source: codewars | Difficulty: EASY

Starter code: def is_divisible(n,x,y):
	

Solutions:
def is_divisible(n, x, y):
	return n % x == 0 and n % y == 0


def is_divisible(n, x, y):
	if n % x == 0 and n % y == 0:
		return True
	else:
		return False


def is_divisible(n, x, y):
	return not n % x and (not n % y)


def is_divisible(n, x, y):
	if n < 1 or x < 1 or y < 1:
		raise ValueError('Must be integer greater than 0')
	return n % x == 0 and n % y == 0


def is_divisible(n, x, y):
	return not (n % x or n % y)


is_divisible = lambda n, x, y: not (n % x or n % y)


def is_divisible(n, x, y):
	if x == 0 or y == 0:
		return False
	return n // x == n / x and n // y == n / y


def is_divisible(n, x, y):
	return (False, True)[n % x == 0 and n % y == 0]


is_divisible = lambda n, x, y: not n ** 2 % (x * y)


def is_divisible(n, x, y):
	correct = True
	if n / x != n // x:
		correct = False
	elif n / y != n // y:
		correct = False
	return correct


def is_divisible(n, x, y):
	if not n % x:
		if not n % y:
			return True
	return False


is_divisible = lambda n, x, y: n % x == 0 and n % y == 0


from math import gcd
is_divisible = lambda n, x, y: not n % (x * y // gcd(x, y))


def is_divisible(n, x, y):
	if n > 0 and x > 0 and (y > 0):
		if n % x == 0 and n % y == 0:
			print('Target number IS divisible by BOTH divisors')
			return True
		else:
			print('Target number is NOT divisible by BOTH devisors')
			return False
	else:
		print('Incorrect input: One or more arguments are not higher than zero')


is_divisible = lambda n, x, y: not n % x and (not n % y)


def is_divisible(n, x, y):
	if n % x == 0:
		if n % y == 0:
			return True
	return False


from fractions import gcd

def is_divisible(n, x, y):
	lcm = x * y / gcd(x, y)
	return n % lcm == 0


def is_divisible(n, x, y):
	a = n / x
	b = n / y
	return a.is_integer() and b.is_integer()


def is_divisible(n, x, y):
	return all([n % m == 0 for m in (x, y)])


def is_divisible(n, *args):
	return all((n % i == 0 for i in args))


def is_divisible(n, x, y):
	return all([not n % x, not n % y])


def is_divisible(n, x, y):
	div1 = n % x
	div2 = n % y
	if div1 == 0 and div2 == 0:
		return True
	else:
		return False
print(is_divisible(6, 2, 3))


def is_divisible(n, x, y):
	return n % y == 0 if n % x == 0 else False


def is_divisible(n, x, y):
	ifx = True
	ify = True
	if n % x != 0 or n % y != 0:
		if n % x != 0 and n % y != 0:
			ifx = False
			ify = False
		elif n % x != 0:
			ifx = False
		elif n % y != 0:
			ify = False
	if ifx == False or ify == False:
		return False
	else:
		return True


def is_divisible(n, x, y):
	return True if (n % x or n % y) == 0 else False


def is_divisible(n, x, y):
	if n < 1 or x < 1 or y < 1:
		return False
	elif n % x == 0 and n % y == 0:
		return True
	else:
		return False


def is_divisible(n, x, y):
	a = n % x
	b = n % y
	if a == 0 and b == 0:
		print(a)
		print(b)
		return True
	else:
		return False


def is_divisible(n, x, y):
	if n > 0:
		if n % x == 0 and n % y == 0:
			return True
		else:
			return False
	else:
		print('Inputs should be positive, non-zero digits!')


import math

def is_divisible(n, x, y):
	return math.floor(n / x) == math.ceil(n / x) and math.floor(n / y) == math.ceil(n / y)


def is_divisible(n, x, y):
	flag = False
	if not n % x and (not n % y):
		flag = True
	return flag


def is_divisible(n, x, y):
	return not bool(n % y) + n % x


def is_divisible(n, x, y):
	num = n
	num1 = x
	num2 = y
	if num % x == 0 and num % y == 0:
		return True
	else:
		return False


def is_divisible(n, x, y):
	ma = n % x
	la = n % y
	ka = ma + la
	if ka == 0:
		return True
	else:
		return False


def is_divisible(n, x, y):
	answer = n / x
	answer2 = n / y
	answer_integer_check = answer.is_integer()
	answer2_integer_check = answer2.is_integer()
	if answer_integer_check and answer2_integer_check == True:
		return True
	else:
		return False


def is_divisible(n, x, y):
	x1 = n % x
	y1 = n % y
	if x1 >= 1 or y1 >= 1:
		return False
	elif x1 == 0 and y1 == 0:
		return True


def is_divisible(n, x, y):
	(q1, r1) = divmod(n, x)
	(q2, r2) = divmod(n, y)
	return True if r1 == 0 and r2 == 0 else False


def is_divisible(z, x, y):
	if z / x == int(z / x) and z / y == int(z / y):
		return True
	else:
		return False


def is_divisible(n, x, y):
	return True if (n / x).is_integer() == True and (n / y).is_integer() == True else False


def is_divisible(n, x, y):
	if n % x == 0 and n % y == 0:
		return True
	elif n % x != 0 or n % y != 0:
		return False
	else:
		return False
n = 3
x = 3
y = 4
print(is_divisible(n, x, y))


def is_divisible(n, x, y):
	(num, num1) = (n / y, n / x)
	if num == int(n / y) and num1 == int(n / x):
		return True
	else:
		return False


def is_divisible(n, x, y):
	if n / x == int(n / x):
		if n / y == int(n / y):
			return True
	return False


is_divisible = lambda n, x, y: (n / x).is_integer() and (n / y).is_integer()


def is_divisible(n, x, y):
	count = n % x or n % y
	if count == 0:
		return True
	elif count != 0:
		return False


def is_divisible(n, x, y):
	return True if n % x == 0 and n % y == 0 else False
print(is_divisible(100, 3, 7))


import math

def is_divisible(n, x, y):
	a = math.trunc(n / x)
	b = math.trunc(n / y)
	return a == n / x and b == n / y


def is_divisible(n, x, y):
	i = n % x
	j = n % y
	return i + j == 0


def is_divisible(n, x, y):
	num = int(n)
	numx = int(x)
	numy = int(y)
	if num % x == 0 and num % y == 0:
		return True
	else:
		return False


def is_divisible(n, x, y):
	ans = False
	if n % x == 0 and n % y == 0:
		ans = True
	return ans


def is_divisible(n, x, y):
	a = n / x
	b = n / y
	cka = a - int(a)
	ckb = b - int(b)
	if cka > 0 or ckb > 0:
		return False
	else:
		return True


def is_divisible(n, x, y):
	print(n, x, y)
	return True if n / x % 1 + n / y % 1 == 0 else False


def is_divisible(n, x, y):
	resultone = n / x
	resulttwo = n / y
	if resultone == int(resultone) and resulttwo == int(resulttwo):
		return True
	else:
		return False


def is_divisible(n, x, y):
	return True if not (bool(n % x) or bool(n % y)) else False


def is_divisible(n, x, y):
	if n % x == 0 and n % y == 0:
		return 1
	else:
		return False


def is_divisible(n, x, y):
	a = n / x
	b = n / y
	if a == int(a) and b == int(b):
		return True
	else:
		return False


def is_divisible(n, x, y):
	F1 = n % x == 0
	F2 = n % y == 0
	return F1 and F2


def is_divisible(n, x, y):
	a = n % x
	b = n % y
	return False if bool(a + b) else True


from math import gcd

def is_divisible(n, x, y):
	return True if n // (x * y / gcd(x, y)) == n / (x * y / gcd(x, y)) else False