Generic Pythonic Code to Solve: 22220

Question

I got the python code below that solves the expression above. I believe there should be a more generic Pythonic approach. By generic I mean it should solve any combinations of numbers (not just: 2 ** 2 ** 2 ** 2 ** 0) e.g: 3 ** 2 ** 4 ** 1 ** 0, 3 ** 3 ** 1 ** 2 ** 0 etc

def get_expo(expo, index, cur_expo):
    return int(expo[index-1]) ** cur_expo


def solve_expo(expo):
    expo = expo.split("^")
    index = len(expo) - 1
    cur_expo = int(expo[-1])
    result = 0
    for i in range(len(expo)):
        if index == 1:
            result = get_expo(expo, index, cur_expo)
            return "Answer is: " + str(result)
        else:
            cur_expo = get_expo(expo, index, cur_expo)
            index -= 1



print solve_expo("2^2^2^2^0")

I need a better pythonic approach to solving it?

What makes you think that code won't work for other numbers? — Morgan Thrapp, Sep 28 '16 at 19:51
Why do you have that print statement at the end of your code? — sawreals, Sep 28 '16 at 19:54
I feel it should the code length should be shorter than that and probably there is a built-in function to doing it? Generally I feel a more pythonic way is available by experienced python programmers? — Umar Yusuf, Sep 28 '16 at 19:55
@sawreals2 As I read the question, he is asking for a more elegant "pythonic" solution even though this code does work. — sabbahillel, Sep 28 '16 at 19:55
`eval` comes to mind but, isn't there better than `eval("2**2**2**2**0")` to do this? I mean we know `eval` is evil right? — Jean-François Fabre, Sep 28 '16 at 19:57
http://stackoverflow.com/questions/1832940/is-using-eval-in-python-a-bad-practice — Ilja Everilä, Sep 28 '16 at 20:06
I think that doing the split and passing the list into the recursive function is a little nicer as I show below. — sabbahillel, Sep 28 '16 at 20:26
Added an answer with the use of `reduce()`. Please note one should always avoid the usage of `eval` and `exec` in the code due to security concerns. Mentioning this because most voted answer is based on the usage of `eval` — Moinuddin Quadri, Sep 28 '16 at 20:53

score 2 · Answer 1 · edited May 23 '17 at 12:26

2

Python's built-in ** operator respects precedence correctly already. You can feed it the full expression and get the answers you are expecting.

>>> 3 ** 2 ** 4 ** 1 ** 0
43046721

So the straightforward (but potentially dangerous) way to write your function is something like this, by just evaluating the expression after replacing the ^ with **:

def solve_expo(expression):
    return eval(expression.replace('^', '**'))

Obviously, eval might not be suitable for your situation (or you might just want to do something a little more interesting), so you could rewrite your solution as a recursive one. It's a little more elegant, at any rate.

def solve_expo(expression):
    base, exp = expression.split('^', 1)  # Split off just the first ^
    if '^' in exp:
        return int(base) ** solve_expo(exp)  # More exponents later, so resolve them and raise our base to that power
    return int(base) ** int(exp)  # base and exp are plain numbers, so just return base^exp

edited May 23 '17 at 12:26

Community

1
1

answered Sep 28 '16 at 19:57

Henry Keiter

16,863
7
51
80

it runs as script not on the cmd prompt – Umar Yusuf Sep 28 '16 at 19:58
@UmarYusuf Anything you do on the interactive interpreter you can do as a script. – Henry Keiter Sep 28 '16 at 20:01
Ok, let me study it – Umar Yusuf Sep 28 '16 at 20:05
eval is evil, but you can assert that the original code has only digits and `^`. i guess that would make it safe. – zvone Sep 28 '16 at 20:16
I split it into a list and just had the recursive function work on the integers – sabbahillel Sep 28 '16 at 20:27

score 1 · Accepted Answer · edited May 23 '17 at 10:27

Alternative approach to achieve this by using reduce() function as:

>>> operation_str = '3^2^4^1^0'
>>> reduce(lambda x, y: int(y)**int(x), operation_str.split('^')[::-1])
43046721

Explanation based on step by step operation:

>>> operation_str.split('^')
['3', '2', '4', '1', '0'] # Converted str into list
>>> operation_str.split('^')[::-1]
['0', '1', '4', '2', '3'] # Reversed list
>>> reduce(lambda x, y: int(y)**int(x), operation_str.split('^')[::-1])
43046721  # Check reduce() fucntion linked above to know how it works

Also read: Why should exec() and eval() be avoided?

Thanks, this is a more professional code – Umar Yusuf Sep 29 '16 at 08:49 — Umar Yusuf, Sep 29 '16 at 08:49

score 0 · Answer 3 · answered Sep 28 '16 at 20:23

Since you want to handle it as a recursion, this code seems to handle it nicely. The split creates a single list of string values which are then handled completely within the recursive function.

val = '2^3^4^5^6^7'
vals = val.split('^')

def solve_expo(expo):
    if len(expo) == 1:
        return int(expo)
    else:
        return solve_expo(expo[:-1]) ** int(expo[-1])

solv_expo(vals)

Generic Pythonic Code to Solve: 2**2**2**2**0

3 Answers3

Generic Pythonic Code to Solve: 22220