Your task is to create function```isDivideBy``` (or ```is_divide_by```) to check if an integer number is divisible by each out of two arguments.

A few cases:

```

(-12, 2, -6)  ->  true
(-12, 2, -5)  ->  false

(45, 1, 6)    ->  false
(45, 5, 15)   ->  true

(4, 1, 4)     ->  true
(15, -5, 3)   ->  true

```

Source: codewars | Difficulty: EASY

Starter code: def is_divide_by(number, a, b):
	

Solutions:
def is_divide_by(number, a, b):
	return number % a == 0 and number % b == 0


def is_divide_by(n, a, b):
	return n % a == 0 == n % b


def is_divide_by(number, a, b):
	return not (number % a or number % b)


def is_divide_by(number, a, b):
	return True if number % a == 0 and number % b == 0 else False


def is_divide_by(number, *divisors):
	return all((number % divisor == 0 for divisor in divisors))


def is_divide_by(num, *n):
	return not any([num % x for x in n])


is_divide_by = lambda n, a, b: not (n % a or n % b)


def is_divide_by(number, *divisors):
	return not sum(map(lambda n: number % n != 0, divisors))


def is_divide_by(number, a, b):
	return not any([number % a, number % b])


is_divide_by = lambda n, a, b: all((not n % x for x in (a, b))) if a and b else 'ZeroDivisionError!'


def is_divide_by(number, a, b):
	return all([number % a == 0, number % b == 0])


is_divide_by = lambda number, *x: all((not number % y for y in x))


def is_divide_by(number, a, b):
	return (number % a or number % b) == 0


def is_divide_by(number, a, b):
	return (number / a, number / b) == (number // a, number // b)


def is_divide_by(number, a, b):
	return sum(map(lambda n: number % n == 0, [a, b])) == 2


is_divide_by = lambda _, __, ___: not (_ % __ or _ % ___)


def is_divide_by(number: int, a: int, b: int) -> bool:
	return list(map(lambda _divider: number % _divider, [a, b])) == [0, 0]


def is_divide_by(number, a, b):
	if number % a != 0 or number % b != 0:
		return False
	return True


def is_divide_by(number, a, b):
	return all([number % fac == 0 for fac in (a, b)])


is_divide_by = lambda number, a, b: not number % a and (not number % b)


def is_divide_by(number, a, b):
	return bool(not number % a and (not number % b))


def is_divide_by(number, a, b):
	result = False
	if number % a == 0 and number % b == 0:
		result = True
	return result


def is_divide_by(number, *args):
	return all((not number % i for i in args))


def is_divide_by(number, a, b):
	return True if not number % b and (not number % a) else False


def is_divide_by(n, a, b):
	if n % a == 0 and n % b == 0:
		return True
	return False


def is_divide_by(num, a, b):
	return (num % a == 0) & (num % b == 0)


def is_divide_by(number, a, b):
	if '.0' not in str(number / a):
		return False
	if '.0' not in str(number / b):
		return False
	return True


def is_divide_by(number, a, b):
	divide = number % a
	divide1 = number % b
	if divide != 0 or divide1 != 0:
		return False
	else:
		return True
is_divide_by(-12, 2, -6)


def is_divide_by(number, a, b):
	if (number % a == 0) & (number % b == 0):
		print(number % b)
		return True
	else:
		return False


def is_divide_by(number, a, b):
	if divmod(number, a)[1] == divmod(number, b)[1] == 0:
		return True
	return False


def is_divide_by(number, a, b):
	if number % a == 0 and number % b == 0:
		return True
	else:
		return False
print(is_divide_by(12, 3, 4))


def is_divide_by(number, a, b):
	var = False
	if number % a == 0 and number % b == 0:
		var = True
	return var


def is_divide_by(number, a, b):
	check = True
	c = number % a
	d = number % b
	if c or d != 0:
		check = False
	else:
		check = True
	return check


def is_divide_by(number, a, b):
	print(type(number / a))
	if number / a % float(1) == 0 and number / b % float(1) == 0:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	x = number / a
	y = number / b
	if x.is_integer() == True and y.is_integer() == True:
		return True
	else:
		return False


import math

def is_divide_by(number, a, b):
	div = abs(number % a)
	div2 = abs(number % b)
	correto = False
	if div == 0 and div2 == 0:
		correto = True
	return correto


def is_divide_by(number, a, b):
	x = number / a
	y = number / b
	if isinstance(x, int) and isinstance(y, int):
		return True
	else:
		try:
			float(x)
			float(y)
		except ValueError:
			return False
		else:
			return float(x).is_integer() and float(y).is_integer()


def is_divide_by(number, a, b):
	flag = True
	if number % a == 0:
		if number % b == 0:
			flag = True
		else:
			flag = False
	else:
		flag = False
	return flag


def is_divide_by(number, a, b):
	if number / a == int(number / a):
		if number / b == int(number / b):
			return True
		else:
			return False
	else:
		return False


def is_divide_by(nu, a, b):
	if nu % a == 0 and nu % b == 0:
		return True
	return False


def is_divide_by(n, a, b):
	return not n % a | n % b


is_divide_by = lambda n, a, b: True if n % a == 0 and n % b == 0 else False


def is_divide_by(number: int, a: int, b: int) -> bool:
	return number % a is 0 and number % b is 0


def is_divide_by(number: int, a: int, b: int) -> bool:
	return True if number % a is 0 and number % b is 0 else False


def is_divide_by(number, a, b):
	x = 0
	if number % a == 0:
		x += 1
	if number % b == 0:
		x += 1
	if x == 2:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	c = number % a == 0
	d = number % b == 0
	return c and d


def is_divide_by(number, a, b):
	if number % a == 0 and number % b == 0:
		return True
	else:
		return False
is_divide_by(-12, 2, -6)
is_divide_by(-12, 2, -5)
is_divide_by(45, 1, 6)
is_divide_by(45, 5, 15)
is_divide_by(4, 1, 4)
is_divide_by(15, -5, 3)


def is_divide_by(number, a, b):
	bool = 0
	if number % a == 0:
		if number % b == 0:
			bool = 1
	return bool


def is_divide_by(number, a, b):
	return not any((number % n for n in (a, b)))


def is_divide_by(number, a, b):
	return not abs(number) % abs(a) | abs(number) % abs(b)


def is_divide_by(number, a, b):
	result_a = None
	result_b = None
	if a is 1:
		result_a = True
	elif number % a is 0:
		result_a = True
	else:
		result_a = False
	if b is 1:
		result_b = True
	elif number % b is 0:
		result_b = True
	else:
		result_b = False
	return result_a and result_b


def is_divide_by(number, a, b):
	return number % a == number % b == 0
print(is_divide_by(12, 2, 6))


import random as r
number = r.randint(-12, 46)
b = r.randint(-5, 6)
c = r.randint(-6, 16)

def is_divide_by(number, b, c):
	if number % b == 0 and number % c == 0:
		return True
	else:
		return False


import random as r
number = r.random()

def is_divide_by(number, a=0, b=0):
	if number % a == 0 and number % b == 0:
		return True
	elif number % a != 0 or number % b != 0:
		return False
	elif number % b != 0:
		return False


def is_divide_by(number, a, b):
	from math import fmod
	return sum([fmod(number, float(a)), fmod(number, float(b))]) == 0.0


def is_divide_by(a, b, c):
	if a % c == 0 and a % b == 0:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	div1 = abs(number % a)
	print(div1)
	div2 = abs(number % b)
	print(div2)
	if div1 == 0 and div2 == 0:
		return True
	else:
		return False


def is_divide_by(n, a, b):
	return n / a - int(n / a) == 0 and n / b - int(n / b) == 0


def is_divide_by(number, a, b):
	n = number / a
	m = number / b
	if n.is_integer() == True and m.is_integer() == True:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	div = float(0)
	div2 = float(0)
	div = number / a
	div2 = number / b
	div3 = number // a
	div4 = number // b
	if div == div3 and div2 == div4:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	if (number % a == 0 and number % b == 0) == True:
		return True
	else:
		return False
print(is_divide_by(-12, 2, -6))


def is_divide_by(number, a, b):
	rezultat = number % a or number % b
	if rezultat == 0:
		return True
	else:
		return False


def is_divide_by(number, a, b):
	mod_a = number % a
	mod_b = number % b
	return mod_a == 0 and mod_b == 0


def is_divide_by(number, a, b):
	if number % a == 0 and number % b == 0:
		return True
	elif number % a != 0 or number % b != 0:
		return False
	else:
		return None


def is_divide_by(number, a, b):
	if number // a * a == number and number // b * b == number:
		return True
	return False