Given 2 elevators (named "left" and "right") in a building with 3 floors (numbered `0` to `2`), write a function `elevator` accepting 3 arguments (in order):

- `left` - The current floor of the left elevator
- `right` - The current floor of the right elevator
- `call` -  The floor that called an elevator

It should return the name of the elevator closest to the called floor (`"left"`/`"right"`).

In the case where both elevators are equally distant from the called floor, choose the elevator to the right.

You can assume that the inputs will always be valid integers between 0-2.

Examples:

```python
elevator(0, 1, 0) # => "left"
elevator(0, 1, 1) # => "right"
elevator(0, 1, 2) # => "right"
elevator(0, 0, 0) # => "right"
elevator(0, 2, 1) # => "right"
```

Difficulty: introductory

Starter code:

def elevator(left, right, call):
	

Solutions:
def elevator(left, right, call):
    return "left" if abs(call - left) < abs(call - right) else "right"

def elevator(left, right, call):
    if abs(left-call) >= abs(right-call):
        return "right"
    else:
        return "left"

def elevator(left, right, call):
    return "left" if abs(left - call) < abs(right - call) else "right"

elevator=lambda l,r,c:'rliegfhtt'[abs(c-l)<abs(c-r)::2]

def elevator(left, right, call):
    return "right" if abs(right - call) <= abs(left - call) else "left"

def elevator(x, y, r):
    return ['left','right'][abs(r-x)>=abs(r-y)]

def elevator(left, right, call):
    delta_left = abs(left - call)
    delta_right = abs(right - call)
    if delta_left < delta_right:
        return 'left' 
    else:
        return 'right'


def elevator(left, right, call):
    return sorted([('right', right), ('left', left),], key = lambda x: abs(call - x[1]))[0][0]

def elevator(left, right, call):
    dr = abs(call - right)
    dl = abs(call - left)
    return "left" if dr > dl else "right"

def elevator(left, right, call):
     # Code on! :)
     distance_left=abs(call-left)
     distance_right=abs(call-right)
     if distance_right<=distance_left or right==call:
         return "right"
     else:
         return "left"
     


elevator = lambda left,right,call: 'left' if abs(call-left) < abs(call-right) else 'right'

elevator=lambda l,r,c: 'left' if abs(l-c)<abs(r-c) else 'right'

def elevator(left, right, call):
    return ['left', 'right'][abs(left - call) >= abs(right - call)]

def elevator(left: int, right: int, call: int) -> str:
    """ Get the name of the elevator closest to the called floor ("left"/"right"). """
    return "left" if abs(right - call) > abs(left - call) else "right" if abs(right - call) < abs(left - call) else "right"

def elevator(left, right, call):
    difleft = left-call
    difright = right-call
    
    if(call == left and call != right):
        return "left"
    if(call == right):
        return "right"
    if(left == right):
        return "right"
    if(difleft == difright):
        return "right"
    if(left>right and call<right):
        return "right"
    if(right>left and call<left):
        return "left"
    if(call > right and call > left and right > left):
        return "right"
    if(call > left and left > right):
        return "left"
    else:
        return "right"

def elevator(left, right, call):
    return ('right', 'left')[right < left <= call or call <= left < right]

elevator=lambda l,r,c:["right","left"][abs(l-c)<abs(r-c)]

elevator = lambda l, r, c: ("right", "left")[abs(c - l) < abs(c - r)]

def elevator(left, right, call):
    return 'left' if left == call and left != right or left > right and call > left or right > left and call < left else 'right'

def elevator(left, right, call):
    return "left" if (call - left)*(call - left) < (call - right)*(call - right) else "right"

def elevator(l, r, c):
    if l-c < 0:
        left = -(l-c)
    else: left = l-c
    if r -c < 0:
        right = -(r-c)
    else: right = r-c
    return 'left' if left < right else 'right'

def elevator(left, right, call):
    closest = "left"
    if abs(right - call) <= abs(left - call):
        closest = "right"
    return closest


def elevator(left, right, call):
    if abs(call - left) < abs(call - right):
        return "left"
    elif abs(call - right) < abs(call - left):
        return "right"
    elif abs(call - left) == abs(call - right):
        return "right"

def elevator(left, right, call):
    return 'right' if abs(left - call) == abs(right - call) else 'left' if  abs(left - call) < abs(right - call) else 'right'

def elevator(left, right, call):
    b=abs(left-call)
    j=abs(right-call)
    if b<j:
        return "left"
    else:
        return "right"

def elevator(left, right, call):
    print((left, right, call))
    if call == left and call != right:
        return 'left'
    elif call == right and call != left:
        return 'right'
    elif abs(right - call) < abs(left - call):
        return 'right'
    elif abs(right - call) > abs(left - call):
        return 'left'
    elif abs(right - call) == abs(left - call):
        return 'right'


def elevator(left, right, call):
    left_dist = abs(call - left)
    right_dist = abs(call - right)
    
    if left_dist >= right_dist:
        return 'right'
    else:
        return 'left'

def elevator(left, right, call):
    print(left, right, call)
    return "left" if abs(left-call) < abs(right-call) else "right"

def elevator(left, right, call):
    if abs(right - call) < abs(left - call): return 'right'
    elif abs(right - call) > abs(left - call): return 'left'
    elif abs(right - call) == abs(left - call): return 'right'



def elevator(left, right, call):
    r_dist = call - right
    l_dist = call - left
    if r_dist < 0:
        r_dist *= -1
    if l_dist < 0:
        l_dist *= -1
        
    if r_dist <= l_dist:
        return 'right'
    else:
        return 'left'


def elevator(left, right, call):
    return 'right' if right == call or right == left or abs(right-call)<=abs(left-call) else 'left'

elevator=lambda l,r,c:'rliegfhtt'[1-(abs(l-c)>=abs(r-c))::2]

def elevator(left, right, call):
    el1 =  abs (call - right)
    el2 = abs (call - left) 
    if el1 > el2:
        return ('left')
    else:
        return('right')


def elevator(left, right, call):
    
    l = left
    r = right
    c = call
    
    if l == r or (l == 2 and r == 0 and c == 1) or (l == 0 and r == 2 and c == 1):
        return "right"
    elif l == c:
        return "left"
    elif l > c > r or r < c < l or c < l < r or c > l > r:
        return "left"
    else:
        return "right"
    


def elevator(left, right, call):
    return abs(call - left) < abs(call - right) and 'left' or 'right'

def elevator(left, right, call):
    if left == right: return "right"
    elif left == call: return 'left'
    elif left < right <= call: return 'right'
    elif call < left < right: return 'left'
    elif left < right > call: return 'right'
    elif right < left < call: return 'left'
    elif right < call < left: return 'right'
    return 'right'

def elevator(left, right, call):
    if call == right:
        return 'right'
    elif call == left:
        return 'left'
    elif call == left and call == right:
        return 'right'
    elif abs(call - right) < abs(call - left) or abs(call-right) == abs(call-left):
        return 'right'
    else:
        return 'left'

def elevator(left, right, call):
    leftDiff = abs(call-left)
    rightDiff = abs(call-right)
    if leftDiff > rightDiff: 
        return 'right'
    elif leftDiff < rightDiff: 
        return 'left'
    else: 
        return 'right'

def elevator(left, right, call):
    l = ['left', 'right']
    return l[abs(left - call) >= abs(right - call)]

def elevator(left, right, call):
    if left==right or abs(left-call)==abs(right-call):
        return "right"
    elif abs(left-call)<abs(right-call):
        return "left"
    else:
        return "right"

def elevator(left, right, call):
    print(left, right, call)
    if call == right == left: return "right"
    elif call == left: return "left"
    elif call == right: return "right"
    elif abs(call-left) == abs(call-right): return "right"
    elif abs(call-left) < abs(call-right): return "left"
    else: return "right"

def elevator(left, right, call):
    if right == call: return 'right'
    elif left == call: return 'left'
    elif abs(left-call) < abs(right-call): return 'left'
    else: return 'right'
    


def elevator(left, right, call):
    a = abs(call - left)
    b = abs(call - right)
    return 'left' if b > a else 'right'

def elevator(left, right, call):
    if right == call:
        return 'right'
    elif left == call:
        return 'left'
    else:
        if abs(right - call) == 1:
            return 'right'
        elif abs(left - call) == 1:
            return 'left'
        else:
            return 'right'

elevator = lambda l, r, c: "right" if abs(c - r) <= abs(c - l) else "left"

def elevator(left, right, call):
    lc = abs(call-left)
    rc = abs(call-right)
    return 'left' if lc<rc else 'right' if rc<lc else 'right'

from itertools import product

foo, rl = list(product('012', repeat=3)), 'RRRLRRLRRRLLR'
bar, combos = list(rl + 'R' + rl[::-1]), dict()

for i in range(27): combos[foo[i]] = bar[i]
elevator = lambda l, r, c: 'right' if combos[(str(l), str(r), str(c))]=='R' else 'left'

def elevator(left, right, call):
    if left == call and right != call or abs(call-left) < abs(call-right):
        return 'left'
    return 'right'

elevator = lambda left, right, call: "left" if abs(right-call) > abs(left-call) else "right"
 
    


def elevator(left, right, call):
    if right == call and call == left: return "right"
    elif right == call: return "right"
    elif left == call: return "left"
    elif left > right and right> call: return "right"
    elif right > left and left > call: return "left"
    elif (right -call)>= (left-call): return "right"
    elif (call-right) <= (call-left): return "left"
    elif call > left and left > right: return "left"
    elif left > call and call > right: return "right"
    


def elevator(left, right, call):
    if left == right:
        return "right"
    elif left == 0 and call == 0:
        return "left"
    elif left == 1 and call == 1:
        return "left"
    elif left == 2 and call == 2:
        return "left"
    elif left == 1 and call == 2 and right == 0:
        return "left"
    elif left == 1 and call == 0 and right == 2:
        return "left"
    else:
        return "right"

def elevator(left, right, call):
    r = abs(right-call)
    l = abs(left-call)
    return 'right' if r <= l else 'left'

def elevator(left, right, call):
    return 'right' if right == left == call or abs(call - right) <= abs(call - left) else 'left' 

def elevator(left, right, call):
    if abs(right-call)==abs(left-call):
        return 'right'
    elif abs(right-call)<abs(left-call):
        return 'right'
    else:
        return 'left'

def elevator(left, right, call):
    if left==right:
        return "right"
    else:
        return "left" if abs(left-call)<abs(right-call) else "right"

def elevator(left, right, call):
    if left > right and left <= call:
        return 'left'
    elif left < right and left >= call:
        return 'left'
    else:
        return 'right'
    


def elevator(left, right, call):
    a,b = abs(call-right), abs(call-left)
    if a<=b:
        return 'right'
    return 'left'



def elevator(l, r, c): 
    ld=abs(l-c)
    rd=abs(r-c)
    if rd<=ld: return "right"
    else:return "left"

def elevator(left, right, call):
    if left == right:
        return 'right'
    return 'right' if -abs(call - left) <= -abs(call - right) else 'left'

def elevator(l, r, c):
    return 'left' if r>l>=c or r<l<=c else 'right'

def elevator(left, right, call):
    close_left = abs(call - left)
    close_right = abs(call - right)
    if close_right <= close_left:
        return "right"
    return "left"

def elevator(left, right, call):
    
    leftdist = abs(left - call)
    rightdist = abs(right - call)
    
    if leftdist == rightdist:
        return "right"
    elif leftdist > rightdist:
        return "right"
    else:
        return "left"

def elevator(left, right, call):

    
    diff_left = abs(left - call)
    
    diff_right = abs(right - call)
    
    
    if diff_left >= diff_right:
        
        return "right"
    
    if diff_left < diff_right:
        
        return "left"

def elevator(left, right, call):
    return "right" if (abs(call-right)<= abs(call-left)) else "left"
    # Code on! :)


def elevator(left, right, call):
    distance1 = abs(call - left)
    distance2 = abs(call - right)
    if distance2 <= distance1:
        result = "right"
    else:
        result = "left"
    return result

def elevator(left, right, call):
    if left == right:
        return 'right'
    elif abs(call - right) < abs(call - left):
        return 'right'
    elif abs(call - left) < abs(call - right):
        return 'left'
    elif abs(call - left) == abs(call - right):
        return 'right'

#import math
def elevator(left, right, call):
    if abs(call-left)<abs(call-right):
        return 'left'
    if abs(call-left)>abs(call-right):
        return 'right'
    return 'right'

def elevator(left, right, call):
    if call == left and call != right:
        return 'left'
    elif call > left > right or call < left < right:
        return 'left'
    else:
        return 'right'

import math
def elevator(left, right, call):
    diff1=abs(left-call)
    diff2=abs(right-call)
    if diff1<diff2:
        return 'left'
    elif diff2>diff1:
        return 'right'
    else:
        return 'right'

def elevator(left, right, call):
    print(left, right, call)
    return "right" if abs(left-call)>=abs(right-call) else "left"

def elevator(left, right, call):
    if right == call or abs(call-right) <= abs(call-left):
        return 'right' 
    return 'left'

def elevator(left, right, call):
    rt = abs(call - right)
    lt = abs(call - left)
    return "left" if rt > lt else "right"


def elevator(l, r, c):

    if l == c and r != c:
        return "left"
    elif r == c:
        return "right"
    elif c > r and r > l:
        return "right"
    elif r > c and c > l : 
        return "right"
    elif r == l and r != c:
        return "right"
    elif l > c and l > r:
        return "right"
    else:
        return "left"

def elevator(left, right, call):
    if call == left and call == right:
        return "right"
    elif call == left:
        return "left"
    elif call == right:
        return "right"
    elif left == right:
        return "right"
    else:
        return "left" if abs(call - left) < abs(call - right) else "right"

def elevator(left, right, call):
    # find absolute value of difference between L and call and R and call
    if abs(right-call) == abs(left-call): #if equal, return right
        return 'right'
    else: #return smallest number
        return ('right' if abs(right-call) < abs(left-call) else 'left')

def elevator(left, right, call):
    "return closest elevator"
    return "left" if abs(left-call) < abs((right - call)) else "right"

def elevator(left, right, call):
    if (abs(call - left) == abs(call - right)) or (abs(call - right) < abs(call - left)):
        return "right"
    else:
        return "left"


from math import fabs
def elevator(left, right, call):
    return 'left' if fabs(call - left) < fabs(call - right) else 'right'

def elevator(left, right, call):
    if int(right) == int(call) and int(left) == int(call):
        return("right")
    elif int(right) == int(call):
        return("right")
    elif int(left) == int(call):
        return("left")
    elif int(call) == 0 and int(left) < int(right):
        return("left")
    elif int(call) == 1 and int(left) > int(right):
        return("right")
    elif int(call) == 2 and int(left) > int(right):
        return("left")
    else:
        return("right")


def elevator(left, right, call):
    aa = abs(left - call)
    bb = abs(right - call)
    if aa < bb:
        return "left"
    else:
        return "right"

def elevator(left, right, call):
    if left == call and call != right:
        return "left"
    elif right == call and call != left:
        return "right"
    if abs(left - call) < abs(right - call):
        return "left"
    elif abs(left - call) > abs(right - call):
        return "right"
    return "right"

def elevator(left, right, call):
  d_left = left - call
  d_right = right - call
  if (d_left + d_right == 0 or abs(d_left) > abs(d_right) or d_left == d_right):
    return "right"
  else:
    return "left"


def elevator(left, right, call):
    isLeft = abs(call-left) < abs(call-right)
    return "left" if isLeft else "right"

def elevator(left, right, call):
    left_dist = abs(call - left)
    right_dist = abs(call - right)
    if right_dist <= left_dist:
        return 'right'
    else:
        return 'left'

def elevator(left, right, call):
    temp = [abs(call - left), abs(call - right)]
    if min(temp) == temp[0]:
        if min(temp) == temp[1]:
            return 'right'
        else:
            return 'left'
    else:
        return 'right'


def elevator(left, right, call):
    if left == right == call:
        return 'right'
    if left == call:
        return 'left'
    if right == call:
        return 'right'
    if abs(left-call) < abs(right-call):
        return 'left'
    else:
        return 'right'

def elevator(left, right, call):
    sum1 = abs(call-left)
    sum2 =  abs(call-right)
    if sum2 <= sum1:
        return "right"
    else:
        return "left"

def elevator(left, right, call):
    l_distance = abs(call - left)
    r_distance = abs(call - right)
    return 'left' if l_distance < r_distance else 'right'

def elevator(left, right, call):
    if abs(left - call) > abs(right - call):
        return "right"
    elif abs(left - call) < abs(right - call):
        return "left"
    elif left == right:
        return "right"
    else:
        return "right"


def elevator(left, right, call):
    if left==right:
        return 'right'
    elif left==call:
        return 'left'
    elif call-right==1 or right-call==1 or call==right:
        return 'right'
    else:
        return 'left'

def elevator(left, right, call):
    x,y=abs(call-right),abs(call-left)
    if x>y:
        return "left"
    elif x==y:
        return "right"
    else:
        return "right"
    pass # Code on! :)

def elevator(left, right, call):
    choice = 'right'
    if call != right:
        choice = ("left","right") [abs(call - left) >= abs(call - right)]
    return choice

def elevator(left, right, call):
    a = abs(call - left )
    b = abs(call - right)
    if a < b:
        return 'left'
    else:
        return 'right'

def elevator(left, right, call):
    x = call - left
    y = call - right
    if (left == call and right != call) or (right < left < call) or (call < left < right):
        return 'left'
    return 'right'


def elevator(left, right, call):

    if left == right and left == call: return 'right'
    if call == left:  return 'left'
    if call == right: return 'right'
    
    if abs(call - left) < abs(call - right): return 'left'
    else: return 'right'

def elevator(left, right, call):
    if abs(left - call) < abs(right - call):
        result = 'left'
    else:
        result = 'right'
    return result

elevator=lambda l,r,c:'right' if abs(r-c)<=abs(l-c) else 'left'

def elevator(left, right, call):
    return 'right' if left == call and right == call else 'right' if right == call else 'left' if left == call else 'right' if left - call == right - call else 'left' if abs(left - call) < abs(right - call) else 'right' 

def elevator(left, right, call):
    '''Return the closest elevator depending on the floor (call). If both are the same, return right'''
    left_distance = abs(call-left)
    right_distance = abs(call-right)
    if right_distance <= left_distance:
        return 'right'
    return 'left'

def elevator(left, right, call):
    d=abs(left-call)
    s=abs(right-call)
    if (d<s):
        return "left"
    else:
        return "right"