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: introductory

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))
    #your code here


def super_size(n):
    #your code here
    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):
    # your code here
    new = list(str(n))
    new = sorted(new, reverse=True)
    new = ''.join(new)
    return int(new)

def super_size(n: int) -> int:
    """ Rearrange the integer into its largest possible value. """
    return int("".join(list(sorted(str(n), reverse=True))))

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(sorted(str(n)[::-1]))[::-1])

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):
    # sorted returns a list with the sorted elements of the input string
    return int("".join(sorted(str(n), reverse=True)))

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):
    #your code here
    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
    
    
    #your code here


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(str(n), reverse = True))
    return int(st)

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):
    #your code here
    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):
    l = [int(i) for i in str(n)]
    l.sort(reverse = True)
    return int("".join([str(i) for i in l]))

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):
    lst=[i for i in str(n)]
    return int(''.join(sorted(lst,reverse=True)))



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)] # convert to list
    num.sort(reverse=True) #sort descending
    num_str = [str(x) for x in num] #convert list ints to strs, there's got to be a less stupid way
    big_num_str = "".join(num_str) #join into a integer
    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):
    x =[i for i in str(n)]
    x = sorted(x, reverse= True)
    return int("".join(x))

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):
    #your code here
    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):
    n = str(n)
    n = sorted(n)
    n = ''.join(n)
    return int(n[::-1])

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
    #your code here


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):
    return int(''.join(sorted([*str(n)], reverse=True)))

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):
    #your code here
    
    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):
    n1 = [int(i) for i in list(str(n))]
    n1.sort(reverse = True)
    n1 = int("".join([str(i) for i in n1]))
    return n1

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):
    #your code here
    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):
    """Function that rearranges an integer into its largest possible value.
    :param int n
        integer to rearranges
    """
    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