# Project Euler Problem 1 with Clojure, Python, Javascript and C++

Tue, Mar 16, 2021 in post General javascript clojure python c++ euler project euler problem

I've long thought about learning Lisp. Some time ago I ran across Clojure and the map, set and vector implementations felt like a modern addition. It's running on top of JVM which is nice in a sense, but a major pain in the ass when installing. Well, I swallowed my wow to never install JDK again and got Clojure running quite painlessly.

To learn the ropes, I thought it would be a fun idea to rewrite Project Euler problems 1-10 with Clojure to see how it would compare against my language of choice for these types of algorithmic problems, Python.

Just to make it more fun, I decided to implement them in my second favorite language, Javascript as well. Since ECMAScript 9, it's actually a pretty powerful and concise language, and coupling it with Node.js unleashes some serious usage options outside just web pages. Npm dependency hell sucks, but that's a topic for another post. For more bare metal, I'm also doing C++ (basically sticking to C functionality until maps and sets make themselves useful). Let's see how the languages stack up!

# Project Euler Problem 1

The first problem in Project Euler is simple, add up numbers below 1000 that
are divisible with either 3 or 5 (or both). Modulo operator `%`

can be used
to get the remainder of a number when divided by 3 and 5, and basically we
add all numbers that have either modulo as zero.

## Python 3

With Python, the most concise implementation is to use the `sum(iterable)`

and
a list comprehension, netting us a nice one-liner:

```
print(sum(i for i in range(1000) if i%3==0 or i%5==0))
```

## C++

C++ needs a bit of boilerplate to print stuff, and does not have
list comprehension that is as concise, so better just to use a
`for`

loop:

```
#include <iostream>
using namespace std;
int main() {
int s = 0;
for(int i=1; i<1000; i++)
if(i%3==0 || i%5==0) s += i;
cout << s << endl;
}
```

## Javascript

Javascript is essentially the same as above, with a bit less boilerplate:

```
let s = 0;
for(let i=1; i<1000; i++)
if(i%3==0 || i%5==0) s += i;
console.log(s);
```

If we'd like to make it more functional, Javascript `filter`

works nicely. With ES9 we can even create an array `[0, 1, 2, ..., 999]`

with a nice hack:

```
console.log([...Array(1000).keys()]
.filter(i => i%3==0 || i%5==0)
.reduce((a, b) => a + b, 0));
```

## Clojure

Finally we get to the fun stuff. Or the not-so-fun: Clojure is heavily favoring
REPL and the actual project with Leiningen are
ten-file affairs that are just cumbersome to run. Thankfully `clojure p1.clj`

did the trick by itself.

```
(println (apply + (filter #(or (= (mod % 3) 0) (= (mod % 5) 0)) (range 1000))))
```

With the `->>`

operator we can make it perhaps somewhat easier to read:

```
(println (->> (range 1000)
(filter #(or (= (mod % 3) 0) (= (mod % 5) 0)))
(apply + )))
```

My personal favorite is to define a simple `ok`

function instead of
the anonymous one and use that in the oneliner to make a nice two-liner:

```
(defn ok [x] (or (= (mod x 3) 0) (= (mod x 5) 0)))
(println (apply + (filter ok (range 1000))))
```

# Conclusions from Problem 1

There is a nice Polish notation feel in the Clojure versions that make
me think of some scientific calculator (like `bc`

). It is also quite
interesting to note that Javascript with its array filtering can be
quite functional when you want.

Personally, the Python one-liner is the cleanest to my eye, which may be because I'm familiar with the syntax.

## comments