# RogerBW's Blog

The Weekly Challenge 198: Count Max 08 January 2023

I’ve been doing the Weekly Challenges. The latest involved analysing a list and counting primes. (Note that this is open until the end of today.)

The Challenge-adjacent programming I did first was a metatest generator. Given a set of tests, which I translated into a YAML-based format, like:

``````---
ch-1:
- function: maxgap
arguments:
- 2
- 5
- 8
- 1
result: 2
- function: maxgap
arguments:
- 3
result: 0
ch-2:
- function: primecount
arguments: 10
result: 4
- function: primecount
arguments: 15
result: 6
- function: primecount
arguments: 1
result: 0
- function: primecount
arguments: 25
result: 9
``````

it can automatically generate the boilerplate files for each challenge in each language, with the tests already laid out (with arrays and strings and so on delimited appropriately for each language), just waiting for me to write the relevant solution functions. V1 was a bit ugly and non-modular; v2 seems to be working, and I plan to release it soon.

On with the challenges!

You are given a list of integers, `@list`.

Write a script to find the total pairs in the sorted list where 2 consecutive elements has the max gap. If the list contains less then 2 elements then return 0.

I prefer a moderately functional style, which I think is exemplified by this Kotlin:

``````fun maxgap(l0: List<Int>): Int {
``````

Take care of the special case.

``````    if (l0.size < 2) {
return 0
}
``````

Get the input values into a sorted list.

``````    var l = ArrayList(l0)
l.sort()
``````

Calculate the gaps between pairs of values. (Yeah, could and arguably should be done with a `map`, but I didn't.)

``````    var q = ArrayList<Int>()
for (i in l.windowed(size = 2)) {
}
``````

Find the biggest gap.

``````    val mq = q.maxOrNull()!!
``````

Filter the list of gaps against that biggest one, and count the results.

``````    return q.filter{it == mq}.size
}
``````

This varies a bit – for example Ruby has a `count` method on enumerables that takes a filter condition and returns a total, thus avoiding my having to build up an output list that I'll immediately throw away.

You are given an integer `\$n > 0`.

Write a script to print the count of primes less than `\$n`.

If you already have a function to generate all primes up to a particular total, whether you've written it for previous challenges or it's available in system libraries, this becomes trivial. Perl:

``````sub primecount(\$l) {
return scalar @{primes(\$l-1)};
}
``````

(Though I did have to modify my standard prime generator logic to return correct lists when the maximum value is lower than 3; this hasn't been a consideration before.)

Full code on github.