Assume we take a number `x` and perform any one of the following operations:
```Pearl
a) Divide x by 3 (if it is divisible by 3), or
b) Multiply x by 2
```
After each operation, we write down the result. If we start with `9`, we can get a sequence such as:
```
[9,3,6,12,4,8] -- 9/3=3 -> 3*2=6 -> 6*2=12 -> 12/3=4 -> 4*2=8
```
You will be given a shuffled sequence of integers and your task is to reorder them so that they conform to the above sequence. There will always be an answer. 
```
For the above example:
solve([12,3,9,4,6,8]) = [9,3,6,12,4,8].
```

More examples in the test cases. Good luck!

Difficulty: introductory

Starter code:

def solve(arr):
	

Solutions:
def solve(a):
    for i in a:
        li = [i]
        while 1:
            if li[-1] % 3 == 0 and li[-1] // 3 in a : li.append(li[-1] // 3)
            elif li[-1] * 2 in a : li.append(li[-1] * 2)
            else : break
        if len(li) == len(a) : return li

def solve(arr):   
    ar, v = arr[:], lambda p: lambda n: 0 if n % p else 1 + v(p)(n // p)
    return sorted(reversed(sorted(ar, key=v(3))), key=v(2))

def decompose(n):
    res = [0,0,n]
    for i,p in enumerate((3,2)):
        while not n%p: res[i]+=1 ; n//=p
    res[0] = -res[0]
    return res

def solve(arr):
    return [n for _,_,n in sorted(map(decompose,arr))]

def solve(arr):
    fn = lambda p: lambda n: 0 if n % p else 1 + fn(p)(n // p)
    return sorted(sorted(arr, key=fn(3), reverse=True), key=fn(2))

k,solve=lambda n,p:n%p<1and-~k(n//p,p),lambda a:sorted(a,key=lambda n:(-k(n,3),k(n,2)))

def solve(arr):
    links = {}
    for a in arr:
        if a % 3 == 0:
            next_val = a // 3
            if next_val in arr:
                links[a] = next_val
        if a * 2 in arr:
            links[a] = a * 2
            
    start = (set(links.keys()) - set(links.values())).pop()
    result = [start]
    while True:
        next_val = links.get(result[-1])
        if next_val is None:
            break
        result.append(next_val)
    return result

def solve(arr):
    stack = []
    for num in arr:
        branches = arr.copy()
        branches.remove(num)
        stack = [([num], branches)]
        while len(stack) != 0:
            (current, remaining) = stack.pop()
            if len(remaining) == 0:
                return current
            x = current[len(current) - 1]
            valid_leaves = [leaf for leaf in remaining if x / 3 == leaf or x * 2 == leaf]
            for valid in valid_leaves:
                valid_current = current.copy()
                valid_current.append(valid)
                valid_remaining = remaining.copy()
                valid_remaining.remove(valid)
                stack.append((valid_current, valid_remaining))
                


def solve(arr):
    stack = []
    for i in arr:
        x = arr[:]
        x.remove(i)
        stack.append(([i],x))
    while True:
        a,b = stack.pop(0)
        v = a[-1]
        a1,a2 = a[:],a[:]
        b1,b2 = b[:],b[:]
        if v*2 in b:
            a1.append(v*2)
            b1.remove(v*2)
            stack.append((a1,b1))
        if not v%3:
            if v//3 in b:
                a2.append(v//3)
                b2.remove(v//3)
                stack.append((a2,b2))
        if not b1:
            return a1
        if not b2:
            return a2

def solve(lst):
    return sorted(lst, key=factors_count)
    
def factors_count(n):
    result = []
    for k in (2, 3):
        while n % k == 0:
            n //= k
            result.append(k)
    return -result.count(3), result.count(2)


def solve(lst):
    return sorted(lst, key=factors_count)
    
def factors_count(n):
    result = [0, 0]
    for k in (2, 3):
        while n % k == 0:
            n //= k
            result[k-2] += (-1)**k
    return result