RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved letter rearrangement and number grouping. (Note that this is open until 16 April 2023.)

Task 1: Jumping Letters

You are given a word having alphabetic characters only, and a list of positive integers of the same length.

Write a script to print the new word generated after jumping forward each letter in the given word by the integer in the list. The given list would have exactly the number as the total alphabets in the given word.

Fairly straightforward if we assume ASCII, and since it's a task 1 I did. Easier in languages that have an enumerate or with_index method, but here's the Perl:

sub jumpingletters($word, $jump) {
  my @s = '';
  my $i = 0;
  foreach my $c (split '', $word) {
    my $d = ord($c) + $jump->[$i] % 26;

Because the numbers in jump are always positive, we don't need to range-check the low end.

    if (($c le 'Z' && $d > 90) || $d > 122) {
      $d -= 26;
    }
    push @s,chr($d);
    $i++;
  }
  return join('', @s);
}

Task 2: Rearrange Groups

You are given a list of integers and group size greater than zero.

Write a script to split the list into equal groups of the given size where integers are in sequential order. If it can’t be done then print -1.

As usual, to make things easier across multiple languages some of which have types, I use [] (empty list) for a failing return value rather than -1. (In Rust I could use a Result type, but they only happen in Rust.)

Kotlin:

fun rearrangegroups(list: List<Int>, size: Int): List<List<Int>> {

Count the occurrences of each number.

    var h = mutableMapOf<Int, Int>()
    for (k in list) {
        if (h.contains(k)) {
            h[k] = h[k]!! + 1
        } else {
            h[k] = 1
        }
    }
    var out = ArrayList<List<Int>>()
    while (true) {

Repeatedly look for the minimum number left in the list. If the rearrangement is to be valid, this must be the first of a sequence of length size.

        val m = h.keys.minOrNull()!!
        val res = (m .. m + size - 1).toList()
        for (n in res) {

Check each term in that sequence. If it's in the list, decrement the count and remove it if the count reaches zero; if it isn't, bail out with a failure state.

            if (h.contains(n)) {
                val p = h[n]!! - 1;
                if (p == 0) {
                    h.remove(n)
                } else {
                    h[n] = p
                }
            } else {
                return emptyList<List<Int>>()
            }
        }

Push the sequence onto the output list, and exit when there's nothing left to do.

        out.add(res)
        if (h.size == 0) {
            break
        }
    }
    return out.toList()
}

Full code on github.