Suppose I have two vectors: `(a1, a2, a3, ..., aN)` and `(b1, b2, b3, ..., bN)`. The dot product between these two vectors is defined as:

```
a1*b1 + a2*b2 + a3*b3 + ... + aN*bN
```

The vectors are classified as orthogonal if the dot product equals zero.


Complete the function that accepts two sequences as inputs and returns `true` if the vectors are orthogonal, and `false` if they are not. The sequences will always be correctly formatted and of the same length, so there is no need to check them first.


## Examples
```
[1, 1, 1], [2, 5, 7]        --> false
[1, 0, 0, 1], [0, 1, 1, 0]  --> true
```

Difficulty: introductory

Starter code:

def is_orthogonal(u, v):
	

Solutions:
def is_orthogonal(u, v): 
    return sum(i*j for i,j in zip(u,v)) == 0

def is_orthogonal(u, v):
    return sum(a*b for a, b in zip(u, v)) == 0

from numpy import dot

def is_orthogonal(u, v): 
    return not dot(u,v )

def is_orthogonal(u, v):
    dot_product = 0
    for pair in zip(u, v):
        dot_product += pair[0] * pair[1]
    return dot_product == 0

from operator import mul
def is_orthogonal(u, v): 
    return not sum(map(mul, u, v))

def is_orthogonal(u, v): 
    return not sum(a * b for a, b in zip(u, v))

def is_orthogonal(u, v): 
    # your code here
    count = list()
    
    for x, y in zip(u, v):
        multiply = x * y
        count.append(multiply)
        
    result = sum(count)
    if result != 0:
        return False
    else:
        return True


is_orthogonal = lambda u, v: not sum(a * b for a, b in zip(u, v))

import numpy
def is_orthogonal(u, v): 
    c=numpy.dot(u,v)
    if c:
        return False
    return True


is_orthogonal=lambda*u:not sum(list(map(int.__mul__,*u)))