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
```

Difficulty: introductory

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):
    return n % x == n % y == 0

def is_divisible(n,x,y):
    #your code here
    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


""" isdiv works thusly:
Create a function isDivisible(n, x, y)
that checks if a number n is divisible
by two numbers x AND y. All inputs are
positive, non-zero digits.
"""


# isDivisible(3,1,3)--> true because 3 is divisible by 1 and 3
# isDivisible(12,2,6)--> true because 12 is divisible by 2 and 6
# isDivisible(100,5,3)--> false because 100 is not divisible by 3
# isDivisible(12,7,5)--> false because 12 is neither divisible by 7 nor 5

def is_divisible(n,x,y):
    """is divisible checks if a number n is divisible
    by two numbers x AND y. All inputs are
    positive, non-zero digits.

    >>> is_divisible(3,1,3)
    True
    >>> is_divisible(12,2,6)
    True
    >>> is_divisible(100,5,3)
    False
    >>> is_divisible(12,7,5)
    False

    >>> is_divisible(0,1,1)
    Traceback (most recent call last):
     ...
    ValueError: Must be integer greater than 0
    >>> is_divisible(1,0,1)
    Traceback (most recent call last):
     ...
    ValueError: Must be integer greater than 0
    >>> is_divisible(1,1,0)
    Traceback (most recent call last):
     ...
    ValueError: Must be integer greater than 0
    """

    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)

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

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

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 True if n % x == 0 and n % y == 0 else False

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):
    return n%x==0==n%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

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

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

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")


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

is_divisible = lambda n,x,y: (n%x==0)&(n%y==0)

def is_divisible(n,x,y):
    #your code here
    while n != 0:
        if n % x == 0 and n % y == 0:
            return True
        else:
            return False

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


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

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


"""NOTE: This is NOT an efficient solution, it's just a solution using Python's gcd function"""
"""Imports greatest common divisor (gcd)"""
from fractions import gcd 
"""gcd has been moved to the math module in Python 3.5,
so you should use: from math import gcd"""
def is_divisible(n,x,y):
    """Computes the least common multiple (lcm) -> 
    https://en.wikipedia.org/wiki/Least_common_multiple#Computing_the_least_common_multiple"""
    lcm = (x*y)/gcd(x,y) 
    """if x divides n, and y divides n, so lcm(x,y) also divides n"""
    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):
    #your code here
    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;
            
    #your code here


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

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

def is_divisible(n,x,y):
    #your code here
    return not(n % x | n % y)

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

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

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

def is_divisible(n,x,y):

  check = True

  if n % x == 0 and n % y == 0:

    check = True


    return check

  else:

    check = False

    return check


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

def is_divisible(n,x,y):
    t1 = n % x
    t2 = n % y
    if t1 == 0 and t2 == 0:
        return True
    else:
        return False
    #your code here


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%x==0 and n%y==0):
        return True
        end
    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):
    return True if n%x == 0 == n%y else False

# checks if n is divisble by x and y
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):
    flag = False
    if(not(n % x) and not(n % y)):
        flag = True
    return flag

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

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):
#    if all(n % x and n % y) == 0:
#        print(True)
#    else:
#        print(False)

    return n % x == 0 and n % y == 0

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):
    a = n % x
    b = n % y
    if (a or b) == 0:
        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(n,x,y):
    return n % x == 0 == n % y
#pogchamp


def is_divisible(n,x,y):
    #print(n % y)
    if n % x == 0 and n % y == 0:
        return True
    else:
        return 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):
    if n%x == 0 == n%y:
        return True
    else:
        return False

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

def is_divisible(n,x,y):
    # We want to check if n is divisible by BOTH x AND Y
    if n % x == 0 and n % y == 0:
        return True
    else:
        return False

def is_divisible(n,x,y):
    #your code here
    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 == 0 and
        n % y == 0):

        return True

    return False


def is_divisible(n,x,y):
    #number being divided
    #x , y numbers being used to divide
    #print false if its not divisible by one number
    #print true if both statements are true
    if n % x == 0 and n % y == 0:
        return True
    elif n % x != 0 or n % y != 0:
        return False

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

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

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

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

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):
    quotient_nx = n%x
    quotient_ny= n%y
    if quotient_nx == 0 and quotient_ny == 0:
        return True
    else:
        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):
    #your code here
    a = math.trunc(n/x)
    b = math.trunc(n/y)
    return (a == n/x and b == n/y)

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

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

def is_divisible(n,x,y):
    #your code here
    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):
    #your code here
    
    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

#Goal: Write a program that determines whether an integer n is divisible by integers x and y and has no remainder.
# The program should return a True or False value.
#General Strategy: Check to see if the remainder value of n / x and n / y is equivalent to zero.
# Use modulus to find the remainders.
# To return a boolean value of both remainders being zero, I can add both remainders together.
# This will work because if both are zero the sum will be zero.
# If not then the sum will be different and the boolean value returned will be false.

def is_divisible(n,x, y):
    # Return a boolean value by checking to see whether the sum of the remainders of n modulus x and n modulus y equals
    # zero.
    return 0 == (n % x) + (n % y)


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

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

is_divisible=lambda n,x,y:n/x==n//x and n/y==n//y

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


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


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


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):
  #your code here
  F1 = (n % x == 0)
  F2 = (n % y == 0)

  return(F1 and F2)

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



print(is_divisible(3,1,3))

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

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


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):
    #your code here
    return True if n//(x*y/gcd(x,y))==n/(x*y/gcd(x,y)) else False