# RogerBW's Blog

The Weekly Challenge 184: Split Sequence 29 September 2022

I’ve been doing the Weekly Challenges. The latest involved modifying and picking things out of sequences. (Note that this is open until 2 October 2022.)

You are given list of strings in the format `aa9999` i.e. first 2 characters can be anything `'a-z'` followed by 4 digits `'0-9'`.

Write a script to replace the first two characters with sequence starting with `'00'`, `'01'`, `'02'` etc.

Don't know why I'd want to, but it's easy enough…

Raku:

``````sub sequencenumber(@list) {
my \$nn = 0;
my @out;
for @list -> \$ins {
@out.push(sprintf('%02d',\$nn) ~ substr(\$ins,2,4));
\$nn++;
}
return @out;
}
``````

The other languages are basically the same, modulo details of how you format an integer into a leading-zero string. (In PostScript I push the characters directly into the string because I'm lazy.)

You are given list of strings containing `0-9` and `a-z` separated by `space` only.

Write a script to split the data into two arrays, one for integers and one for alphabets only.

So we're generating two lists: the first contains lists of digits, the second lists of letters. (From the examples I gather that if one of these sublists would be empty, e.g. one of the input strings contains no digits, that sublist is omitted.)

Kotlin and Rust care enough about types that I can't simply use an array for the outer container, because one element is a list of lists of integers and the other a list of lists of characters; in Rust I use a tuple, and in Kotlin the `Pair` type.

Rust:

``````fn splitarray(list: Vec<&str>) -> (Vec<Vec<u8>>, Vec<Vec<char>>) {
``````

Initialise the output.

``````    let mut out = (Vec::new(), Vec::new());
``````

For each input string:

``````    for ins in list {
``````

Initialise the number and letter lists.

``````        let mut av: Vec<u8> = Vec::new();
let mut bv: Vec<char> = Vec::new();
``````

Then for each character:

``````        for c in ins.chars() {
match c {
``````

If it's a number, evaluate it and stick it on the number list.

``````                '0'..='9' => av.push(c.to_digit(10).unwrap() as u8),
``````

If it's a letter, stick it on the letter list.

``````                'a'..='z' => bv.push(c),
``````

Otherwise ignore it.

``````                _ => {}
}
}
``````

(I think I'm finally getting the hang of `match`. I like it.)

If each list is non-empty, push it into the respective part of the output structure.

``````        if av.len() > 0 {
out.0.push(av);
}
if bv.len() > 0 {
out.1.push(bv);
}
}
``````

And return that.

``````    out
}
``````

The other languages are similar. Having two arrays to build up means I can't use my standard PostScript array-on-stack technique, but instead have to stick them in variables.

Full code on github.