The dragon's curve is a self-similar fractal which can be obtained by a recursive method. 

Starting with the string `D0 = 'Fa'`, at each step simultaneously perform the following operations:

```
replace 'a' with: 'aRbFR'
replace 'b' with: 'LFaLb'
```

For example (spaces added for more visibility) : 

```
1st iteration: Fa -> F aRbF R
2nd iteration: FaRbFR -> F aRbFR R LFaLb FR
```

After `n` iteration, remove `'a'` and `'b'`. You will have a string with `'R'`,`'L'`, and `'F'`. This is a set of instruction. Starting at the origin of a grid looking in the `(0,1)` direction, `'F'` means a step forward, `'L'` and `'R'` mean respectively turn left and right. After executing all instructions, the trajectory will give a beautifull self-replicating pattern called 'Dragon Curve'

The goal of this kata is to code a function wich takes one parameter `n`, the number of iterations needed and return the string of instruction as defined above. For example: 

```
n=0, should return: 'F'
n=1, should return: 'FRFR'
n=2, should return: 'FRFRRLFLFR'
```

`n` should be a number and non-negative integer. All other case should return the empty string: `''`.

Difficulty: introductory

Starter code:

def Dragon(n):
	

Solutions:
def Dragon(n):
    if not isinstance(n, int) or n < 0:
        return ''
        
    value = 'Fa'
    
    for i in range(n):
        value = value.replace('a', 'aRcFR')
        value = value.replace('b', 'LFaLb')
        value = value.replace('c', 'b')
        
    return value.replace('a', '').replace('b', '')

def Dragon(n):
    if not isinstance(n, int) or n < 0:
        return ''
    s = 'Fa'
    for i in range(n):
        s = 'aRbFR'.join(t.replace('b', 'LFaLb') for t in s.split('a'))
    return s.replace('a', '').replace('b', '')


import re
def Dragon(n):
  if not isinstance(n, int) or n < 0: return ''
  sub_table = { 'a' : 'aRbFR', 'b' : 'LFaLb' }
  s = 'Fa'
  for i in range(0, n):
    s = re.sub(r'[ab]', lambda m: sub_table[m.group()], s)
  return s.translate(None, 'ab')


def Dragon(n):
  #your code here
  if(type(n) != type(1)):
      return ''
  if(n<0):
      return ''
  if n == 0:
      return 'F'
  ret = 'Fa'
  while(n>0):
      temp = ''
      for word in ret:
          if(word == 'a'):
              temp += 'aRbFR'
          elif(word == 'b'):
              temp += 'LFaLb'
          else:
              temp += word
      ret = temp
      n-=1
  ret = ret.replace('a','')
  ret = ret.replace('b','')
  return ret
    
          
      


def Dragon(n, strng='Fa'):
    if not isinstance(n, int) or n < 0: return ''
    if not n: return strng.translate(None, "ab")
    next = ''.join("aRbFR" if c == 'a' else "LFaLb" if c == 'b' else c for i,c in enumerate(strng))
    return Dragon(n-1, next)

def Dragon(n):
    if not isinstance(n, int) or n < 0:
        return ''
    s = 'Fa'
    for _ in range(n):
        s = ''.join({'a': 'aRbFR', 'b': 'LFaLb'}.get(c, c) for c in s)
    return s.replace('a', '').replace('b', '')

def Dragon(n):
    if type(n) != int or n < 0:
        return ""
    stg, a, b = "F{a}", "{a}R{b}FR", "LF{a}L{b}"
    for _ in range(n):
        stg = stg.format(a=a, b=b)
    return stg.replace("{a}", "").replace("{b}", "")

def Dragon(n):
    if not isinstance(n, int) or n < 0:
        return ""
    d = "Fa"
    for i in range(n):
        d = "".join("aRbFR" if c == "a" else "LFaLb" if c == "b" else c for c in d)
    return d.translate(dict.fromkeys(map(ord, "ab")))

def Dragon(n, Curve='Fa'):
  if type(n)!=int or n%1!=0 or n<0: return '' 
  
  elif n==0: 
      return Curve.replace('a','').replace('b','')
  else: 
      #now need to add an extra step where we swap out a dn b because otherwise the replace will affect the outcome. ie the replaces are not concurrent
      return Dragon(n-1, Curve.replace('a','c').replace('b','d').replace('c','aRbFR').replace('d', 'LFaLb') )