Eli Bendersky's website - Project Euler

Euler 68 - solving problems the hard way, but having fun along the way

2009-07-28T14:58:35-07:00

Project Euler problem 68 is your typical puzzle - you have to fill in some numbers into a pattern according to certain rules (constraints). Kind-of like Sudoku, just simpler.

The approaches people have used to solve it are quite varied:

By hand, using pencil and paper. It isn't a very hard puzzle, after all.
Brute forcing the 10! permutations of 10 numbers, checking which permutation satisfies all the constraints and has the largest 16-digit string representation.
Smarter brute forcing with some pruning of bad paths - this comes closer to AI approaches.
Some people recognized that this can be easily solved by a constraint-satisfaction engine, found such an engine and used it to solve the problem (there's still a challenge here, and that's representing the problem in the language of the constraint satisfier).
The most brilliant solution I saw was using SQL! The constraints were coded as a SQL select statement - not the most efficient solution, but an original one!

Now, as I tend to do in many cases, I took the long and hard way here. I coded my own constraint satisfaction engine in Python - complete with constraint propagation, search pruning and some generic heuristics. For sample problems I represented map coloring, Sudoku, magic squares and N-queens problems. The solver works quite fine for all these problems, and when I represented the 5-gon problem for it, it was easy to find the solution quickly.

It was real fun coding the CSP solver (kinda like the time when I coded a simple SAT solver to solve Sudokus) - it was an educational experience. True, solving problem 68 took 6-7 hours instead of 20 minutes this way, but it was definitely worth it!

The code for the solver is available here. Drop me an email if you have any questions about it.

Solved 100th problem on Project Euler!

2009-06-27T07:15:51-07:00

I've just solved my 100th problem on Project Euler and got this nice message:

Excellent work, eliben! By solving your 100th problem you have earned a place among the top 2.53% of members and have advanced to level 3.

So I'm level 3 now! P.S.: Problem 125 is very easy

Project Euler problem 83 - how creeps can help

2009-06-19T17:10:47-07:00

Problems 18, 67, 81, 82 and 83 in Project Euler are quite similar, but increase in level of difficulty.

For all of these except 83 I've used a specialized dynamic-programming solution that worked quite well. Being recursive it was a tiny bit slower than the iterative approaches others have used, but I believe recursive solutions are more elegant.

Anyway, project 83 proved too hard for my approach, because it introduces real cycles into the paths. So, this time I had to arm myself with a real path-finding algorithm. Luckily, I've coded a pretty generic implementation of the A* algorithm quite recently for my Creeps PyGame demo.

A*, however, requires a heuristic to do its magic, and for problem 83 there's no real heuristic. However, since a constant heuristic is acceptable and effectively "dumbs down" A* to the original Dijkstra algorithm (the heuristic of A* must be non-decreasing, which a constant satisfies), I was able to make use of the code from the Creeps game to find a solution in 0.3 seconds, with only 30 lines of code.

Project Euler problem 66 and continued fractions

2009-06-19T14:49:07-07:00

Problem 66 is one of those problems that make Project Euler lots of fun. It doesn't have a brute-force solution, and to solve it one actually has to implement a non-trivial mathematical algorithm and get exposed to several interesting techniques.

I will not post the solution or the full code for the problem here, just a couple of hints.

After a very short bout of Googling, you'll discover that the Diophantine equation:

Is quite famous and is called Pell's equation. From here, further web searches and Wikipedia-reading will bring you to at least two methods for finding the fundamental solution, which is the pair of x and y with minimal x solving it.

One of the methods involves computing the continued-fraction representation of the square root of D. This page is a must read on this topic, and will help you with other Euler problems as well.

I want to post here a code snippet that implements the continued-fraction computation described in that link. Its steps follow the Algebraic algoritm given there:

def CF_of_sqrt(n):
    """ Compute the continued fraction representation of the
        square root of N.

        The first element in the returned array is the whole
        part of the fraction. The others are the denominators
        up to (and not including) the point where it starts
        repeating.

        Uses the algorithm explained here:
        http://www.mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/cfINTRO.html
        In the section named: "Methods of finding continued
        fractions for square roots"
    """
    if is_square(n):
        return [int(math.sqrt(n))]

    ans = []

    step1_num = 0
    step1_denom = 1

    while True:
        nextn = int((math.floor(math.sqrt(n)) + step1_num) / step1_denom)
        ans.append(int(nextn))

        step2_num = step1_denom
        step2_denom = step1_num - step1_denom * nextn

        step3_denom = (n - step2_denom ** 2) / step2_num
        step3_num = -step2_denom

        if step3_denom == 1:
            ans.append(ans[0] * 2)
            break

        step1_num, step1_denom = step3_num, step3_denom

    return ans

As I said, this still isn't enough to solve the problem, but with this code in hand, the solution isn't too far. Read some more about Pell's equation and you'll discover how to use this code to reach a solution.

It took my program ~30 milliseconds to find an answer to the problem, by the way. It took less than a second to solve a 10-times larger problem (for D <= 10000), so I believe it to be a pretty good implementation.

Posting Project Euler solutions in my blog

2009-03-02T18:49:09-08:00

Some may find it inappropriate that I post solutions to Project Euler in this blog. I don't share this sentiment, however. Here's an excerpt from the PE FAQ:

I solved it by using a search engine, does that matter? That depends on your motivation for solving the problems. It probably means that you've missed out on some beautiful and hidden mathematics.

If anyone races through PE using solutions of others, what has he gained? Will others feel they've been robbed? Isn't this, at the core, just an issue of personal integrity?

Anyways, if anyone's determined to find solutions to PE online, it's easy. This Haskell Wiki, for instance, holds code for the first 200 solutions. And other resources can be easily found by Googling.

I'm posting hints for some selected problems because I feel like sharing these insights with the readers of my blog, and this is also a good way to compare solutions with friends. It's the same motivation I've used for posting the solutions to almost all SICP exercises online. For some reason no one objected to that, although solved SICP exercises can lead to students cheating in homework, while Project Euler is just a game.

So take it easy, and if you don't want to spoil the solving experience for yourself, just don't look at these posts! I've conveniently hidden all the real hints behind a Read More link, so it won't be accidentally caught in your eyesight.