You're laying out a rad pixel art mural to paint on your living room wall in homage to [Paul Robertson](http://68.media.tumblr.com/0f55f7f3789a354cfcda7c2a64f501d1/tumblr_o7eq3biK9s1qhccbco1_500.png), your favorite pixel artist.

You want your work to be perfect down to the millimeter. You haven't decided on the dimensions of your piece, how large you want your pixels to be, or which wall you want to use. You just know that you want to fit an exact number of pixels.

To help decide those things you've decided to write a function, `is_divisible()` that will tell you whether a wall of a certain length can exactly fit an integer number of pixels of a certain length.

Your function should take two arguments: the size of the wall in millimeters and the size of a pixel in millimeters. It should return `True` if you can fit an exact number of pixels on the wall, otherwise it should return `False`. For example `is_divisible(4050, 27)` should return `True`, but `is_divisible(4066, 27)` should return `False`.

Note: you don't need to use an `if` statement here. Remember that in Python an expression using the `==` comparison operator will evaluate to either `True` or `False`:
```python
>>> def equals_three(num):
>>>     return num == 3
>>> equals_three(5)
False
>>> equals_three(3)
True
```


```if:csharp
Documentation:
Kata.IsDivisible Method (Int32, Int32)

Returns a boolean representing if the first argument is perfectly divisible by the second argument.

Syntax


public
static
bool IsDivisible(
int wallLength,
    int pixelSize,
    )
  



Parameters

wallLength

Type: System.Int32
The length of the wall in millimeters.

pixelSize

Type: System.Int32
The length of a pixel in millimeters.

Return Value

Type: System.Boolean
  A boolean value representing if the first argument is perfectly divisible by the second.

```

Difficulty: EASY
Starter code: def is_divisible(wall_length, pixel_size):
	

Solutions:
def is_divisible(wall_length, pixel_size):
	return wall_length % pixel_size == 0


def is_divisible(wall_length, pixel_size):
	return not wall_length % pixel_size


def is_divisible(a, b):
	return a % b == 0


def is_divisible(wall_length, pixel_size):
	return divmod(wall_length, pixel_size)[1] == 0


def is_divisible(wall_length: int, pixel_size: int) -> bool:
	return int(wall_length / pixel_size) == float(wall_length / pixel_size)


is_divisible = lambda n, d: not n % d


is_divisible = lambda w, p: not w % p


def is_divisible(wall_length, pixel_size):
	boop = wall_length / pixel_size
	return boop == int(boop)


def is_divisible(wall_length, pixel_size):
	return {0: True}.get(wall_length % pixel_size, False)


def is_divisible(*args):
	return int.__mod__(*args) is 0


def is_divisible(wall_length, pixel_size):
	print("It takes you 10 seconds to solve, but half an hour to google 'pixel art',     'Paul Robertson' etc. :D Thank you ! :)")
	return wall_length % pixel_size == 0


def is_divisible(l, p):
	return not bool(l % p)


def is_divisible(wall_length, pixel_size):
	a = wall_length / pixel_size
	b = wall_length // pixel_size
	if a == b:
		return True
	else:
		return False


def is_divisible(wall_length, pixel_size):
	a = wall_length % pixel_size
	if a == 0:
		return True
	else:
		return False


def is_divisible(wall_length, pixel_size):
	n = wall_length / pixel_size
	return n % 2 == 0 or n % 2 == 1.0


def is_divisible(wall_length, pixel_size):
	while wall_length % pixel_size == 0:
		return True
	else:
		return False


is_divisible = lambda a, b: not a % b


def is_divisible(*num):
	return int.__mod__(*num) is 0


def is_divisible(wall_length, pixel_size):
	data = wall_length / pixel_size
	if data == int(data):
		return True
	else:
		return False


def is_divisible(wall_length, pixel_size):
	a_w = wall_length ** 2
	a_p = pixel_size ** 2
	return True if a_w % a_p == 0 else False


def is_divisible(wall_length, pixel_size):
	paul = wall_length % pixel_size == 0
	return paul
	print(is_divisible(4050, 27))


def is_divisible(n, k):
	return not n % k


def is_divisible(wall_length: int, pixel_size: int) -> bool:
	return not wall_length % pixel_size


def is_divisible(wall_length, pixel_size):
	w = wall_length
	p = pixel_size
	return w % p == 0


is_divisible = lambda a, b: a % b == 0


def is_divisible(w, p):
	return w / p % 1 == 0


def is_divisible(wall, pix):
	return wall % pix == 0


def is_divisible(wall_in_mils, pixel_in_mils):
	return wall_in_mils % pixel_in_mils == 0


def is_divisible(wall_length, pixel_length):
	return wall_length % pixel_length == 0


def is_divisible(wall_length, pixel_size):
	return wall_length / pixel_size == wall_length / pixel_size // 1


def is_divisible(wall_length, pixel_size):
	return (wall_length / pixel_size).is_integer()
print(is_divisible(4050, 27))


def is_divisible(wall_size, pixel_size):
	return wall_size % pixel_size == 0


import math

def is_divisible(wall_length, pixel_size):
	return wall_length / pixel_size == math.floor(wall_length / pixel_size)


def is_divisible(wall_length, pixel_size):
	i = wall_length % pixel_size
	if i == 0:
		return True
	else:
		return False


def is_divisible(wall_length, pixel_size):
	calculate = wall_length % pixel_size == 0
	return calculate
print(is_divisible)


is_divisible = lambda l, p: 0 == l % p


def is_divisible(wall_length, pixel_size):
	return wall_length % pixel_size == 0
is_divisible(4066, 27)


def is_divisible(size_of_wall_mm, size_of_pixel_mm):
	return size_of_wall_mm % size_of_pixel_mm == 0


is_divisible = lambda a, b: not bool(a % b)


def is_divisible(wall_length, pixel_size):
	wall_length_true = wall_length
	wall_length_true /= pixel_size
	wall_length_floor = wall_length
	wall_length_floor //= pixel_size
	wall_length_true %= wall_length_floor
	return wall_length_true == 0


def is_divisible(wall_length, pixel_size):
	p = wall_length / pixel_size
	return int(p) == p


def is_divisible(wall, pixel):
	return wall % pixel == 0
print(is_divisible(900, 30))


def is_divisible(wall_length, pixel_size):
	return wall_length % pixel_size == False
is_divisible(4050, 27)


def is_divisible(wall_length, pixel_size):
	div = wall_length / pixel_size
	div_floor = wall_length // pixel_size
	return div == div_floor


def is_divisible(wall_length: int, pixel_size: int) -> bool:
	return wall_length % pixel_size == 0


def is_divisible(wall_length, pixel_size):
	wall_n = wall_length
	pixel_n = pixel_size
	math = wall_n % pixel_n
	if math != 0:
		return False
	elif math == 0:
		return True


def is_divisible(wall_length, pixel_size):
	n = wall_length / pixel_size
	return n.is_integer()


def is_divisible(wall_length, pixel_size):
	return wall_length % pixel_size == 0

def main():
	is_divisible(4050, 27)
main()


def is_divisible(x, y):
	return x / y == x // y


def is_divisible(wall_length, pixel_size):
	if wall_length % pixel_size == 0:
		return 1
	else:
		return 0


def is_divisible(wall_length, pixel_size):
	return wall_length % pixel_size == 0
print(is_divisible(3, 5))
print(is_divisible(8, 4))


is_divisible = lambda wall_length, pixel_size: not wall_length % pixel_size


def is_divisible(wall_length, pixel_size):
	wall = wall_length
	wall %= pixel_size
	return wall == 0
print(is_divisible(6, 2))


def is_divisible(wall_length, pixel_size):
	remdr = wall_length % pixel_size
	print(remdr)
	return remdr == 0


def is_divisible(wall_length, pixel_size):
	is_div = wall_length % pixel_size
	return is_div == 0
print(is_divisible(4050, 27))


def is_divisible(wall_length, pixel_size):
	t = True
	f = False
	text = wall_length % pixel_size
	if text == 0:
		ans = t
	else:
		ans = f
	return ans


def is_divisible(wall_length, pixel_size):
	x = wall_length / pixel_size
	y = wall_length // pixel_size
	return x == y


import math

def is_divisible(wall_length, pixel_size):
	division = wall_length % pixel_size
	return int(division) == 0.0 and float(division) >= 0.0


def is_divisible(wall, pixel):
	return not wall % pixel


def is_divisible(wall_length, pixel_size):
	return True if not wall_length % pixel_size else False