Imagine a funnel filled with letters. The bottom letter drops out of the funnel and onto a conveyor belt:

```
  \b,c/  -->   \b,c/
   \a/   -->    \ /
                 a
-------     -------
```
If there are two letters above a gap, the smaller letter falls into the gap.
```
  \b,c/   -->   \  c/ 
   \ /    -->    \b/   
a            a         
-------      -------
```
Of course, this can create a new gap, which must also be filled in the same way:
```
  \f,e,d/  -->  \f, ,d/
   \  c/   -->   \e,c/ 
    \b/           \b/   
   a            a         
  -------      -------
```
Once all the gaps above it have been filled, the bottom letter drops out of the funnel and onto the conveyorbelt. The process continues until all letters have fallen onto the conveyor. (New letters fall onto the end of the existing string)

**KATA GOAL: Return the string on the conveyorbelt after all letters have fallen**.
```
\f, ,d/      \f, ,d/   --> etc -->    \     /
 \e,c/        \e,c/    --> etc -->     \   /
  \b/    -->   \ /     --> etc -->      \ /
a           a   b                   abcdef
-------     -------                 -------
```
All letters in the funnel will be unique i.e. in every comparison one letter will be strictly smaller than the other. The funnel will be presented as a nested list, e.g:
```
[["d","a","c"],
   ["b","e"],
     ["f"]]
```
The value of a letter is defined by its codepoint. Note: this means all capital letters are defined as smaller than all lower-case letters, but your language's comparison operator will probably treat it that way automatically.

The funnels will always be "nice" -- every layer will have 1 item more than the layer below, and every layer will be full, and generally there's no funny business or surprises to consider. The only characters used are standard uppercase and lowercase letters A-Z and a-z. The tests go up to 9 layer funnel.

### Fully Worked Example
```
\d,a,c/      \d,a,c/      \d,a,c/ -->  \d   c/     
 \b,e/        \b,e/  -->   \  e/  -->   \a,e/
  \f/   -->    \ /   -->    \b/          \b/  --> 
                f        f            f
------      -------      -------      -------


\d   c/      \d   c/ -->  \    c/      \    c/     
 \a,e/  -->   \  e/  -->   \d,e/        \d,e/  -->
  \ /   -->    \a/          \a/   -->    \ /   -->
f  b        fb           fb           fb  a
------      -------      -------      -------


 \    c/      \    c/      \    c/ -->  \     /     
  \  e/        \  e/  -->   \   /  -->   \  c/   
   \d/   -->    \ /   -->    \e/          \e/  -->
fba          fba d       fbad          fbad
-------      -------     --------      -------


  \     /      \     /      \     /
   \  c/  -->   \   /        \   / 
    \ /          \c/   -->    \ /   
fbad e       fbade        fbadec         
-------      -------      -------

DONE. Return "fbadec".

```

**For a bigger funneling challenge, check out [this kata](https://www.codewars.com/kata/create-a-funnel) by @myjinxin2015.**

Difficulty: introductory

Starter code:

def funnel_out(funnel):
	

Solutions:
def funnel_out(funnel):
    r=""
    h=len(funnel)
    while funnel[h-1][0]!="~":
      r+=funnel[h-1][0]
      funnel[h-1][0]="~"
      i=h-1
      j=0
      while i>0:
        if funnel[i-1][j] < funnel[i-1][j+1]:
          funnel[i][j]=funnel[i-1][j]
          funnel[i-1][j]="~"
        else:
          funnel[i][j]=funnel[i-1][j+1]
          funnel[i-1][j+1]="~"
          j+=1
        i-=1
    print(funnel)
    return r

def funnel_out(funnel):
    if not funnel: return ""
    ret = []
    while funnel[-1][-1]:
        j = 0
        ret.append(funnel[-1][j])
        funnel[-1][j] = None
        for i in range(-2, -len(funnel)-1, -1):
            _, k = min((funnel[i][x] or "\xff", x) for x in (j, j+1))
            funnel[i+1][j], funnel[i][k], j = funnel[i][k], funnel[i+1][j], k
    return ''.join(ret)

def pull_letter(funnel):
    letter = funnel[0][0]
    funnel[0][0] = None
    pos = 0
    
    for idx, level in enumerate(funnel[:-1]): 
        current_pos = pos
        
        c1 = funnel[idx+1][pos]
        c2 = funnel[idx+1][pos+1]
        if c1 is None or (c2 is not None and c1 >= c2):
            pos += 1
        
        level[current_pos] = funnel[idx+1][pos]
        funnel[idx+1][pos] = None
    
    return letter


def funnel_out(funnel):
    funnel = list(reversed(funnel))
    result = ''

    while funnel[0][0]:
        result += pull_letter(funnel)
        
    return result


def drop(p):
    p[0][0]=''; x=0;
    for y in range(1,len(p)):
        dx = 1 if not p[y][x] else 0 if not p[y][x+1] else 1 if p[y][x+1]<p[y][x] else 0
        p[y-1][x]=p[y][x+dx]; x+=dx
    p[-1][x]=''

def funnel_out(funnel):
    s=[]; p=[r[:] for r in reversed(funnel)]
    while p[0][0]: s.append(p[0][0]); drop(p)
    return ''.join(s)

from copy import deepcopy

def funnel_out(funnel):
    funnel, ans, depth = deepcopy(funnel), [], len(funnel)
    for _ in range(depth*(depth+1)//2):
    
        ans.append(funnel[-1][0])                                                # Archive current lowest char
        i, funnel[-1][0] = 0, "~"                                                # Starting position (i) / erase current char (use "~" as empty cell: higher ascii value than any letter)
        
        for d in range(depth-1, 0, -1):                                          # Will swap the current char with the appropriate one from the line above
            iUp = min((i, i+1), key=lambda x: funnel[d-1][x])                    #     search the lower char index in the above level
            if funnel[d-1][iUp] == "~": break                                    #     no more chars to swap....
            funnel[d][i], funnel[d-1][iUp] = funnel[d-1][iUp], funnel[d][i]      #     make the swap
            i = iUp                                                              #     update thte current column index
            
    return ''.join(ans)

def funnel_out(funnel):
    break_outs, n = [], len(funnel)
    while len(break_outs) < n*(n+1)/2:
        break_outs.append(funnel[-1][0])
        funnel[-1][0], prev = '~', 0
        for i in range(len(funnel) - 1, 0, -1):
            m = min(funnel[i-1][prev:prev+2])
            index = funnel[i-1].index(m)
            funnel[i-1][index], funnel[i][prev], prev = '~', m, index
    return "".join(break_outs)

def funnel_out(funnel):
    ans = ""
    while funnel[-1][0] != "~":
        ans += funnel[-1][0]
        i, funnel[-1][0] = 0, "~"
        for d in range(len(funnel)-1, 0, -1):
            iUp = min((i, i+1), key=lambda x: funnel[d-1][x])
            funnel[d][i], funnel[d-1][iUp] = funnel[d-1][iUp], funnel[d][i]
            i = iUp
    return ans

def funnel_out(lst):
    ans = ""
    while lst != [[]]:
        temp = []
        for i in range(len(lst)-1, -1, -1):
            x = lst[i]
            x2 = lst[i-1]
            if i == len(lst)-1:
                ans += x[0]
                if len(lst) == 1:
                    lst = [[]]
                    break
                lst[i] = [min([k for k in x2 if k != ""])] if len(lst) > 1 else []
                lst[i-1][x2.index(min([k for k in x2 if k != ""]))] = ""
            elif i == 0:
                if all(j=="" for j in lst[0]):
                    lst = lst[1:]
                else:
                    break
            else:
                for j in range(len(x)):
                    if x[j] == "":
                        a, b = x2[j], x2[j+1]
                        t = [k for k in (a, b) if k != '']
                        val = min(t) if t != [] else ""
                        idx = j if x2[j] == val else j+1
                        x[j] = val
                        x2[idx] = ""                      
    return ans

def funnel_out(funnel):
    ans = ""
    while funnel:
        ans += funnel[-1].pop()
        funnel[-1].append('µ')
        for row in range(len(funnel) - 1, 0, -1):
            for col in range(len(funnel[row])):
                if funnel[row][col] == 'µ':
                    if funnel[row - 1][col] < funnel[row - 1][col + 1]:
                        funnel[row][col] = funnel[row - 1][col]
                        funnel[row - 1][col] = 'µ'
                    else:
                        funnel[row][col] = funnel[row - 1][col + 1]
                        funnel[row - 1][col + 1] = 'µ'
            if all(en == 'µ' for en in funnel[row]):
                del(funnel[row])
        if len(funnel) == 1:
            break
    return ans

def funnel_out(funnel):
    result, funnel = [], funnel[::-1]
    
    def move(i=0, j=0):
        if i < len(funnel)-1:
            c1, c2 = funnel[i+1][j:j+2]
            if c1 and (not c2 or c1 < c2):
                funnel[i][j] = c1
                return move(i+1, j)
            elif c2 and (not c1 or c2 < c1):
                funnel[i][j] = c2
                return move(i+1, j+1)
        funnel[i][j] = ''
    
    while funnel[0][0]:
        result.append(funnel[0][0])
        move()
    return ''.join(result)