Comments on: Pythagoras and lambdas…..

By: jmoney

jmoney — Mon, 25 Aug 2008 13:32:46 +0000

I recommend cutting your looping down.
p hyp 1000)

Just ideas… brute force helps clarify the problems, allowing much more elegant solutions.

By: rgz

rgz — Mon, 25 Aug 2008 04:03:49 +0000

The real speedup would be using a generator. And while we are at it let’s use argument unpacking and the built-in iteritems.

dict((v,k) for k, v in d.iteritems())

By: Shriphani

Shriphani — Sun, 24 Aug 2008 01:47:17 +0000

@Jim Meier: Thanks for your solution as well.

By: Shriphani

Shriphani — Sun, 24 Aug 2008 01:43:54 +0000

@seth: Thanks for pointing out the improvement in efficiency by using a list comprehension instead of the lambda+map thingy. And yeah, I should’ve seen that a+b+c< 1000 is easier to evaluate than the other condition.

By: Jim Meier

Jim Meier — Sun, 24 Aug 2008 01:34:28 +0000

Of course, a better solution is to reduce the problem from an O(n^3) to O(n^2) with minimal constant factors:

from math import sqrt, ceil

def solve(p):
    max_unique_hyp = int(ceil(p/2))
    for hyp in xrange(1, max_unique_hyp):
        hyp2 = hyp ** 2
        for x in xrange(1, hyp):
            y = sqrt(hyp2 - x**2)
            if y == int(y) and x+y+hyp  most_solutions[1]:
            most_solutions = (p, len(s))
    return solutions, most_solutions

print most_solutions(1000)

I'm not sure how that'll show up formatted as a comment, sorry. The results:

$ time python peri.py
(840.0, 8)

real	0m0.198s
user	0m0.180s
sys	0m0.013s

By: Seth

Seth — Sun, 24 Aug 2008 00:20:50 +0000

Also, a little poking showed that reversing the conditions in checkCond saves a substantial amount of time.

a + b + c < 1000 and c ** 2 == a ** 2 + b ** 2

It’s often a good idea to be very deliberate about arranging conditions in an AND statement. Sometimes you want the most likely to be violated, other times you want the one that’s cheapest to evaluate. Python (and many other languages) won’t test later conditions in an AND after one fails.

I’ll stop poking at your code now. Hope my tips are useful to you.

By: Seth

Seth — Sat, 23 Aug 2008 23:51:25 +0000

I’d be remiss as a Python nerd if I didn’t point out that you could speed things up and avoid the lambda/map if you used a list comprehension.

dict([(item[1], item[0]) for item in dict_name.items()])

Keep up the good work!