Given the number n, return a string which shows the minimum number of moves to complete the tower of Hanoi consisting of n layers.
Tower of Hanoi : https://en.wikipedia.org/wiki/Tower_of_Hanoi

Example - 2 layered Tower of Hanoi 

Input: n=2

Start
[[2, 1], [], []]

Goal
[[], [], [2, 1]]

Expected Output : '[[2, 1], [], []]\n[[2], [1], []]\n[[], [1], [2]]\n[[], [], [2, 1]]'

Difficulty: introductory

Starter code:

def hanoiArray(n):
	

Solutions:
def hanoiArray(n):
    A, B, C = list(range(n, 0, -1)), [], []
    res = [str([A, C, B])]
    def rec(n, X, Y, Z):
        if not n: return
        rec(n-1, X, Z, Y)
        Y.append(X.pop())
        res.append(str([A, C, B]))
        rec(n-1, Z, Y, X)        
    rec(n, A, B, C)
    return '\n'.join(res)

from io import StringIO

def move(n, a, b, c, source, target, auxiliary, output):
    if n > 0:
        move(n - 1, a, b, c, source, auxiliary, target, output)
        target.append(source.pop())
        print([a, b, c], file=output)
        move(n - 1, a, b, c, auxiliary, target, source, output)

def hanoiArray(n):
    a, b, c = list(range(n, 0, -1)), [], []
    with StringIO() as output:
        print([a, b, c], file=output)
        move(n, a, b, c, a, c, b, output)
        return output.getvalue().rstrip('\n')

m=lambda n,l,a,b,c:n and m(n-1,l,a,c,b)+[l[c].append(l[a].pop())or str(l)]+m(n-1,l,b,a,c)or[]
hanoiArray=lambda n:(lambda l:str(l)+'\n'+'\n'.join(map(str,m(n,l,0,1,2))))([list(range(n,0,-1)),[],[]])

def maketrans(n, a, b, c):
  if n == 0: return []
  return maketrans(n-1, a, c, b) + [[a, b]] + maketrans(n - 1, c, b, a)


def hanoiArray(n):
    transitions = maketrans(n, 0, 2, 1)
    state = [[i for i in range(n, 0, -1)], [], []]
    res = str(state)
    while transitions:
        from_peg, to_peg = transitions.pop(0)
        state[to_peg].append(state[from_peg].pop())
        res += '\n' + str(state)
    return res

def hanoiArray(n):

  def move(n, source, target, auxiliary):
      if n > 0:
          # Move n - 1 disks from source to auxiliary, so they are out of the way
          move(n - 1, source, auxiliary, target)

          # Move the nth disk from source to target
          target.append(source.pop())

          # Store new state
          res.append([A[:], B[:], C[:]])

          # Move the n - 1 disks that we left on auxiliary onto target
          move(n - 1, auxiliary, target, source)
          
  A = list(range(n, 0, -1))
  B = []
  C = []

  res = [[A[:], B[:], C[:]]]

  # Initiate call from source A to target C with auxiliary B
  move(n, A, C, B)
  return '\n'.join(map(str, res))

def hanoiArray(n):
    initial = [x for x in range(n,0,-1)]
    tow = [initial,[],[]]
    ret = str(tow)
    
    def move(f,t):
        nonlocal tow, ret
        tow[t].append(tow[f].pop())
        ret = ret + '\n' + str(tow)
        
    def solve(n,f,h,t):
        if n == 0:
            pass
        else:
            solve(n-1,f,t,h)
            move(f,t)
            solve(n-1,h,f,t)
    
    solve(n,0,1,2)

    return ret
    


def Hanoi_Solution(n):
    # Establish base cases
    if n == 0:
        return([[],[],[]])
    if n == 1:
        return([[[1],[],[]],[[],[],[1]]])
    # Setup recursion
    else:
        L = len(Hanoi_Solution(n-1))
        # Move from [[n,..,1],[],[]] to [n,[n-1,...,1],[]] 
        first_half = Hanoi_Solution(n-1)    
        for i in range(L):
            # Insert the new number at the beginning in the previous solution
            first_half[i][0].insert(0,n)
            # Switch the last two positions in each move
            temp_1 = first_half[i][2]
            first_half[i][2] = first_half[i][1]
            first_half[i][1] = temp_1
        # Move from [[],[n-1,...,1],[n]] to [[],[],[n,...,1]]
        second_half = Hanoi_Solution(n-1)
        for i in range(L):
            # Insert the new number at the end in the previous solution
            second_half[i][2].insert(0,n)
            # Switch the first two positions in each move
            temp_2 = second_half[i][1]
            second_half[i][1] = second_half[i][0]
            second_half[i][0] = temp_2
        # Join the two halves into a single solution of length 2**n
        for i in second_half:
            first_half.append(i)
        return(first_half)

# Print the solution in the string format suggested
def hanoiArray(n):
    return((''.join(str(i)+'\n' for i in Hanoi_Solution(n)))[:-1])

def hanoi(n,a,b):
    if n==1:
        return [(a,b)]
    else:
        c=3-a-b
        return hanoi(n-1,a,c)+[(a,b)]+hanoi(n-1,c,b)


def hanoiArray(n):
    moves=hanoi(n,0,2)
    towers=[list(range(n,0,-1)),[],[]]
    ans=[str(towers)]
    for i,j in moves:
        towers[j].append(towers[i].pop())
        ans.append(str(towers))
    return '\n'.join(ans)