RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved string analysis and format conversion. (Note that this ends today.)

Task 1: String Alike

You are given a string of even length.

Write a script to find if the given string split into two halves of equal lengths and they both have same number of vowels.

One way to do this would be to iterate over half the string, and use a half-string offset. But I took a slightly different approach. Kotlin:

I only use the vowel tester in one place, but it's easiest to break it out into its own thing.

fun is_vowel(c: Char): Boolean {
    return when (c.lowercaseChar()) {
        'a', 'e', 'i', 'o', 'u' -> true
        else -> false
    }
}

fun stringalike(a: String): Boolean {

Bail out immediately if the string is not of even length.

    if (a.length % 2 == 1) {
        return false
    }

Set up variables. vt is the running vowel count, mode adds to that count, and av logs the presence of any vowels at all.

    var vt = 0
    var mode = 1
    var av = false

Iterate over the characters in the string.

    a.toList().forEachIndexed { i, c ->

If we've reached the half-way point, change mode to -1.

                                  if (i * 2 == a.length) {
                                      mode = -1
                                  }

If we get a vowel, increment (in the first half of the string) or decrement (in the second half) the vowel count. Also flag that we've seen any at all.

                              if (is_vowel(c)) {
                                  av = true
                                  vt += mode
                              }
    }

The test is true if we've seen any vowels, and the balanced vowel count has got back to zero.

    return av && (vt == 0)
}

Task 2: Convert Time

You are given two strings, $source and $target, containing time in '24-hour' time form.

Write a script to convert the source into target by performing one of the following operations:

1. Add 1 minute

2. Add 5 minutes

3. Add 15 minutes

4. Add 60 minutes

Find the total operations needed to get to the target.

Minimum number of operations; maximum is just the difference in minutes.

Convert the "hour:minute" format to a minute count.

sub hm2m($a) {
    my @p = $a.comb(/\d+/);
    @p[0] * 60 + @p[1];
}

sub converttime($ssrc, $ttgt) {

Convert the inputs to minute counts.

    my $src = hm2m($ssrc);
    my $tgt = hm2m($ttgt);

If we wrap over midnight, add minutes to avoid this.

    if ($tgt < $src) {
        $tgt += 24 * 60;
    }

Store a working difference and an operation count.

    my $delta = $tgt - $src;
    my $oc = 0;

For each class of operation,

    for [60, 15, 5, 1] -> $op {

count the number we can apply to delta.

        $oc += $delta div $op;

Then reset delta to what's left after that is done.

        $delta %= $op;
    }
    $oc;
}

Full code on github.