Write a function that rearranges an integer into its largest possible value. 

```python
super_size(123456) # 654321
super_size(105)    # 510
super_size(12)     # 21
```
``` haskell
superSize 123456 `shouldBe` 654321
superSize    105 `shouldBe`    510
superSize     12 `shouldBe`     21
```

If the argument passed through is single digit or is already the maximum possible integer, your function should simply return it.

Difficulty: EASY
Starter code: def super_size(n):
	

Solutions:
def super_size(n):
	return int(''.join(sorted(str(n), reverse=True)))


def super_size(n):
	b = list(str(n))
	b.sort(reverse=True)
	return int(''.join(b))


def super_size(n):
	return int(''.join(sorted(str(n)))[::-1])


super_size = lambda n: int(''.join(sorted(str(n), reverse=True)))


def super_size(n):
	list_ = sorted(list(str(n)))
	list_.reverse()
	return int(''.join(tuple(list_)))


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


def super_size(n):
	arr = list(map(int, str(n)))
	arr.sort(reverse=True)
	strings = [str(integer) for integer in arr]
	a_string = ''.join(strings)
	an_integer = int(a_string)
	return an_integer


def super_size(n):
	x = sorted(list(str(n)), reverse=True)
	return int(''.join(x))


def super_size(n):
	return int(''.join((str(x) for x in sorted([int(a) for a in str(n)], reverse=True))))


def super_size(n):
	digits = sorted([d for d in str(n)], reverse=True)
	return int(''.join(digits))


def super_size(n):
	new = list(str(n))
	new = sorted(new, reverse=True)
	new = ''.join(new)
	return int(new)


def super_size(n):
	digitList = list(str(n))
	if len(digitList) == 1:
		return n
	else:
		digitList.sort()
		digitList.reverse()
	largestValue = ''
	for digit in digitList:
		largestValue += digit
	return int(largestValue)


def super_size(n):
	if n < 0:
		raise ValueError
	elif n < 10:
		return n
	else:
		ans = sorted(str(n), reverse=True)
		return int(''.join(ans))


def super_size(n):
	l = [int(i) for i in str(n)]
	s = ''
	while len(l) > 0:
		s += str(l.pop(l.index(max(l))))
	return int(s)


def super_size(n):
	l = list(str(n))
	l = sorted(l, reverse=True)
	return int(''.join(l))


def super_size(num):
	res = [x for x in str(num)]
	Sorted_res = sorted(res, reverse=True)
	Sorted_string = ''.join(Sorted_res)
	return int(Sorted_string)


def super_size(n):
	li = list()
	p = ''
	for i in str(n):
		li.append(i)
	for j in range(len(li)):
		p += max(li)
		li.remove(max(li))
	return int(p)


def super_size(n):
	lista1 = list(str(n))
	lista = []
	for num in lista1:
		lista.append(num)
	for i in range(0, len(lista)):
		lista[i] = int(lista[i])
	lista.sort(reverse=True)
	lista_buna = int(''.join((str(i) for i in lista)))
	return lista_buna


def super_size(n):
	num_str = list(str(n))
	num_str.sort(reverse=True)
	res = int(''.join(num_str))
	return res


def super_size(n):
	li = list(str(n))
	li.sort(reverse=True)
	return int(''.join(li))


def super_size(n):
	li = list(str(n))
	li.sort()
	li.reverse()
	temp = ''
	for i in range(len(li)):
		temp += li[i]
	return int(temp)


def super_size(n):
	return int(''.join(list([str(x) for x in sorted([int(i) for i in str(n)], reverse=True)])))


def super_size(n):
	list = [str(i) for i in str(n)]
	list.sort(reverse=True)
	result = int(''.join(list))
	return result


def super_size(n):
	result = ''
	num = sorted([int(d) for d in str(n)])[::-1]
	for n in num:
		result += str(n)
	return int(result)


def super_size(n):
	temp = sorted(str(n), reverse=True)
	temp2 = ''
	for i in temp:
		temp2 += i
	return int(temp2)


def super_size(n):
	a = sorted(str(n), reverse=True)
	str1 = ''
	for i in a:
		str1 += i
	return int(str1)


def super_size(n):
	digits = [int(i) for i in str(n)]
	new_int = ''
	while digits:
		new_int += str(max(digits))
		digits.remove(max(digits))
	return int(new_int)


def super_size(n):
	lst = sorted([int(c) for c in str(n)], reverse=True)
	return int(''.join([str(i) for i in lst]))


def super_size(n):
	q = []
	for i in str(n):
		q.append(i)
	q.sort(reverse=True)
	q = ''.join(q)
	return int(q)


def super_size(n):
	a = str(n)
	c = list(a)
	d = sorted(c, reverse=True)
	z = ''
	for i in d:
		z += i
	return int(z)


def super_size(n):
	lis = []
	for i in str(n):
		lis.append(i)
	lis.sort(reverse=True)
	x = int(''.join(lis))
	return x


def super_size(n):
	x = list(str(n))
	z = []
	for k in x:
		z.append(int(k))
	z.sort()
	z = z[::-1]
	y = ''
	for k in z:
		y += str(k)
	y = int(y)
	return y


def super_size(n):
	s = ''
	a = sorted(str(n))[::-1]
	print(a)
	for j in a:
		s += str(j)
	return int(s)


def super_size(n):
	n_list = sorted([int(number) for number in str(n)], reverse=True)
	return int(''.join((str(number) for number in n_list)))


def super_size(n):
	bigest = ''
	amount = len(str(n))
	numbers = []
	n = str(n)
	for i in range(amount):
		numbers.append(n[i])
	numbers.sort(reverse=True)
	for i in range(amount):
		bigest += numbers[i]
	bigest = int(bigest)
	return bigest


def super_size(n):
	n_list = [i for i in str(n)]
	n_list.sort(reverse=True)
	return int(''.join(n_list))


def super_size(n):
	p = list(str(n))
	p.sort()
	return int(''.join(reversed(p)))


def super_size(n):
	st = ''.join(sorted(list(str(n)), reverse=True))
	return int(st)


def super_size(n):
	a = list(str(n))
	a.sort(reverse=True)
	n = ''.join(a)
	n = int(n)
	return n


def super_size(n):
	num = str(n)
	arr = []
	for i in range(0, len(num)):
		arr.append(num[i])
	arr.sort(reverse=True)
	return int(''.join(arr))


def super_size(n):
	a = []
	for i in range(len(str(n))):
		a.append(n % 10)
		n //= 10
	a = list(reversed(sorted(a)))
	num = 0
	for i in a:
		num = num * 10 + i
	return num


def super_size(n):
	ln = []
	for x in str(n):
		ln.append(x)
	ln.sort()
	ln.reverse()
	return int(''.join(ln))


def super_size(n):
	b = list(str(n))
	b.sort()
	r = ''
	for i in b[::-1]:
		r += i
	return int(r)


def super_size(n):
	n_str = str(n)
	str_sort = sorted(n_str, reverse=True)
	output = ''
	for num in str_sort:
		output = output + num
	return int(output)


def super_size(n):
	arr = [x for x in str(n)]
	arr.sort(reverse=True)
	return int(''.join(arr))


def super_size(n):
	uporz = list(str(n))
	uporz.sort(reverse=True)
	return int(''.join(uporz))


super_size = lambda n: int(''.join(sorted([digit for digit in str(n)])[::-1]))


def super_size(n):
	convert_to_str = str(n)
	lst = convert_to_str.split()
	for elem in convert_to_str:
		lst.append(elem)
	lst.pop(0)
	num_list = []
	for num in lst:
		num_list.append(int(num))
	srt = sorted(num_list, reverse=True)
	string = ''.join(str(srt))
	rep1 = string.replace('[', '')
	rep2 = rep1.replace(']', '')
	rep3 = rep2.replace(',', '')
	rep4 = rep3.replace(' ', '')
	return int(rep4)


def super_size(n):
	res = ''
	n = list(str(n))
	for i in range(len(n)):
		res += str(max(n))
		n.remove(max(n))
	return int(res)


def super_size(n):
	n = str(n)
	a = n[:]
	b = []
	for elem in a:
		b += elem
	b.sort()
	b.reverse()
	s = ''
	s = s.join(b)
	m = int(s)
	return m


def super_size(n):
	l = []
	s = ''
	for i in str(n):
		l.append(int(i))
	for i in sorted(l, reverse=True):
		s += str(i)
	return int(s)


def super_size(n):
	lst = list(str(n))
	lst.sort()
	return int(''.join(lst[::-1]))


def super_size(n):
	a = [i for i in str(n)]
	out = ''
	while len(a):
		out = out + max(a)
		a.remove(max(a))
	return int(out)


def super_size(n):
	return int(''.join(reversed(sorted([*str(n)]))))


from functools import reduce

def super_size(n):
	car = sorted([int(x) for x in str(n)], reverse=True)
	van = (str(a) for a in car)
	return int(''.join(van))


def super_size(m):
	arr = [int(x) for x in str(m)]
	n = len(arr)
	result = ''
	for i in range(n - 1):
		for j in range(0, n - i - 1):
			if arr[j] > arr[j + 1]:
				(arr[j], arr[j + 1]) = (arr[j + 1], arr[j])
	arr.reverse()
	string_new = [str(i) for i in arr]
	result = int(''.join(string_new))
	return result


def super_size(n):
	n_str = str(n)
	n_sorted = sorted(n_str, reverse=True)
	output_str = ''
	for num in n_sorted:
		output_str = output_str + num
	if n_str == n_sorted:
		return int(n_str)
	else:
		return int(output_str)


def super_size(n):
	num = [int(x) for x in str(n)]
	num.sort(reverse=True)
	num_str = [str(x) for x in num]
	big_num_str = ''.join(num_str)
	return int(big_num_str)


def super_size(n):
	x = sorted([int(x) for x in str(n)])[::-1]
	return int(''.join(map(str, x)))


def super_size(n):
	ints = [int(thing) for thing in list(str(n))]
	ints = sorted(ints, reverse=True)
	strings = [str(integ) for integ in ints]
	new_str = ''.join(strings)
	return int(new_str)


def super_size(n):
	n = list(str(n))
	ans = ''
	while len(n) > 0:
		temp = max(n)
		ans += temp
		n.remove(temp)
	return int(ans)


def super_size(n):
	list = []
	textNb = ''
	for nb in str(n):
		list.append(nb)
	list.sort(reverse=True)
	for ch in list:
		textNb += ch
	return int(textNb)


def super_size(n):
	items = [int(x) for x in str(n)]
	items.sort(reverse=True)
	itemStr = ''.join((str(d) for d in items))
	return int(itemStr)


def super_size(n):
	sorted_integers = sorted(str(n), reverse=True)
	supersized_n = int(''.join(sorted_integers))
	return supersized_n


def super_size(n):
	nn = str(n)
	num = []
	for i in nn:
		num.append(int(i))
	numnum = sorted(num)
	numnum.reverse()
	for i in numnum:
		return int(''.join((str(i) for i in numnum)))


def super_size(n):
	b = sorted([int(x) for x in str(n)], reverse=True)
	return int(''.join(map(str, b)))


def super_size(n):
	n_str = str(n)
	n_sorted = sorted(n_str, reverse=True)
	res = int(''.join(n_sorted))
	return res


def super_size(n):
	s = sorted(list(str(n)))
	s.reverse()
	return int(''.join(s))


def super_size(n):
	a = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
	while n >= 1:
		a[n % 10] += 1
		n //= 10
	ans = 0
	for i in range(9, -1, -1):
		while a[i]:
			ans *= 10
			ans += i
			a[i] -= 1
	return ans


def super_size(n):
	temp = [int(x) for x in str(n)]
	temp.sort(reverse=True)
	strings = [str(integer) for integer in temp]
	a_string = ''.join(strings)
	an_integer = int(a_string)
	return an_integer


def super_size(n):
	sort_numbers = sorted(str(n))
	sort_numbers.reverse()
	return int(''.join(map(str, sort_numbers)))


def super_size(n):
	if len(str(n)) > 1:
		array_numbers = map(int, str(n))
		sorted_arrays = sorted(array_numbers, reverse=True)
		strings = [str(sorted_array) for sorted_array in sorted_arrays]
		a_string = ''.join(strings)
		result = int(a_string)
		return result
	else:
		return n


def super_size(n):
	singleValues = []
	x = 1
	result = 0
	while n >= 1:
		singleValues.append(n % 10)
		print(n % 10)
		n = int(n / 10)
	singleValues.sort()
	print(singleValues)
	for i in singleValues:
		result = result + i * x
		x = x * 10
	print(result)
	return int(result)


def super_size(n):
	s = [int(i) for i in str(n)]
	s.sort(reverse=True)
	s = [str(x) for x in s]
	res = int(''.join(s))
	return res


def super_size(n):
	w = list(str(n))
	w.sort(reverse=True)
	return int(''.join(w))


def super_size(n):
	n_list = list(str(n))
	n_list.sort(reverse=True)
	n_string = ''.join(n_list)
	return int(n_string)


def super_size(n):
	m = str(n)
	l = list()
	for i in range(len(m)):
		l.append(int(m[i]))
	k = sorted(l, reverse=True)
	res = list()
	for i in range(len(k)):
		res.append(str(k[i]))
	f = ''.join(res)
	return int(f)


def super_size(n):
	list1 = []
	for i in str(n):
		list1.append(i)
	list1.sort()
	list1.reverse()
	return int(''.join(list1))


def super_size(n):
	L = [int(i) for i in str(n)]
	L.sort(reverse=True)
	S = [str(i) for i in L]
	A = ''.join(S)
	return int(A)


def super_size(n):
	a = []
	b = len(str(n))
	for i in range(b):
		n = str(n)
		a.append(n[i])
	a = sorted(a)
	a = a[::-1]
	c = ''
	for i in range(b):
		c += a[i]
	return int(c)


def super_size(n):
	n_str = str(n)
	n_sorted = sorted(n_str, reverse=True)
	sorted_str = ''
	for i in n_sorted:
		sorted_str += i
	return int(sorted_str)


def super_size(n):
	a = sorted(str(n), reverse=True)
	b = int(''.join(a))
	return b


def super_size(n):
	big = list(str(n))
	big.sort(reverse=True)
	return int(''.join(big))


def super_size(n):
	number_list = list(str(n))
	number_list.sort(reverse=True)
	return int(''.join(number_list))


def super_size(n):
	size_str = ''
	size_list = [int(i) for i in str(n)]
	for _ in range(len(size_list)):
		i = max(size_list)
		size_str += str(i)
		size_list.remove(i)
	return int(size_str)


def super_size(n):
	ll = list()
	while n != 0:
		ll.append(n % 10)
		n //= 10
	ll = sorted(ll, reverse=True)
	res = 0
	for digit in ll:
		res = res * 10 + digit
	return res


def super_size(n):
	n_str = str(n)
	n_sorted = sorted(n_str, reverse=True)
	n_joined = ''
	for i in n_sorted:
		n_joined += i
	n_reverse = int(n_joined)
	return n_reverse