Americans are odd people: in their buildings, the first floor is actually the ground floor and there is no 13th floor (due to superstition).

Write a function that given a floor in the american system returns the floor in the european system.

With the 1st floor being replaced by the ground floor and the 13th floor being removed, the numbers move down to take their place. In case of above 13, they move down by two because there are two omitted numbers below them.

Basements (negatives) stay the same as the universal level.

[More information here](https://en.wikipedia.org/wiki/Storey#European_scheme)

## Examples

```
1  =>  0 
0  =>  0
5  =>  4
15  =>  13
-3  =>  -3
```

Difficulty: introductory

Starter code:

def get_real_floor(n):
	

Solutions:
def get_real_floor(n):
    if n <= 0: return n
    if n < 13: return n-1
    if n > 13: return n-2

def get_real_floor(n):
    return n if n < 1 else n - 1 if n < 13 else n - 2

def get_real_floor(n):
    return n - (1 if n < 13 else 2) if n > 0 else n

def get_real_floor(n):
    return n - (n > 0) - (n > 13)

def get_real_floor(n):
    return n-2 if n > 13 \
      else n-1  if n > 0 \
      else n

def get_real_floor(n):
    if n > 0 and n >= 13:return n - 2
    elif n > 0 and n < 13: return n - 1 
    else: return n

def get_real_floor(n):
    if n == 1:return 0
    elif n == 15:return 13
    elif n == 0:return 0
    else:
        if n > 0 and n < 13:return n - 1
        elif n > 0 and n > 13:return n - 2
        else:return n

def get_real_floor(n):
  return n if n < 1 else (n - 2 if (n > 13) else n - 1)

def get_real_floor(n):
    if n <= 0:
        return n
    return n - 1 - (n >= 13)

def get_real_floor(n):
    if 1 <= n < 13:
        return n - 1
    if 13 <= n:
        return n - 2
    if  n <= 0:
        return n

def get_real_floor(n):
    if n<=0:
        return n
    elif n<14:
        return n-1
    elif n==14:
        return 12
    else:
        return n-2

def get_real_floor(n):
    return n - 1 - (n > 13) if n > 0 else n

def get_real_floor(n):
    
    return n - 1 * (n>0) - 1 * (n>13)

def get_real_floor(n):
    if n <= 0: return n
    elif 0 < n < 13: return n - 1
    elif n > 13: return n - 2

def get_real_floor(n):
    return n - 2 if n > 13 else n - 1 if n > 0 else n

get_real_floor = lambda n: n - ((n > 0) + (n > 12))

def get_real_floor(n):
    return n - (n > 0) * ((n > 0) + (n > 13))

def get_real_floor(n):
    return n if n<0 else 0 if n <=1 else n-1 if n<13 else n-2

def get_real_floor(n):
    return n - (n > 0) - (n > 12)

def get_real_floor(n):
    if n<1:
        return n
    ls=[]
    for i in range(1,n+1):
        if i==13:
            pass
        else:
            ls.append(i)
    return ls.index(n)  #I solved this Kata on  8/21/2019  11:07 PM...#Hussam'sCodingDiary

get_real_floor = lambda n: n if n <= 0 else n - 1 - int(n >= 13)

def get_real_floor(n):
    if n <= 0:
        return n
    
    else:
        ans = n - 1
        
    if n > 13:
        ans = ans - 1
    
    return ans

def get_real_floor(n):
    return (n - 1) + (n <= 0) - (n > 13)

def get_real_floor(n):
    if n > 0:
       return n - (1 + int(n >= 13))
    return n


def get_real_floor(n):
    return [n, n-[2, 1][n < 13]][n > 0]  # fun

def get_real_floor(n):
    return [n, n-[2, 1][n < 13]][n > 0]  # fun logic

def get_real_floor(n):
    return n - [2,1][n < 13] if n > 0 else n

get_real_floor = lambda n: n - (n > 0) - (n > 13)

def get_real_floor(n: int) -> int:
    """ Get the floor in the european system based on the floor in the american system. """
    return sum([n, {0 < n < 13: -1, n >= 13: -2}.get(True, 0)])

def get_real_floor(n):
    if n >0 and n<13:
        return n-1
    elif n > 13:
        return n-2
    else:
        return n

def get_real_floor(n):
    # code here
    if n ==0:
        return 0
    elif n>0 and n <= 13:
        n=n-1
        return n
    elif n>0 and n>13:
        n=n-2
        return n
    elif n < 0:
        return n

def get_real_floor(n):
    return n - 1 - int(n >= 13) if n > 0 else n

def get_real_floor(n):
    if n>13:
        f = n-2
    elif n>1 and n<13:
        f = n-1
    elif n<0:
        f = n
    else: f = 0
    return f

def get_real_floor(n):
    # code here
    if n > 13:
        return n-2
    if n < 13 and n > 1:
        return n-1
    if n < 0:
        return n
    else: return 0

def get_real_floor(n) :
    if n > 13:
        return n - 2 
    if n>1 and n<13:
        return n-1
    if n<0:
        return n 
    else:
        return 0

def get_real_floor(n):
    if (n < 13):
        if n < 0:
            o=n
        elif n == 0:
            o=0
        else:
            o = n-1
    elif n == 13:
        o = 0
    else:
        o = n-2
    return o

def get_real_floor(n):
    if 1 <= n <= 12:
        n = n-1
    elif 14 <= n:
        n = n-2
    else: 
        n = n
    
    return n

def get_real_floor(n):
    if n == 0:
        return 0
    if 0 < n <= 13:
        return n-1
    
    return n-2 if n > 13 else n

def get_real_floor(n):
    return 0 if n == 0 or n == 1 else n - 1 if 1 < n <= 13 else n - 2 if n > 13 else n

def get_real_floor(n):
    if n == 15:
        return 13
    elif n == 0:
        return 0
    elif n >=1 and n < 14:
        return (n-1)
    elif n < 0:
        return n
    else:
        return (n-2)
    # code here


def get_real_floor(n):
    if 0<n<=13:
        return n-1
    elif n>13:
            return n-2
        
    elif n<0:
        return n
    else:
        return 0

def get_real_floor(n):
    if n <= 0:
        return n
    elif 0 < n <= 12:
        return n - 1
    elif n >= 13:
        return n - 2

def get_real_floor(n):
    return n - 2 if n > 13 else n - 1 if n < 13 and n > 0 else n

def get_real_floor(n):
    if (n < 0):
        return n
    if (n == 0 or n == 1):
        return 0
    elif (2 <= n <= 12):
        return n-1
    else:
        return n-2

get_real_floor=lambda n:n-1-(n>12)+(n<=0)

def get_real_floor(n):
    if n<0: return n
    elif n>0 and n<13: return n-1
    elif n==0: return 0
    else: return n-2

def get_real_floor(n):
    if n > 13:
        return n - 2
    elif n > 1 and n < 13:
        return n - 1
    elif n == 1:
        return 0 
    else:
        return n

def get_real_floor(n):
    return n - (n>0 and 1) - (n>13 and 1)

def get_real_floor(n):
    return n - 2 if n > 13 else n - 1 if n >= 1 else n

def get_real_floor(n):
    return n-1 if n<13 and n>0 else n if n<=0 else n-2 if n>13 else n

def get_real_floor(n):
    # code here
    if n<0:
        return n
    elif n>0 and n<=12:
        return n-1
    elif  n>12 :
        return n-2
    else:
        return 0 
        


def get_real_floor(n):
    if n < 0:
        return n
    elif n == 0:
        return n
    elif n >= 13:
        return n-2
    else:
        return n-1

def get_real_floor(n):
    if n > 13:
        return n - 2
    if n >= 1:
        return n - 1
    else:
        return n

def get_real_floor(n):
    if 0 < n < 13:
        return n - 1 
    elif n > 13:
        return n - 2
    else:
        return n
#     return n-1 if 0 < n < 13 else


def get_real_floor(n):
    if n>0:
        if n<13:
            n=n-1
        else:
            n=n-2
    
    return n

def get_real_floor(n):
    floor=0
    if n>=1:
        floor-=1
    if n>=13:
        floor-=1
    return n + floor

def get_real_floor(n):
    if n == 0:
        return 0
    elif n < 0:
        return n
    return n - 1 if n <= 13 else n - 2

def get_real_floor(n):
    if n <= 0:
        return n
    if n > 0 and n < 14:
        return n-1
    else:
        return n-2

def get_real_floor(n):
    if n == 0:
        return 0
    elif 13 > n > 0:
        return n - 1
    elif n > 13:
        return n - 2
    else:
        return n

def get_real_floor(n):
    return n-1 if 0 < n < 13 else n-2 if n > 12 else n

get_real_floor = lambda n: n-1 if n > 0 and n < 13 else n-2 if n > 12 else n

def get_real_floor(n):
    if n == 1:
        return 0
    if n > 13:
        return n - 2
    if n < 0:
        return n
    if n > 0 and n < 13:
        return n - 1
    return 0

def get_real_floor(n):
    if 1 <= n <= 12:
        return n - 1
    elif n <=0:
        return n
    else:
        return n - 2

def get_real_floor(n):
    if n>0 and n<13:
        real_floor=n-1
        return real_floor
    if n >=13:
        real_floor=n-2
        return real_floor
    if n<=0:
        real_floor=n
        return real_floor

def get_real_floor(n):
    return n-1 if 1 <= n <= 13 else n if n < 1 else n - 2

def get_real_floor(n):
    if n == 0 or n == 1:
        return 0
    elif n < 0:
        return n
    elif n < 14:
        return n - 1
    else:
        return n - 2

def get_real_floor(n):
    return n - 1 if (n > 0 and n <= 13) else n - 2 if n > 13 else n

def get_real_floor(n):
    if n > 13:
        n = n - 1
    if n > 0:
        n = n - 1
    return n

def get_real_floor(n):
    if n == 0: return 0
    elif n > 0: return n - 1 if n <= 13 else n - 2
    else: return n

def get_real_floor(n):
    if n>0:
        return n-1 if n<13 else n-2
    if n<=0:
        return n

def get_real_floor(n):
    floors = n-1
    top = n-2
    basement = n
    if n >= 1 and n < 13:
        return floors
    elif n <=0:
        return basement
    else:
        return top


def get_real_floor(n):
    return n-1 if n>=1 and n<=12 else n-2 if n>12 else 0+n

def get_real_floor(n):
    if n == 0 or n == 1:
        return 0
    elif n < 0:
        return n
    elif n > 13:
        return n-2
    elif n < 13:
        return n-1
    return n-1

def get_real_floor(n):
    return 0 if n == 0 else 0 if n == 1 else n if n < 0 else n - 1 if n < 13 else n - 2

def get_real_floor(n):
    print(n)
    if n == 0:
        return 0
    if n < 13 and n > 0:
        return n - 1
    elif n < 0:
        return n
        
    else:
        return n - 2

def get_real_floor(n):
    if n<1:
        return n
    elif n==1:
        return 0
    elif n>1 and n<=13:
        return n-1
    elif n>13:
        return n-2

def get_real_floor(n):
    if n == 0:
        return 0
    elif n < 0:
        return n
    elif n < 13:
        return n - 1
    return n - 2

def get_real_floor(n):
    if n < 0:
        return n
    if n > 13:
        return n - 2
    else:
        return max(0, n - 1)

def get_real_floor(n):
    if 0<=n<=1:
        return 0
    elif n>13:
        return n-2
    elif 1<n<=13:
        return n-1
    else:
        return n

def get_real_floor(n):
    if n <= 0:
        return n
    if 0 < n < 13:
        return n-1
    if 13 < n:
        return n-2

def get_real_floor(n):
    if 0<n<=13:
        return n-1
    if n>13:
        return n-2
    else:
        return n

def get_real_floor(n):
    if n == 0:
        return 0 
    elif n > 0 and n <= 13:
        return n - 1
    elif n > 13:
        return n - 2
    else:
        return n

def get_real_floor(n):
    if n < 14 and n >= 1:
        return n-1
    if n >= 14:
        return n-2
    if n == -1:
        return n+1  
    else:
        return n

def get_real_floor(n):
    if n < 1:
        return n
    elif 1<=n<=12:
        return n-1
    elif n >= 13:
        return n-2

def get_real_floor(n):
    if n < 1:
        return n
    return n-2 if n>13 else n-1

def get_real_floor(n):
    if n == 0 or n ==1:
        print((0))
        return 0
    if n<13 and n>1:
        print((n-1))
        return n-1
    if n>13:
        print((n-2))
        return n-2
    return n


def get_real_floor(n: int) -> int:
    return 0 if n == 1 or n == 0 else n - 2 if n > 13 else n if n < 0 else n - 1

def get_real_floor(n):
    if 0 < n < 14:
        return n - 1
    if 13 < n:
        return n - 2
    else:
        return n

def get_real_floor(n):
    if 0<n<13:
        return n-1
    elif n>=13:
        return n-2
    elif n <=0:
        return n

def get_real_floor(n):
    if n<=0:
        return n
    elif n<=1 or n<=12:
        return n-1
    else:
        return n-2

def get_real_floor(n):
    if 1 <= n <= 13:
        return n - 1
    elif n >= 14:
        return n - 2
    else:
        return n

def get_real_floor(n):
    if 0 < n <= 13:
        return n -1
    elif n > 13:
        return n - 2

    return n

def get_real_floor(n):
    if n<=0:
        return n
    elif(n>0 and n!=13 and n<14):
        return (n-1)
    else:
        return(n-2)

def get_real_floor(n):
    if n < 0:
        return n
    return max(0, n - 1) if n < 13 else n - 2

def get_real_floor(n):
    if 0 < n <= 13:
        n = n - 1
    else:
        if n > 13: 
            n = n - 2
    return n

def get_real_floor(n):
    if n >= 13:
        return n-2
    if n > 0:
        return n-1
    else:
        return n

def get_real_floor(n):
    if n < 0:
        return n
    elif n == 0:
        return 0
    elif n == 1:
        return 0
    elif n < 13:
        return n - 1
    else:
        return n - 2

def get_real_floor(n):
    if n == 0 or n < 0:
        return n
    elif n in range(1, 14):
        return n - 1
    elif n > 13:
        return n - 2

def get_real_floor(n):
    if n == 1 or n == -1:
        return 0
    elif n <= 0:
        return n
    elif n < 13:
        return n - 1
    else:
        return n - 2

def get_real_floor(n):
    if n <=0:
        return n
    elif n <= 13:
        return n - 1
    elif n == 15:
        return 13
    else:
        return n - 2