Why is elif running before if statement? Python

Question

Project Euler problem 33 asks solvers to find "curious fractions": fractions which are equal to the fraction obtained by deleting digits that appear in both numerator and denominator (for example, 49/98, which "cancels" to 4/8 by deleting the 9s).

NOTE: This is not a competition to solve the Project Euler problem FASTEST. I already rewrote this code into a solution that's as fast as Nickie's. This is done by removing the for loop and if float(numer)... conditionals. It looks like this:

def curious(numer,denom):
    n = str(numer)
    d = str(denom)

    if len(n) == 2 and len(d) == 2:
        if n[1] == d[0]:
            if n != d:
                if d[1] != "0":
                    if Fraction(int(n[0]), int(d[1])) \
                    == \
                    Fraction(numer, denom):
                            return n + d

I still don't understand the conditional problem though.

I am not new to Python programming and this is the first time I've encountered anything like this. In the function defined below, there are paired if and elif statements:

import time
from fractions import Fraction

def curious(numer,denom):
    n = str(numer)
    d = str(denom)

    if len(n) == 2 and len(d) == 2:
        if n[1] == d[0]:
            for i in range(2, numer+1):
                if float(numer)/i == float(int(n[0])) \
                and float(denom)/i == float(int(d[1])):
                    if n != d:
                        return n + "/" + d

                elif d[1] != "0":
                    if Fraction(int(n[0]), int(d[1])) \
                    == \
                    Fraction(numer, denom):
                        if n != d:
                            return n + d


start = time.time()

nums = []
denoms = []
for i in range(10, 100):
    for j in range(10, 100):
        if i < j:
            if type(curious(i, j)) == str:
                frac = (curious(i,j))
                nums.append(frac[0]+frac[1])
                denoms.append(frac[2]+frac[3])
                print frac

pro = 1
duct = 1

for i in range(0, len(nums)):
    pro *= int(nums[i])
    duct *= int(denoms[i])


print Fraction(pro, duct)

elapsed = time.time() - start
print "The elapsed time is %s seconds." % (elapsed)

when I run the code with the elif statement commented out, the result is this:

16/64,
19/95,
26/65,
The elapsed time is 0.0500001907349 seconds.

But when the elif is included, the if statement is ignored and the result is this:

1664,
1995,
2665,
4998,
The elapsed time is 0.59700012207 seconds.

It appears that Python prefers to take the inefficient route, even though the conditions of the if statement are satisfied in both cases. Can anyone help me solve this mystery?

Ideally, I want the result to be:

16/64,
19/95,
26/65,
4998,
The elapsed time is 0.0500001907349 seconds.

nickie · Accepted Answer

This is an oddly structured answer, as it was written incrementally. I apologize for this. Even so, I think it is worth reading in this order. Each part, separated with a horizontal ruler, says something different.

Equality comparisons in floating point arithmetic are usual sources of trouble and should be avoided. Instead of testing for:

float(numer)/i == float(int(n[0])) and float(denom)/i == float(int(d[1]))

why not the following? Simpler and equivalent (in mathematics, but not in Python!):

numer == i * int(n[0]) and denom == i * int(d[1])

On top of this, not only is floating point arithmetic a source of trouble but translating from int to float too often is bad for performance too.

I do not understand why you expect your program to print the same result when you remove the elif clause. It does two different things, when you have the elif and when you don't. You're just returning the same result (n/d) so you don't see the difference.

The if statement is not "being bypassed". But, if it does not return something in the first iteration of the for loop, then the elif statement (which does the same thing in every iteration) will have the chance to return its value. Then the if statement will not be executed again.

As now more information has been supplied concerning the question (this is intended as part of a solution to Euler project's problem #33), I will stick to the original version of the question and try to refactor function curious, which I believe is poorly written. I believe that the following function is equivalent and much faster, as the for loop only computes things that depend on i:

def curious(numer,denom):
    n = str(numer)
    d = str(denom)

    if len(n) == 2 == len(d) and n[1] == d[0] and n != d:
       for i in range(2, numer+1):
           if numer == i*int(n[0]) and denom == i*int(d[1]):
               return n + "/" + d
           elif i == 2 and d[1] != "0":
               if Fraction(int(n[0]), int(d[1])) == Fraction(numer, denom):
                   return n + d

With this function, Cawb07's program produces the same output (the four fractions plus 1/100, which is the answer to the problem) much faster.

Now that I understand what curious is trying to do, let me suggest a much better approach. Let us assume that a brute force solution is to be sought. It can be easily arranged so that curious is always called with two 2-digit parameters, for which numer < denom is true, and that it returns a Boolean result, denoting whether the fraction is curious or not. Furthermore, there's no need for a for loop in curious, which can be greatly simplified.

import time
from fractions import Fraction

def curious(numer, denom):
    n = str(numer)
    d = str(denom)
    return (n[0] == d[1] != '0' and denom * int(n[1]) == numer * int(d[0])) \
        or (n[0] == d[0] != '0' and denom * int(n[1]) == numer * int(d[1])) \
        or (n[1] == d[0] != '0' and denom * int(n[0]) == numer * int(d[1])) \
        or (n[1] == d[1] != '0' and denom * int(n[0]) == numer * int(d[0]))

start = time.time()

for i in range(10, 100):
    for j in range(i+1, 100):
        if curious(i, j):
           print i, "/", j

elapsed = time.time() - start
print "The elapsed time is", elapsed, "seconds."

This program just prints the four curious fractions, again much faster than the previous one.

Notice also that, for reducing the product of the curious fractions to lowest common terms, you could easily calculate the nominator and denominator and then divide by their GCD, which can be found using Euclid's algorithm.

Cawb07: Can also use fractions.gcd(n,d) :).

Why is elif running before if statement? Python

Answers (2)

Related Questions