# Convert number to reversed array of digits

Given a random non-negative number, you have to return the digits of this number within an array in reverse order.

## Example:

```
348597 => [7,9,5,8,4,3]
```

Difficulty: introductory

Starter code:

def digitize(n):
	

Solutions:
def digitize(n):
    return [int(x) for x in str(n)[::-1]]

def digitize(n):
    return [int(x) for x in reversed(str(n))]

def digitize(n):
    result = []
    while n >= 1:
        result.append(n%10)
        n //= 10
    return result

def digitize(n):
    return [int(c) for c in str(n)[::-1]]

def digitize(n):
    return [int(x) for x in (str(n))][::-1]


def digitize(n):
    l = []
    m = []
    n = str(n)
    n = n[::-1]
    for i in range(len(n)):
        l.append(int(n[i]))
    return l

def digitize(n):
    return [int(i) for i in str(n)][::-1]


def digitize(n):
    return list(reversed([int(s) for s in str(n)]))

def digitize(n):
    mylist = [int(i) for i in str(n)]
    mylist.reverse()
    return mylist


def digitize(n):
    d, r = divmod(n, 10)
    if d:
        return [r] + digitize(d)
    else:
        return [r]

def digitize(n):
    new_list = list(int(x) for x in str(n))
    return new_list[::-1]


import re

def digitize(n):
    answer = []
    l= re.findall('\d', str(n))
    for i in l:
         answer.append (int(i))
    answer.reverse()
    return answer

def digitize(n):
    num_array = [] # make empty array
    for number in str(n): # make n into string to interate through 
        num_array.insert(0, int(number)) # insert number into 1st position (reverses it)
    return num_array # return array

def digitize(n):
    result = []
    while n > 0:
        result.append(n % 10)
        n = int(n/ 10)
    return result

digitize = lambda n: [int(e) for e in str(n)[::-1]]

digitize = lambda n: [int(x) for x in str(n)][::-1]


def digitize(n):
    return list(int(x) for x in str(n)[::-1])

def digitize(n):
    n=str(n)
    arr=[]
    for u in n:
        arr.append(int(u))
    arr=arr[::-1]
    return arr

digitize = lambda n: [int(x) for x in reversed(str(n))]

def digitize(n):
    return [int(digit) for digit in str(n)[::-1]]

def digitize(n):
    return [int(d) for d in str(n)[::-1]]

digitize = lambda n: list(reversed([int(i) for i in str(n)]))

def digitize(n):
    return [int(i) for i in reversed(str(n))]

def digitize(n):
    k = [int(num) for num in str(n)]
    k.reverse()
    return k

def digitize(n):
    b = []
    for i in str(n):
        b.append(int(i))
    return b[::-1]

def digitize(n):
    output = []
    for digit in str(n):
        output.append(int(digit))
    return(output[::-1])

def digitize(n):
    n = str(n)
    n_list = list(map(int, str(n)))
    n_list.reverse()
    return n_list



def digitize(n):
    return list(reversed([int(x) for x in str(n)])) #reversed(sequence),here sequence
                                                    #is a list comprehension returns an 
                                                    #object which is accessed by using a list
                                                    #which is in this case.


def digitize(n):
    n=str(n)
    l=[]
    c=list(n)
    c.reverse()
    for i in c:
        l.append(int(i))
    return l

def digitize(n):
    a=[]
    while n!=0:
        a.append(n%10)
        n=n//10
    return a

def digitize(n):
    arr = []
    result = n
    
    shouldGo = True
    
    while shouldGo:
        arr.append(result % 10)
        
        result = result // 10
        
        if result == 0:
            shouldGo = False
    
    return arr

def digitize(n):
    arr = []
    convertToString = str(n)
    for num in  convertToString:
        arr.append(int(num))
    arr.reverse()
    return arr

def digitize(n):
    return [int(i) for i in str(n)[::-1]]

def digitize(n):
    return list(map(int, str(n)))[::-1]

def digitize(n):
    d = [int(i) for i in str(n)]
    p = d[::-1]
    return p


def digitize(n):
    result = []
    for d in str(n)[::-1]:
        result.append(int(d))
    return result

def digitize(n): 
    lista = str(n)
    listan = list(lista)
    listan.reverse()
    for i in range(0, len(listan)):
        listan[i] = int(listan[i])
    return listan



def digitize(n):
    n = str(n)
    digits = [int(s) for s in n]
    return digits[::-1]

def digitize(n):
    return [n % 10] + digitize(n//10) if n > 10 else [n % 10]

def digitize(n):
    ls = list(str(n))
    a = ls[::-1]
    return [int(x) for x in a]


def digitize(n):
    r = []
    res = str(n)
    for i in res:
        r.append(int(i))
        
    return r[::-1]


def digitize(n):
    a =  [int(x) for x in str(n)]
    b = a[::-1]
    return b

def digitize(n):
    num = []
    z = str(n)
    for i in z:
        num.append(int(i))
    return num[::-1]

def digitize(n):
    x = str(n)
    y = ""
    lst = []
    for char in x:
        y = char + y
    for char in y:
        lst.append(int(char))
    return lst

def digitize(n):
    
    res=[int(i) for i in str(n)][::-1]
    return res

def digitize(n):
    result = array = [int(x) for x in str(n)]
    result = result[::-1]
    return result 

digitize = lambda input: [int(x) for x in str(input)][::-1]

def digitize(n):
    n = str(n)
    n = n[::-1]
    res = []
    for i in n:
        res.append(int(i))
    
    return res

def digitize(n):
    x = [int(i) for i in str(n)]
    return [i for i in reversed(x)]

def digitize(n):
    rez = []
    for i in list(str(n)[::-1]):
        rez.append(int(i))
    return rez

def digitize(n):
    x = ','.join(str(n))[::-1]
    result=[]
    for i in x.split(','):
        result.append(int(i))
    return result

def digitize(n):
    str_arr = list(str(n)[::-1])
    int_arr = []
    for i in str_arr:
        int_arr.append(int(i))
    return int_arr

def digitize(num):
    if len(str(num)) == 1:
        return num
    output = []
    for n in reversed(str(num)):
        output.append(int(n))
    return output

def digitize(n):
    results = []
    for num in str(n)[::-1]:
        results.append(int(num))
    return results

def digitize(n):
    results = []
    for x in range(len(str(n))):
        results.append(int(str(n)[len(str(n)) - x - 1]))
    return results

def digitize(n):
    string_of_int = (str(n))
    final_array = [int(x) for x in string_of_int]
    return(final_array[::-1])

def digitize(n):
    list = []
    while n>0:
        list.append(int(n%10))
        n = int(n/10)
    return list

def digitize(n):
    n = str(n)
    l = list()
    n = n[::-1]
    for s in n:
        l.append(int(s))
    return l


def digitize(n):
    num = [int(m) for m in str(n)]
    return (num[::-1])

def digitize(n):
    mylist = []

    a = list(str(n))
    for i in a:
         mylist.append(int(i))
    
    mylist.reverse()
    return mylist

def digitize(n):
    d = [int (array) for array in list(str(n))]
    d.reverse()
    return d

def digitize(n):
    a = list(reversed(str(n)))
    k = []
    for i in a:
        k.append(int(i)) 
    return k 
    
        
        
    
    
    
   
        


def digitize(n):
    string_num = str(n)
    digits = []
    for digit in string_num:
        digits.append(int(digit))
    digits.reverse()
    return digits

def digitize(n):
    n = str(n)
    n = list(n)
    n = list(map(conv, n))
    n.reverse()
    return n
    

def conv(x):
    return int(x)

def digitize(n):
    copy = []
    array = list(str(n))
    for num in array:
        copy.append(int(num))
    copy.reverse()
    return copy

def digitize(n):
    lista = list(str(n))
    lista.reverse()
    int_list = []
    for i in lista:
        int_list.append(int(i))
    
    return int_list

def digitize(n):
    list_n = list(str(n))
    list_n.reverse()
    return list(map(int, list_n))

def digitize(n):
    string_num = str(n)
    res = []
    comp = [res.append(int(number)) for number in string_num]
    res.reverse()
    return res


def digitize(n):
    empty = []
    n = str(n)
    n = n[::-1]
    for num in n:
        empty.append(int(num))
    return empty

def digitize(n):
    a = []
    b = str(n)
    for i in b:
        a.append(int(i))
    return a[::-1]

def digitize(n):
    s = list(reversed(str(n)))
    a = [];
    for x in s:
        m = int(x)
        a.append(m)
    return a

def digitize(n):
    result = []
    if(n == 0):
        return [0]
    while(n):
        result.append(n % 10)
        n //= 10
    return result

def digitize(n):
    n = str(n)
    n = n[::-1]
    n = ' '.join(n)
    return [int(i) for i in n.split()]

def digitize(n):
    x=list(str(n))
    y=[]
    for i in range(len(x)-1,-1,-1):
        y.append(int(x[i]))
    return y

import numpy as np

def digitize(n):
    return [int(i) for i in str(n)[::-1]]


def digitize(n):
    x = list(map(lambda x: int(x), list(str(n))))
    x.reverse()
    return x

def digitize(n):
    ls = []
    for i in range(len(str(n))):
        ls.append(n % 10)
        n //= 10
    return ls

def digitize(n):
    s=str(n)
    a=[]
    for i in range(1,len(s)+1):
        a.append(s[-i])
    for j in range(len(a)):
        a[j]=int(a[j])
    return a

def digitize(n):
    listn = []
    for x in str(n):
        listn.append(int(x))
    revl = listn[::-1]
    return revl

def digitize(n):
    arr = list(str(n))
    rev = []
    for i in arr:
        rev.insert(0, int(i))
    return rev

def digitize(n):
    result = list(int(x) for x in str(n))
    return result[::-1]

def digitize(n):
    
    lst = [int(i) for i in str(n)]
    #lst = lst.reverse()
    return lst[::-1]

def digitize(n):
    res = [int(i) for i in list(str(n))]
    return res[::-1]

def digitize(n):
    num_list = list(str(n))
    reversed_num_list = num_list.reverse()
    reversed_num_list = list(map(int,num_list))
    return reversed_num_list

def digitize(n):
    lst = []
    n = str(n)
    
    for char in n:
        lst.append(int(char))
        
    lst = lst[::-1]
    
    return lst

def digitize(n):
    
    array = []
    
    n = str(n)
    x = len(n) - 1
    
    while(x >= 0):
        array.append(int(n[x]))
        x -= 1
    
    return array

def digitize(n):
    n=str(n)
    l=[]
    for elem in n:
        l.append(int(elem))  
    l.reverse()
    return l

def digitize(n):
    s=[int(i) for i in str(n)]
    return s[::-1]

digitize = lambda n : [int(digit) for digit in str(n)][::-1]

def digitize(n):
    n = list(str(n))
    l = []
    for i in n:
        a = int(i)
        l.append(a)
    return l[::-1]

def digitize(n):
    
    new=[]
    for I in str(n):
        new.append(int (I))
    
    return new[::-1]


def digitize(n):
    len_n = str(n)
    list = []
    for i in range(0,len(len_n)):
        
        a = n % 10
        n = n//10
        
        list.append(a)
    
    return list