An AI has infected a text with a character!! 

This text is now **fully mutated** to this character.

If the text or the character are empty, return an empty string.  
There will never be a case when both are empty as nothing is going on!!

**Note:** The character is a string of length 1 or an empty string.

# Example
```python
text before = "abc"
character   = "z"
text after  = "zzz"
```

Difficulty: introductory

Starter code:

def contamination(text, char):
	

Solutions:
def contamination(text, char):
  return char*len(text)

def contamination(text, char):
  return len(text) * char

import re
def contamination(text, char):
  return re.sub(".", char, text)

import re

def contamination(text, char):
    if text == '' or char == '':
        return ""
    else:
        contaminated_word = re.sub('[!#~@$%&*_+{}|:"<>;,/?=a-zA-Z0-9]', char, text)
        return contaminated_word

contamination = lambda s, c: c * len(s)

contamination=lambda t,c: c*len(t)

def contamination(text: str, char: str) -> str:
    """ Mutate the text by given character. """
    return char * len(text)

def contamination(text, char):
  return "".join(char for x in text)

def contamination(text, char):
  return "" if not text else char+contamination(text[1:],char)

def contamination(text, char):
    if not char or not text:
        return ""
    else:
        return char * len(text)


def contamination(t, char):
    return t.translate({ord(x):char for x in t})

contamination = lambda text, char : char * len (text);

def contamination(text, char):
    return "".join(char for _ in text)


def contamination(text, char):
    for i in text:
        text = text.replace(i, char)
    return text

def contamination(text, char):
    return char * len(text) if len(char) > 0 and len(text) > 0 else ''

def contamination(text, char):  
    return ''.join([char for letter in text])

def contamination(text, char):
    if len(text)==0:
        return ''
    res = ''
    for i in range(len(text)):
        res += text[i].replace(text[i], char)
        
    return res

def contamination(text, char):
    return len(text) * char if len(text) else ''

def contamination(text, char):
    res = ''
    if text:
        for c in text:
            res += char
        return res
    else:
        return text

def contamination(text, char):
    a = len(text)
    if type(text) == str:
        return a * char
    if text or char == "": 
        return ""


def contamination(text, char):
    x = []
    if text == '' or char == '':
        return ""
    else:
        for i in range(len(text)):
            x.append(char)
    return ''.join(x)

def contamination(text, char):
    i,s=0,''
    while i <len(text):
        s+=char
        i+=1
    return s


def contamination(text, char):
    answer = len(text)
    final = ""
    for i in range(answer):
        final += char
    return final

def contamination(text, char):
    result = ''
    if (len(text) == 0 or char == ''):
        return ''
    else:
        for x in text:
            result = result + char
    return result

def contamination(text: str, char: str) -> str:
    return "" if text == "" or char == "" else char * len(text)

def contamination(txt, char):
    return char*len(txt)

def contamination(text, char):
    res=""
    i=0
    while i <len(text):
        i+=1
        res+=char
    return res

def contamination(text, char):
    return char*(len(text) if char and text else 0)

def contamination(text, char):
    st=''
    for c in text:
        st+=char
    return st

def contamination(text, char):
    lst=[char for i in range(len(text))]
    return "".join(lst)

def contamination(text, char):
    if text == "" or char == "":
        return ""
    
    res = ""
    for t in text:
        res += char
    return res

def contamination(text, char):
    
    res = ""
    for i in text:
        if text == " ":
            return text
        else:
            res+=char
    return res

def contamination(text, char):
    if text=='' or char=='':
        return ''
    else:
        ans=''
        for i in text:
            ans=ans+char
        return ans

def contamination(text, char):
    list = []
    if len(text) == 0 or len(char) == 0:
        return ''
    else:
        for elem in text:
            elem = char
            list.append(elem)
        return ''.join(list)

def contamination(text, char):
  l = len(text)
  n = ""
  for i in range(0, l):
      n = n + char
  return n

def contamination(text, char):
    a = ""
    for i in text:
        a += char
    return a

def contamination(text, char):
    return char * len(text) if text != '' != char else ''

def contamination(text, char):
    msg = ''
    if char != '':
        for x in text:
            msg += char
    return msg

def contamination(text, char):
    return len(text) * char if text != '' or text != '' else ""


def contamination(text, char):
  l = 0
  if char == "":
      return ""
  elif text == "":
      return ""
  else:
      l = len(text)
      return char*l

def contamination(text, char):
    if text == "":
        return text
    if char == "":
        return char
    else:
        return char * len(text)



def contamination(text, char):
    return "" if text is "" else char * len(text)

def contamination(text, char):
    number = len(text)
    return char * number

def contamination(text, char):
    if text is '' or char is '':
        return ''
    else:
        return char * len(text)

def contamination(text, char):
  large = 0
  for letters in text:
    large += 1
  return large*char

def contamination(text, char):
  large = 0
  newText = ""
  for letters in text:
    large += 1
  if text == "":
    newText == ""
  else:
    newText = large*char
  return newText

def contamination(text, char):
    if text == "":
        return text
    else:
        for letter in text:
            text = text.replace(letter, char)
        return text

def contamination(text, char):
    
    output = ""
    
    for i in range(0,len(text)):
        output += char
    
    return output

def contamination(text, char):
  return char * len(text) if len(char) else ''

def contamination(text, char):
  m = list(text)
  n = []
  for i in m:
     n.append(char)
  a = "".join(n)
  return a

def contamination(text, char):
    cunt = list(text)
    ctr = 0
    for fuck in cunt:
        cunt[ctr] = char
        ctr += 1
    return ''.join(cunt)

contamination=lambda t,c:c*len(t) if t and c else ''

def contamination(text, char):
  #Code here ;)
  return len(text)*char if text != "" and char != "" else ""

def contamination(text, char):
    result = ''
    for s in range(0, len(text)):
        result += char
    return result

def contamination(text, char):
    if text == '' or char == '':
        return ''
    elif len(text) > 0:
        return len(text)*char


def contamination(text, char):
    
    l = len(text)
    r = l * char
    
    if text == "" or char == "":
        return ""
    else:
        return r


import string

def contamination(text, char):
    if not text or not char:
        return ''
    
    intab = string.printable
    outtab = char * len(intab)
    transtab = str.maketrans(intab, outtab)
    
    return text.translate(transtab)


def contamination(text, char):
     new_str = ''
     for l in text:
         new_str += char
     return new_str

def contamination(text, char):
    return "" if not(text or char) else len(text) * char

def contamination(text, char):
  return '' if text == '' else f'{char*len(text)}'

def contamination(text, char):
    return '' if not text else char * len(text)

def contamination(text, char):
    
    if not (text or char):
        return ''
    return char*len(text)

def contamination(text, char):
  return ''.join([char for i in range(len(text))]) if text else ""

def contamination(s, c):
    return ''.join([x.replace(x,c) for x in s if s != ""])

def contamination(text, char):
    nw = ''
    for c in text:
        nw += char
    return nw
    # Flez


def contamination(text, char):
  a = len(text)
  return a * char

def contamination(text, char):
    if char != "":
        return char * len(text)
    else:
        return ""

def contamination(text, char):
  return "".join([i.replace(i,char) for i in text])

def contamination(text, char):
    string = ""
    for i in range(len(text)):
        string += char
    return string

def contamination(text, char):
    return "" if text == "" or char == "" else "".join([char for i in text])

def contamination(text, char):
    return '' if text=='' or char=='' else ''.join(char for letter in text)

def contamination(text, char):
  if text == '':
      return ''
  
  return char * len(text)

def contamination(text, char):
    if not text or not char:
        return ''
    
    for ch  in text:
        text = text.replace(ch, char) 
    
    return text

def contamination(text, char):
  #Code here ;)
  #print(text[1])
  lt = list(text)
  for i in range(len(lt)):
      lt[i] = char
  return "".join(lt)

def contamination(text, char):
    return f"{len(text)*char}"

def contamination(s, c):
    f = ''
    for i in range(len(s)):
        f = f + c
    return f 

def contamination(text, char):
  if len(text) == 0:
      return ""
  else:
      result = ""
      for c in text:
          result += char
      return result

def contamination(text, char):
    if text:
        return ''.join([char for el in list(text)])
    else:
        return ''
  
  
  


def contamination(text, char):
    x = ''
    for i in text:
        x = x + char
    if text == '' or char == '':
        return ''
    else:
        return x

def contamination(text, char):
  return ''.join(char for i in range(len(text))) if len(text) > 0 or len(char) > 0 else ''

def contamination(text, char):
  return text.replace(text, char*len(text))


print((contamination('_3ebzgh4', '&')))


def contamination(text, char):
    return "" if len(text) == 0 else char * len(text) 

def contamination(text, char):
    return '' if not text or not char else len(text) * char

def contamination(text, char):
  if text == None:
      return ''
  else:
      return char * len(text)

def contamination(text, char):
  if text == '': return ''
  text = list(text)
  for x in range(len(text)):
      text[x] = char
      
  return ''.join(text)

def contamination(text, char):
     return len(text)*char if  len(text)!=0 or len(char)!=0 else ""

def contamination(text, char):
  return len(text) * str(char)

def contamination(text, char):
  return "" if char=="" else char*len(text)

def contamination(text, char):
    #return char * len(text) if text and char else ''
    return char * len(text)

def contamination(text, char):
    if not text or not char:
        return ''
    else:
        return char * len(text)

def contamination(text,char):
    if text == "":
        return text
    elif char == "":
        return char
    else:
        count_of_characters = len(text)
        return (char * count_of_characters)


def contamination(text, char):
    return len(text)*char if len(text)!=0 and len(char)!=0 else ''

def contamination(text, char):
  #Code here ;)
  return char * len(text)
  
  print(contamination("abc","z"))

def contamination(text, char):
    if not (text or char):
        return ''
    else:
        return char*(len(text))

def contamination(text, char):
    new_str = ""
    new_str += str(char) * len(text)
    return new_str

def contamination(text, char):
  return ''.join([char for i in text])

def contamination(text, char):
  a = len(text)* char
  return a

def contamination(text, char):
    if char == '': return ''
    else: return len(text)*char

def contamination(text, char):
  #Code here ;)
#   for i in range(len(text)):
#       text[i] = char
#   return text
    return(char * len(text))

def contamination(text, char):
    nt = len(text)
    nc = len(char)
    if nt == 0 or nc == 0:
        return ""
    return char * nt