In this kata you will create a function that takes in a list and returns a list with the reverse order.

### Examples

```python
reverse_list([1,2,3,4]) == [4,3,2,1]
reverse_list([3,1,5,4]) == [4,5,1,3]
```

Difficulty: introductory

Starter code:

def reverse_list(l):
	

Solutions:
def reverse_list(l):
  return l[::-1]

def reverse_list(l):
  """return a list with the reverse order of l"""
  return list(reversed(l))

def reverse_list(l):
  l.reverse()
  return l

def reverse_list(l):
  """ Returns reversed list. """
  return list(reversed(l))

def reverse_list(l):
  'return a list with the reverse order of l'
  return l[::-1]  # This was dumb

reverse_list = lambda l: l[::-1]


def reverse_list(l):
  return [r for r in reversed(l)]

reverse_list = lambda l: l.reverse() or l


def reverse_list(l):
  """Return a list with the reverse order of l"""
  return l[::-1]

def reverse_list(l):
  new_list = []
  for i in l:
      new_list = [i] + new_list
  return new_list

def reverse_list(liste):
    liste.reverse()
    return liste

reverse_list = lambda L: L[::-1]

def reverse_list(l):
    return [l[-1]] + reverse_list(l[:-1]) if len(l) > 0 else []

from typing import List

def reverse_list(l: List[int]) -> List[int]:
    """ Get a list with the reverse order. """
    return l[::-1]

def reverse_list(*l):
    x = []
    for x in l:
        x.reverse()
        print(x)
    return x

def reverse_list(l):
  'return a list with the reverse order of l'
  c = [0] * len(l)
  for i in range(len(l)):
      c[i] = l[len(l) - i - 1]
  return c

def reverse_list(l):
  'return a list with the reverse order of l'
  index = len(l)
  i = index -1
  temp = []
  while i!=-1:
      temp.append(l[i])
      i-=1
  return temp


def reverse_list(l):
    c = -1
    d = []
    for i in l:
        d.append(l[c])
        c -= 1
    return d

def reverse_list(l):
  #'return a list with the reverse order of l'
  re = []
  for i in range(0,len(l)):
    re.append(l.pop())   
  return re

def reverse_list(l):
  return l[4::-1]

def reverse_list(l):
    reverse = [l[-i] for i in range(1, len(l)+1)]
    return reverse

def reverse_list(l):
    return l[-1:-(len(l) + 1):-1]

def reverse_list(l):
    l_list = list(reversed(l))
    return l_list


def reverse_list(l):
    output=[]
    for i in l:
        output=[i]+output
    return output

def reverse_list(l):
    return [l[len(l)-1-n] for n in range(len(l))]

def reverse_list(l):
    list1 = []
    length = len(l)
    for x in range(length - 1, -1, -1):
        list1.append(l[x])
    return list1


reverse_list = lambda l: l[::-1]
#   'return a list with the reverse order of l'


def reverse_list(l):
    lista = list()
    for x in l:
        lista.insert(0,x)
    return lista

def reverse_list(list_):
    return list_[::-1]

def reverse_list(l):
    a = []
    for i in range(0, len(l)):
        a.append(l[-1 - i])
    return a

def reverse_list(args):
    args.reverse()
    return args
    'return a list with the reverse order of l'

def reverse_list(l):
    x = []
    for i in range(1, len(l)+1):
        x.append(l[-i])
    return x

def reverse_list(l):
    reversedList = []
    for i in reversed(l): 
        reversedList.append(i)
    return reversedList

def reverse_list(lst):
    reversed_lst = []
    
    for item in lst:
        reversed_lst.insert(0, item)
        
    return reversed_lst

def reverse_list(l):
    return l[-1:-len(l)-1:-1]

def reverse_list(l):
    m = []
    for x in reversed(l):
        m.append(x)
    return m

def reverse_list(l):
    v=[];
    for i in reversed(l):
        v.append(i);
    return v;

def reverse_list(l):
  ###'return a list with the reverse order of l'
    return l[::-1]

def reverse_list(l):
    arr=[]
    for i in range(len(l)):
        arr.append(l[len(l)-1-i])
    return arr

def reverse_list(l):
    start = 0
    end = len(l) - 1
    while(start < end):
        l[start], l[end] = l[end], l[start]
        start += 1
        end -= 1
    return l

def reverse_list(l):
  rev = []
  up = len(l) - 1

  for i in range(up, -1, -1):
    rev.append(l[i])

  return rev

def reverse_list(xs):
    return list(reversed(xs))

def reverse_list(l):
    c = []
    for x in l[::-1]:
        if x != None:
            c.append(x)
    return c

def reverse_list(l):
    answer = []
    for e in l:
        answer.insert(0, e)
    return answer

def reverse_list(l):
    return [l[index] for index in range(-1,-len(l)-1,-1)]

def reverse_list(l):
    arr = []
    if len(l) == 0:
        return arr
    for i in l:
        arr.append(i)
    arr.reverse()
    return arr

reverse_list = lambda o : [i for i in reversed(o)]

def reverse_list(l):
  res = l[::-1]
  return res

def reverse_list(l):
    rl = l
    l.reverse()
    return l

def reverse_list(l):
    newL=list()
    for i in l[::-1]:
        newL.append(i)
    return newL

def reverse_list(l):
  'return a list with the reverse order of l'
  return(list(reversed(l)))

print(reverse_list.__doc__)

print(reverse_list([1,2,3,4,444]))

reverse_list = lambda l: l[::-1]

# reverse_list = lambda l: list(reversed(l))

# def reverse_list(l):
#   l.reverse()
#   return l


def reverse_list(l):
    length = len(l)
    reversed_list = []
    index = -1
    print('len = ', length)
    print('reversed_list = ', reversed_list)
    
    for i in l:
        print(l[index])
        reversed_list.append(l[index])
        index -= 1
    return reversed_list

def reverse_list(l):
    tab=[]
    for x in range(len(l)):
        tab.append(l[-x-1])
        
    return tab

def reverse_list(l):
    return [ele for ele in reversed(l)] 
    #l.sort()
    #return l.reverse()


def reverse_list(l):
    
# =============================================================================
#     This function reverses the order of items in a given list.  If the given 
#     list is empty, the function returns an empty list
#     
#     Example:
#        reverse_list([1,2,3,4]) ==> [4,3,2,1]
# =============================================================================
    
    result = []
    
    if len (l) == 0:
        return result
    
    for item in l[::-1]:
        result.append(item)
            
    return (result)

def reverse_list(l):
    updt = []
    for i in reversed(l):
        updt.append(i)
    return updt


def reverse_list(l):
  'return a list with the reverse order of l'
  list = []
  for items in l: # Pour chaque "objet" dans la liste, on l'insert dans la nouvelle liste à la première position
      list.insert(0, items)
      print(list)
  return list

def reverse_list(l):
#   'return a list with the reverse order of l'
    new_lst = l[::-1] 
    return new_lst


def reverse_list(lst):
    l = lst.reverse()
    return lst

def reverse_list(l):
#   return l.reverse()
    return list(reversed(l))

def reverse_list(l):
# 'return a list with the reverse order of l'
   return l[::-1]


l = [1, 2, 3, 4]
print(reverse_list(l))

def reverse_list(l):
  i = 0
  size = len(l)
  while i < size:
      temp = l.pop(size-1-i)
      l.append(temp)     
      i += 1
  return l

def reverse_list(mylist):
   return mylist[::-1]

def reverse_list(l):
  return l[::-1]
  
  
l=[1,2,3,4,]

def reverse_list(l):
  'return a list with the reverse order of l'
  list.reverse(l)
  return l
  
  'first kata and im so happy :)'

def reverse_list(l):
    reversed_arr = []
    
    for i in range(len(l)):
        reversed_arr.append(l[len(l)- 1 - i])
    
    return reversed_arr

def reverse_list(l):
    res = []
    for i in reversed(l): res.append(i)
    return res

def reverse_list(l):
  'return a list with the reverse order of l'
  result = []
  counter = 0
  while counter < len(l):
      result.append( l[ -1 - counter]  )
      counter +=1
  return result    
  


def reverse_list(l):
  # There are 3 ways to reverse a list:
  # 1) return l[::-1]
  # 2) l.reverse()
  #    return l
  # 3) 
    return list(reversed(l))

def reverse_list(ls):
    ls.reverse()
    return ls


def reverse_list(l):
    x = []
    for item in l:
        x.insert(0, item)
    return x


def reverse_list(l):
  return [x for x in reversed(l)]
l=[1,2,3,4]
print((reverse_list(l)))


def reverse_list(l):
    rs = []


    for n in l:
        print(n)
        rs.insert(0, n)


    return rs




r = reverse_list([1, 2, 3, 4])


print(r)

def reverse_list(l):
  return ([int(x) for x in l])[::-1]

def reverse_list(l):
    rs = []
    for n in l:
        rs.insert(0, n)
    return rs

def reverse_list(l):
    rs = []
    for n in l:
        rs.insert(0, n)
    return rs


r = reverse_list([1,2,3,4])

print(r)

def reverse_list(l):
  return l[::-1]
  
print(reverse_list([5, 6, 8, 9]))

def reverse_list(l):
    out = []
    for x in l:
        out = [x]+out
    return(out)

from typing import List


def reverse_list(l: List[int]) -> List[int]:
  return l[::-1]

def reverse_list(l):
  'return a list with the reverse order of l'
  return l[-1:(len(l) + 1) * -1:-1]

def reverse_list(l):
    print (l[::-1])
    return l[::-1]

def reverse_list(v):
  return list(reversed(v))

def reverse_list(l):
  return [v for v in reversed(l)]

def reverse_list(l):
     l = reversed(l)
     return list(l)

def reverse_list(l):
  r = []
  le = len(l)
  while le>0:
      r.append(l[le-1])
      le-=1
  return r
  


def reverse_list(l):
    i = len(l)-1
    n = []
    p = 0
    while p != len(l):
        n.insert(p,l[i])
        p += 1
        i -= 1
    return n

def reverse_list(l):
  'return a list with the reverse order of l'
  L=len(l)
  for i in range(L//2):
      l[i],l[L-i-1]=l[L-i-1],l[i]
  return l

def reverse_list(l):
  return [int(i) for i in ''.join(str(n) for n in l[::-1])]

def reverse_list(l):
  tmp = list.copy(l)
  counter = 0
  listIndex = len(tmp) - 1
  for i in l:
      l[counter] = tmp[listIndex]
      counter += 1
      listIndex -= 1
  return l

def reverse_list(l):
    #list1=[1,2,3,4]
    #print('Original List:', list1)

    l.reverse()

    print('Updated List:', l)
    return l

def reverse_list(l):
  'return a list with the reverse order of l'
  wynik = l.copy()
  wynik.reverse()
  return wynik

def reverse_list(l):
  ret = []
  for it in l:
      ret = [it] + ret
  return ret

def reverse_list(l):
    result = []
    i = len(l)
    while i > 0:
        i-=1
        result.append(l[i])
    return result

def reverse_list(l):
  'return a list with the reverse order of l'
  
  # lijst = [1,2,3,4]
  lijst_rev = l[::-1]
  return(lijst_rev)

def reverse_list(l):
  n=len(l)
  return l[::-1]

def reverse_list(l):
    l1=l[::-1]
    return l1

def reverse_list(l):
    li = []
    for n in range (0, len(l)):
        li.append(l[len(l)-n-1])
    return(li)

def reverse_list(l):
    r = reversed(l)
    return list(r)

def reverse_list(l):
    l.reverse()
    return l
l = [1, 2, 3, 4]
print("reverse_list(" + str(l) + ") == " + str(reverse_list(l)))
l = [3, 1, 5, 4]
print("reverse_list(" + str(l) + ") == " + str(reverse_list(l)))