## Introduction

In the 2018 Advent of Code challenged I solved all the puzzles in Groovy. It is pretty obvious, that choosing good data structure is the most important to obtain performant solution. However, the way we iterate over those structures is also very significant, at least when using Groovy.

## Measuring performance

I want to measure how long it takes to sum some numbers. For testing performance of loops I prepared a small function that simply sums some numbers:

```
void printAddingTime(String message, long to, Closure<Long> adder) {
LocalTime start = LocalTime.now()
long sum = adder(to)
println("$message: $sum calculated in ${Duration.between(start, LocalTime.now()).toMillis()} ms")
}
```

Pseudo code for summing functions is below:

```
for i = 1 to n
for j = 1 to n
sum += i * j
end
end
```

`Loops types`

Let’s implement the summing function in various ways.

`collect`

and `sum`

First loop type is to use built-in (by Groovy) function `collect`

and `sum`

on collections (`Range`

it this example):

```
(1..n).collect { long i ->
(1..n).collect { long j ->
i * j
}.sum()
}.sum()
```

`each`

Next, let’s write the same function using `each`

built-in function on collections (`Range`

it this example) and then add results to accumulator variable:

```
long sum = 0
(1..n).each { long i ->
(1..n).each { long j ->
sum += i * j
}
}
return sum
```

`times`

Now instead of using `each`

we could use the function `times`

built-in on `Number`

by Groovy:

```
long sum = 0
n.times { long i ->
n.times { long j ->
sum += (i + 1)*(j+1)
}
}
return sum
```

We have to add `1`

to `i`

and `j`

because times generates numbers from `0`

to `n`

exclusive.

`LongStream`

with `sum`

Java 8 came with a new feature – streams. One example of streams is `LongStream`

. Fortunately, it has `sum`

built-in function, which we can use:

```
LongStream.range(0, n).map { i ->
LongStream.range(0, n).map { j ->
(i + 1) * (j + 1)
}.sum()
}.sum()
```

`LongStream`

generates numbers in the same way as `times`

function, so we also have to add `1`

to `i`

and `j`

here.

`LongStream`

with manual sum

Instead of `sum`

function on `LongStream`

, we can add all numbers manually:

```
long sum = 0
LongStream.range(0, n).forEach { i ->
LongStream.range(0, n).forEach { j ->
sum += (i + 1) * (j + 1)
}
}
return sum
```

`while`

Of course since Groovy inherits from Java a big part of its syntax, we can use the `while`

loop:

```
long sum = 0
long i = 1
while(i <= n){
long j = 1
while(j <= n){
sum+= i*j
++j
}
++i
}
return sum
```

`for`

As we can use `while`

, we can also use `for`

loop in Groovy:

```
long sum = 0
for (long i = 1; i <= n; ++i) {
for (long j = 1; j <= n; ++j) {
sum += i * j
}
}
return sum
```

## Results

My tests I run on Java `1.8`

and Groovy `2.5.5`

. Script `loops.groovy`

was fired using bash script:

```
#!/bin/sh
for x in 10 100 1000 10000 100000; do
echo $x
groovy loops.groovy $x
echo
done
```

Values are in milliseconds

Loop n | 10 | 100 | 1000 | 10000 | 100000 |
---|---|---|---|---|---|

`collect` + `sum` |
7 | 22 | 216 | 16244 | 1546822 |

`each` |
12 | 17 | 118 | 7332 | 706781 |

`times` |
2 | 10 | 109 | 8264 | 708684 |

`LongStream` + `sum` |
7 | 17 | 127 | 7679 | 763341 |

`LongStream` + manual sum |
18 | 35 | 149 | 6857 | 680804 |

`while` |
8 | 20 | 103 | 3166 | 301967 |

`for` |
7 | 10 | 25 | 359 | 27966 |

As you can spot, for small amount of iterations using built-in Groovy functions is good enough, but for much bigger amount of iterations we should use `while`

or `for`

loops like in plain, old Java.

## Show me the code

Code for those examples are available here. You can run those examples on your machine and check performance on your own.