# Bash for Project Euler - really???

### Rodion Gorkovenko ใป4 min read

Whatever language and stack you prefer, **learn bash also!** - that wisdom come to me through years. I was doing electronics and POS-terminals in C++, backend in Java, web with PHP and JS, machine learning in BigData with Python, Scala and many horrible names...

And always there were chores to be done with linux/unix shell scripting!

Let's plan "miniseries" on bash, but let's start with math exercise. To see how bash rocks and know when it sucks :)

For example I pick Project Euler #7 - "10001-st Prime". There would be 3 versions of code and they all are in this git repo for reference.

### Let's Rock!

For generating primes we usually need array to collect them. I usually start by initializing first few elements manually (this helps avoiding spare stop condition inside the loop).

```
#!/usr/bin/env bash
primes=(2 3 5 7)
```

As clever people warn, we add "shebang" header which allows script to properly start if it is executable.

Array is created by enclosing space-separated sequence in parentheses. (non-posix feature, though we can do without them)

Now we create main loop! Just make 20 first primes for test, not thousands...

```
next=9 # next number to try
while [[ ${#primes[@]} -lt 20 ]] ; do
#here we put more code
next=$((next+2))
done
```

we understand `while`

and `do`

and `done`

, but what is this whimsical expression? Well, logical expressions are tested in square brackets, `-lt`

is "numerical" comparison for "less than" and `${#primes[@]}`

is curious expression of the length of array. Bash has funny syntax sometimes.

Now the code inside.

At every iteration we are going to test if `next`

is divisible by anything in array `primes`

, starting from beginning.

```
i=0
while true ; do
p=${primes[i]}
if [[ $((next % p)) -eq 0 ]] ; then
# next is divisible by p, not prime, halt
break
fi
# some end condition we add at next step...
i=$((i+1))
done
```

Here we see new features - `if - fi`

block (it supports `else`

too), `-eq`

operator for numeric equality and forms `$((...))`

for evaluating numeric expressions. Shell heavily deals with text so usually variables are treated as strings, not numbers.

Now how we decide new prime is found? We don't need to go till end of `primes`

, it's enough to stop when `p`

is greater than `sqrt(next)`

- let's add it to the loop:

```
if [[ $((p * p)) -gt $next ]] ; then
primes+=($next)
break
fi
```

Looks good! Let's print out `primes`

after main loop ended to check:

```
# various code before...
next=$((next+2))
done
echo ${primes[@]}
```

Curiously, syntax for "whole array" is quite close to syntax of taking length... Now I save this into file `pe-7.sh`

, set executable flag and run:

```
$ chmod a+x pe-7.sh
$ ./pe-7.sh
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71
```

Wonderful! Now we need two small changes:

- replace
`20`

with`10001`

in the main loop condition - don't print whole array, but only its last element with
`${primes[-1]}`

Feel free to check the whole code in github - it's brief.

Run the program with `time`

program to see how long it takes :)

```
$ time ./pe-7.sh
104743
real 0m12.896s
user 0m12.881s
sys 0m0.004s
```

Result is correct. **But wow, 13 seconds** - definitely bash is not intended to be the fastest. However there are faster shell versions (e.g. `dash`

) and on other hand I'll show you how to make it much slower :)

### Refactor it

Bash supports functions. Let's extract inner loop into function. It can be checked that running time doesn't increase seriously.

```
tryprime() {
local try=$1 # $1 is the 1-st parameter
i=0
while true ; do
p=${primes[i]}
if [[ $((try % p)) -eq 0 ]] ; then
break
fi
if [[ $((p * p)) -gt $try ]] ; then
primes+=($try)
break
fi
i=$((i+1))
done
}
```

The function takes single parameter and puts it into local variable. Curiously, parameters are not passed in the parentheses :)

We don't return value, rather just add it to `primes`

global array. I'll explain this bit later.

Now call the function in main loop:

```
next=9
while [[ ${#primes[@]} -lt 10001 ]] ; do
tryprime $next
next=$((next+2))
done
```

Hey, that's neat! Full code in GH. And it still works - took 14 seconds...

### Performance Pitfall

Now just small change to **make it sloooooow**!

Let's return value from function. This is not done by `return`

(which serves for other purpose). We rather print value in the function and capture it from output on call:

```
# change this inside function
# primes+=($try)
# to this
echo $try
#and main loop will be:
while [[ ${#primes[@]} -lt 10001 ]] ; do
found=$(tryprime $next)
primes+=($found)
next=$((next+2))
done
```

The complete code is here. Run it to get... 76 seconds!!!

Well, bash is shell version designed for reach user-friendly features, not for speed. But it is important to know such pitfalls :)

**Thanks for reading that far!** Let's meet next time to make some web-related work with bash :)