Given a mathematical equation that has `*,+,-,/`, reverse it as follows:

```Haskell
solve("100*b/y") = "y/b*100"
solve("a+b-c/d*30") = "30*d/c-b+a"
```

More examples in test cases. 

Good luck!

Please also try:

[Simple time difference](https://www.codewars.com/kata/5b76a34ff71e5de9db0000f2)

[Simple remove duplicates](https://www.codewars.com/kata/5ba38ba180824a86850000f7)

Difficulty: introductory

Starter code:

def solve(eq):
	

Solutions:
import re

def solve(eq):
    return ''.join(reversed(re.split(r'(\W+)', eq)))

def solve(eq):
    #
    # implemantation takes advantage of abscence of spaces
    #
    leq = (eq.replace('*', ' * ')
             .replace('/', ' / ')
             .replace('+', ' + ')
             .replace('-', ' - ')
             .split(' ')) 

    out = ''.join(leq[::-1])

    return out



def solve(eq):
    s = eq.replace('+',' + ').replace('-',' - ').replace('/',' / ').replace('*',' * ')
    return ''.join(s.split()[::-1])

def solve(eq):
    r=[]
    n=""
    for i in eq:
        if i in "*/-+":
            r.append(n)
            r.append(i)
            n=""
        else:
            n+=i
    r.append(n)
    r.reverse()
    return "".join(r)


import re

def solve(eq):
    return "".join(re.split("([*+-/])", eq)[::-1])

def solve(eq):
    answer = ""
    temp = ""
    for i in eq[::-1]:
        if i.isalnum(): temp += i
        else: 
            answer += temp[::-1] + i
            temp = ""
    answer += temp[::-1]
    return answer

import re
def solve(eq):
    res = re.findall(r'([^0-9]+)|(\d+)', eq)[::-1]
    return ''.join([a[::-1]+b for a,b in res])

import re
from itertools import zip_longest
def solve(eq):
    val=re.split('[+-/*]',eq)[::-1]
    symb=re.findall('[+-/*]',eq)[::-1]
    return ''.join(i+j for i,j in zip_longest(val,symb,fillvalue=''))


def solve(eq):
    eqnLen = len(eq)
    
    revEqn = ''    
    token  = ''    #this will be a sigle alpha, or an entire number 
    i=0
    
    #build the reversed eqation (care regarding the numbers)
    while i<eqnLen:
        token = eq[i]
        # if we have hit a digit (and the next char is a digit) and we are not out of bounds
        # then we need to gobble up the entire number in non-reversed order
        #e.g. 849 should be the token '849' not '948'
        while (i+1 < eqnLen) and (token.isdigit()) and (eq[i+1].isdigit()):
            i+=1
            token+=eq[i]    
        revEqn = token + revEqn    #push token ontop of existing equation
        i+=1
        
    return revEqn
#end solve function


import re
def solve(eq):
    return "".join(re.split("([+-/*])", eq)[::-1])