my $startsWithVowel = rx/ :i ^<[aeiou]> /;

sub goatLatin($sentence) {
  my @words = $sentence.comb(/\S+/);
  my $a_count = 1;
  for @words <-> $word {
    if ($word ~~ $startsWithVowel) {
      $word ~= 'ma';
    }
    else {
      my $first = $word.substr(0,1);
      my $rest  = $word.substr(1);
      $word = $rest ~ $first ~ 'ma';
    }
    $word ~= 'a' x $a_count++;
  }
  return @words.join(' ');
}

my $startsWithVowel = qr/ ^[aeiou] /ix;

sub goatLatin($sentence) {
  my @words = split /\s+/, $sentence;
  my $a_count = 1;
  foreach my $word ( @words ) {
    if ($word =~ /$startsWithVowel/) {
      $word .= 'ma';
    }
    else {
      my $first = substr($word, 0, 1);
      my $rest  = substr($word, 1);
      $word = $rest . $first . 'ma';
    }
    $word .= 'a' x $a_count++;
  }
  return join(' ', @words);
}

import re

startsWithVowel = re.compile(r'^[aeiou]', re.I)

def goatLatin(sentence):
  words = sentence.split()
  new_words = []
  a_count = 1
  for word in words:
    if re.search(startsWithVowel, word):
      new_words.append(word + 'ma')
    else:
      first = word[0:1]
      rest  = word[1:]
      new_words.append(rest + first + 'ma')
    new_words[-1] += 'a' * a_count
    a_count += 1
  return ' '.join(new_words)

  @startsWithVowel Regex.compile!("^[aeiou]", "i")
  
  def addAs([], list, _), do: list

  def addAs([first | rest], list, a_count) do
    list = list ++ [ first <> String.duplicate("a", a_count) ]
    addAs(rest, list, a_count + 1)
  end

  def goatWord(word) do
    if Regex.run(@startsWithVowel, word) do
      word <> "ma"
    else
      first = String.first(word)
      rest  = String.slice(word, 1 .. -1//1)
      rest <> first <> "ma"
    end
  end

  def goatLatin(sentence) do
    String.split(sentence)
    |> Enum.map(&goatWord/1)
    |> addAs([], 1)
    |> Enum.join(" ")
  end

sub routeTimes(@route) {
  my ($interval, $start, $duration) = @route;
  my %times;
  while ($start < 60 + $interval) {
    %times{$start} = $start + $duration;
    $start += $interval;
  }
  return %times;
}

sub faster(@routes) {
  # find the arrival times for each route's departures
  my %times;
  for @routes -> @route {
    for routeTimes(@route).kv -> $start, $arrive {
      if (%times{$start}:exists && %times{$start} > $arrive) {
        # this departure for this route will arrive sooner than
        # the departure for the earlier route, keep this one!
        %times{$start} = $arrive;
      }
      elsif (%times{$start}:!exists) {
        # no route we've seen has a departure at this time
        %times{$start} = $arrive;
      }
    }
  }

  # now look at all the departures and see if there are
  # later departures with earlier arrivals
  my @bad_starts;
  my @starts = %times.keys.sort: *.Int;
  for @starts.kv -> $pos, $start {
    for @starts[$pos+1 .. *] -> $i {
      if (%times{$i} < %times{$start} ) {
        # we found a later departure with an earlier arrival!
        @bad_starts.push($start);
      }
    }
  }
  @bad_starts = @bad_starts.unique;

  # now determine which minutes of the hour we should say
  # "skip the next bus and take the later one"
  my @skip;
  for 0 .. 59 -> $min {
    if (@starts && @bad_starts && @starts[0] == @bad_starts[0]) {
      # we're in a bad window!
      @skip.push($min);
    }
    if (@starts && @starts[0] == $min) {
      @starts.shift; # remove the start time
    }
    if (@bad_starts && @bad_starts[0] == $min) {
      @bad_starts.shift; # remove the bad start time
    }
  }
  return @skip;
}

use List::Util qw( mesh uniq );

sub routeTimes($route) {
  my ($interval, $start, $duration) = @$route;
  my %times;
  while ($start < 60 + $interval) {
    $times{$start} = $start + $duration;
    $start += $interval;
  }
  return %times;
}

sub faster(@routes) {
  # find the arrival times for each route's departures
  my %times;
  foreach my $route ( @routes ) {
    foreach my($start, $arrive) ( routeTimes($route) ) {
      if (exists $times{$start} && $times{$start} > $arrive) {
        # this departure for this route will arrive sooner than
        # the departure for the earlier route, keep this one!
        $times{$start} = $arrive;
      }
      elsif (! exists $times{$start}) {
        # no route we've seen has a departure at this time
        $times{$start} = $arrive;
      }
    }
  }

  # now look at all the departures and see if there are
  # later departures with earlier arrivals
  my @bad_starts;
  my @starts = sort { $a <=> $b } keys %times;
  foreach my($pos, $start) ( mesh [0 .. $#starts], \@starts ) {
    foreach my $i (@starts[$pos+1 .. $#starts]) {
      if ($times{$i} < $times{$start} ) {
        # we found a later departure with an earlier arrival!
        push @bad_starts, $start;
      }
    }
  }
  @bad_starts = uniq @bad_starts;

  # now determine which minutes of the hour we should say
  # "skip the next bus and take the later one"
  my @skip;
  foreach my $min ( 0 .. 59 ) {
    if (@starts && @bad_starts && $starts[0] == $bad_starts[0]) {
      # we're in a bad window!
      push @skip, $min;
    }
    if (@starts && $starts[0] == $min) {
      shift @starts; # remove the start time
    }
    if (@bad_starts && $bad_starts[0] == $min) {
      shift @bad_starts; # remove the bad start time
    }
  }
  return @skip;
}

def routeTimes(route):
  (interval, start, duration) = route
  times = {}
  while (start < 60 + interval):
    times[start] = start + duration
    start += interval
  return times

def faster(routes):
  # find the arrival times for each route's departures
  times = {}
  for route in routes:
    for start, arrive in routeTimes(route).items():
      if (start in times) and (times[start] > arrive):
        # this departure for this route will arrive sooner than
        # the departure for the earlier route, keep this one!
        times[start] = arrive
      elif (start not in times):
        # no route we've seen has a departure at this time
        times[start] = arrive

  # now look at all the departures and see if there are
  # later departures with earlier arrivals
  bad_starts = []
  starts = sorted(times.keys(), key=int)
  for pos, start in enumerate(starts):
    for i in starts[pos+1:]:
      if (times[i] < times[start]):
        # we found a later departure with an earlier arrival!
        if start not in bad_starts:
          bad_starts.append(start)

  # now determine which minutes of the hour we should say
  # "skip the next bus and take the later one"
  skip = []
  for min in range(60):
    if (starts and bad_starts and starts[0] == bad_starts[0]):
      # we're in a bad window!
      skip.append(min)
    if (starts and starts[0] == min):
      starts.pop(0) # remove the start time
    if (bad_starts and bad_starts[0] == min):
      bad_starts.pop(0) # remove the bad start time

  return skip