# 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]
```

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Data structures

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):
	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 = []
	for number in str(n):
		num_array.insert(0, int(number))
	return num_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):
	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):
	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 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):
	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):
	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):
	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):
	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


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