Tag Archives: algorithm

Project Euler in F#: Problem 8

I’ve been trying to teach myself F# using the Project Euler problems, and I’m starting to feel I’m getting somewhere with the language. The few Euler problems I’ve solved so far have had very straightforward and natural solutions.

Problem 8 is as follows: Find the subsequence of 5 consecutive digits that yield the greatest product when multiplied together, in the 1000-digit number:


I was able to come up with an F# solution that is one line, plus a helper line to convert the string into a sequence of digits:

let str = "731<...>"

let digits = Seq.map (fun x -> int (Char.GetNumericValue x)) str

let maxproduct num list =
 Seq.max (Seq.map (fun x -> Seq.reduce (*) x) (Seq.windowed num list))

The value digits is just a list of the digits in the string, converted into integers. The function maxproduct works the obvious way: take every subsequence of five digits (Seq.windowed), multiply them together (Seq.reduce, applied to each element of the sequence with Seq.map) and then find the maximum (Seq.max).

The only reason this needs quite so little work is the existence of Seq.windowed in the standard library, which does exactly the right thing in turning a 1000-element list into 996 arrays of subsequences of consecutive digits.

I’m not sure I like ramming all the functions into one line, and I’m sure there must be a way to combine map and reduce without the lambda, which adds a lot of clutter. If this was real code, it would need quite a lot of work to make it readable. However, the standard library is a big win, because the process of ‘windowing’ a sequence is nicely separated from the code. It’s also nice (for toy problems like this, at any rate) that the program is pretty much a definition of the problem, with little thought being necessary as to how to do the processing.

Implementing the Graham Scan for a convex hull in Clojure

I saw implementation of the Graham scan mentioned in Real World Haskell as an exercise. I figured I’d have a go at doing it in Clojure, as it might prove useful for another project I was doing in a combination of Java and Clojure.

I’m mentioning this here as it really illustrated to me the power of Clojure basing itself on the JVM. During the development of this inherently graphical algorithm, I was able to quickly cobble together a Swing UI that showed what was going on. Working with the UI was very nearly as responsive as working at a REPL (indeed, UI elements were being drawn and redrawn as a result of commands from the REPL) and illustrated what was going on with the algorithm far better. For the first time ever I didn’t feel the dichotomy between dynamic and graphical ways of working with code.

I was also able to follow a very test-driven approach with test-is. This works so well at the REPL that it starts to make my work with C++ seem laughable.

The main body of the algorithm itself was something that seemed to fit well into Clojure’s loop construct as it’s inherently iterative rather than recursive. This was the first time I’ve done something where the loop seemed more natural than both the recursive solution and a for / while loop in C++. I tend to like declarations of intent in code, and listing the variables that are going to vary at the top of the loop seems like a sensible piece of discipline.

For what it’s worth, here’s the code of the main algorithm:

(defn make-convex-hull
  "Make a convex hull for a set of points, all of which are assumed to have positive x and y
coordinates. Returns a vector of lines, each of which is a sequence of two points"
  (let [starting-point (find-starting-point points)
        remaining-points (remove #(= % starting-point) points)
        working-set (sort angle-comparator remaining-points)]
    (loop [remaining-points working-set
           p1 starting-point
           p2 (first working-set)
           p3 (second working-set)
           hull []]
      (if (= p3 (last working-set))
        ; We have reached the end of the set, return the full hull
        (if (left-turn? p1 p2 p3)
          (concat hull [[p1 p2] [p2 p3] [p3 starting-point]])
          (concat hull [[p1 p3] [p3 starting-point]]))

        ; Does this form a left turn?
        (if (left-turn? p1 p2 p3)
          (recur (rest remaining-points) p2 p3 (nth remaining-points 2) (conj hull [p1 p2]))
          (recur (rest remaining-points) p1 p3 (nth remaining-points 2) hull))))))

You can also download a complete tarball. Note that this is a tarball of a darcs repository, so if you’re someone who might want to employ me you can see a full history of how I worked on the project. And if you’re a potential employer who knows how to use darcs, I might be interested in hearing from you. 🙂