Input: $s = "Perl" $t = "Preel"
Output: "e"

Input: $s = "Weekly" $t = "Weeakly"
Output: "a"

Input: $s = "Box" $t = "Boxy"
Output: "y"

sub oddChar($s, $t) {
  # count the characters in $s
  my %count;
  for $s.lc.split('', :skip-empty) -> $c {
    %count{$c}++;
  }
  # find the character in $t that's been added to $s
  for $t.lc.split('', :skip-empty) -> $c {
    if ( %count{$c}:!exists ) {
      # we found the added character!
      return $c
    }
    %count{$c}--;
    %count{$c}:delete if %count{$c} == 0;
  }
  die "No odd character found!";
}

sub oddChar($s, $t) {
  # count the characters in $s
  my %count;
  foreach my $c ( split(//, lc($s)) ) {
    $count{$c}++;
  }
  # find the character in $t that's been added to $s
  foreach my $c ( split(//, lc($t)) ) {
    if ( ! exists $count{$c} ) {
      # we found the added character!
      return $c
    }
    $count{$c}--;
    delete $count{$c} if $count{$c} == 0;
  }
  die "No odd character found!";
}

import sys
from collections import Counter

def oddChar(s, t):
    # count the characters in s
    count = Counter()
    for c in s.lower():
        count[c] += 1

    # find the character in t that's been added to s
    for c in t.lower():
        if c not in count:
            # we found the added character!
            return c
        count[c] -= 1
        if count[c] == 0:
            del count[c]

    sys.exit("No odd character found!")

Input: $p = "Joe hit a ball, the hit ball flew far after it was hit."
       $w = "hit"
Output: "ball"

The banned word "hit" occurs 3 times.
The other word "ball" occurs 2 times.

Input: $p = "Perl and Raku belong to the same family. Perl is the most popular language in the weekly challenge."
       $w = "the"
Output: "Perl"

The banned word "the" occurs 3 times.
The other word "Perl" occurs 2 times.

Example 1:
Input: $p = "Joe hit a ball, the hit ball flew far after it was hit."
       $w = "hit"
Output: "hit."

The banned word "hit" occurs 2 times.
The other word "hit." occurs 1 time.

sub frequentWord($p, $w) {
  # assign the value to a container so we can modify it
  my $paragraph = $p;

  # first, remove punctuation from the paragraph
  # (but we'll leave apostrophes for contractions)
  $paragraph ~~ s:i:g/<-[a..z'\s]>//;

  # count the words in $paragraph
  my %count;
  for $paragraph.lc.split(' ', :skip-empty) -> $pw {
    %count{$pw}++;
  }

  # generate the output about the banned word
  my $bannedCount = %count{$w} // 0;
  my $output = qq/The banned word "$w" occurs $bannedCount /;
  $output ~= ($bannedCount == 1) ?? 'time' !! 'times';
  $output ~= ".\n";

  # delete the banned word from the word count
  %count{$w}:delete;

  # now find the most frequent word left and report on that
  my @sorted = %count.keys.sort: {
    # sort by count
    %count{$^b} <=> %count{$^a}
  };
  my $freqWord  = @sorted[0];
  my $freqCount = %count{$freqWord};

  $output ~= qq/The other word "$freqWord" /;
  $output ~= qq/occurs $freqCount /;
  $output ~= ($freqCount == 1) ?? 'time.' !! 'times.';

  return $freqWord, $output;
}

Example 1:
Input: $p = "Joe hit a ball, the hit ball flew far after it was hit."
       $w = "hit"
Output: "ball"

The banned word "hit" occurs 3 times.
The other word "ball" occurs 2 times.

sub frequentWord($p, $w) {
  # first, remove punctuation from the paragraph
  # (but we'll leave apostrophes for contractions)
  $p =~ s/[^a-z'\s]//ig;

  # count the words in $paragraph
  my %count;
  foreach my $pw ( split(/\s+/, lc($p)) ) {
    $count{$pw}++;
  }

  # generate the output about the banned word
  my $bannedCount = $count{$w} // 0;
  my $output = qq/The banned word "$w" occurs $bannedCount /;
  $output .= ($bannedCount == 1) ? 'time' : 'times';
  $output .= ".\n";

  # delete the banned word from the word count
  delete $count{$w};

  # now find the most frequent word left and report on that
  my @sorted = sort {
    # sort by count
    $count{$b} <=> $count{$a}
  } keys %count;
  my $freqWord  = $sorted[0];
  my $freqCount = $count{$freqWord};

  $output .= qq/The other word "$freqWord" /;
  $output .= qq/occurs $freqCount /;
  $output .= ($freqCount == 1) ? 'time.' : 'times.';

  return $freqWord, $output;
}

import re
from collections import Counter

def frequentWord(p, w):
    # first, remove punctuation from the paragraph
    # (but we'll leave apostrophes for contractions)
    p = re.sub(r'[^a-z\'\s]', '', p.lower())

    # count the words in $paragraph
    count = Counter()
    for pw in p.split():
        count[pw] += 1

    # generate the output about the banned word
    bannedCount = count[w] if w in count else 0
    output = f'The banned word "{w}" occurs {bannedCount} ';
    output += 'time' if bannedCount == 1 else 'times'
    output += ".\n"

    # delete the banned word from the word count
    del count[w]

    # now find the most frequent word left and report on that
    decorated = [ ( count[w], w ) for w in count.keys() ]
    sorted_tuples = sorted(
        decorated,
        # the - before the first element sorts descending
        key=lambda k: -k[0]
    )
    freqWord = sorted_tuples[0][1]
    freqCount = count[freqWord]

    output +=  f'The other word "{freqWord}" '
    output += f'occurs {freqCount} '
    output += 'time.' if freqCount == 1 else 'times.'

    return (freqWord, output)

Input: $n = 27
Output: true

27 = 3 ^ 3

Input: $n = 0
Output: true

0 = 0 ^ 3

Input: $n = 6
Output: false

sub isAPowerOfThree($n, $pow = 0) {
  if ($n == $pow ** 3) {
    return 'true';
  }
  elsif ($n < $pow ** 3) {
    return 'false';
  }
  return isAPowerOfThree($n, $pow + 1);
}

Input: $s = "Raku"
Output: "Ruka"

Input: $s = "Perl"
Output: "Perl"

Input: $s = "Julia"
Output: "Jaliu"

Input: $s = "Uiua"
Output: "Auiu"

sub reverseVowels($s) {
  # split string into letters
  my @letters = $s.split('', :skip-empty);

  # find the vowels
  my @vowels = @letters.grep({ /:i<[aeiou]>/ });

  # replace each vowel in reverse order, converting
  # any uppercase letters to lowercase
  for 0 .. @letters.end -> $i {
    if (@letters[$i] ~~ /:i<[aeiou]>/) {
      @letters[$i] = @vowels.pop.lc;
    }
  }

  # rejoin the array as a string, title casing it
  return tc(@letters.join(''));
}

Input: @words = ("one.two.three","four.five","six")
       $separator = "."
Output: "one","two","three","four","five","six"

Input: @words = ("$perl$$", "$$raku$")
       $separator = "$"
Output: "perl","raku"

sub splitOnSeparator(@words, $separator) {
  my @output;
  for @words -> $str {
    @output.append( $str.split($separator, :skip-empty) );
  }
  return @output;
}

sub splitOnSeparator($separator, @words) {
  my @output;
  foreach my $str ( @words ) {
    push @output, grep { !/^$/ } split(/\Q$separator/, $str);
  }
  return @output;
}

def splitOnSeparator(words, separator):
    output = []
    for str in words:
        output.extend(
            list(filter(lambda w: w>"", str.split(separator)))
        )
    return output

a) The number of 1s in row i is less than the number of 1s in row j.
b) Both rows have the same number of 1 and i < j.

Input: $matrix = [
                   [1, 1, 0, 0, 0],
                   [1, 1, 1, 1, 0],
                   [1, 0, 0, 0, 0],
                   [1, 1, 0, 0, 0],
                   [1, 1, 1, 1, 1]
                 ]
Output: (2, 0, 3, 1, 4)

The number of 1s in each row is:
- Row 0: 2
- Row 1: 4
- Row 2: 1
- Row 3: 2
- Row 4: 5

Input: $matrix = [
                   [1, 0, 0, 0],
                   [1, 1, 1, 1],
                   [1, 0, 0, 0],
                   [1, 0, 0, 0]
                 ]
Output: (0, 2, 3, 1)

The number of 1s in each row is:
- Row 0: 1
- Row 1: 4
- Row 2: 1
- Row 3: 1

sub weakestRows(@matrix) {
  my @oneCount = @matrix.map({ $_.sum });
  my @weakest = (0 .. @oneCount.end).sort: {
    # sort by count first
    @oneCount[$^a] <=> @oneCount[$^b]
    ||
    # then by index order
    $^a <=> $^b
  };

  return @weakest;
}

use List::Util qw( sum );

sub weakestRows(@matrix) {
  my @oneCount = map { sum(@$_) } @matrix;
  my @weakest = sort {
    # sort by count first
    $oneCount[$a] <=> $oneCount[$b]
    ||
    # then by index order
    $a cmp $b
  } (0 .. $#oneCount);

  return @weakest;
}

def weakestRows(matrix):
    oneCount = [ sum(row) for row in matrix ]
    # sort the rows by their oneCount values
    # use the Decorate-Sort-Undecorate idiom
    # to convert the dict into a list
    # https://docs.python.org/3/howto/sorting.html#decorate-sort-undecorate
    decorated = [
        (oneCount[i], i) for i in range(len(oneCount))
    ]
    sorted_tuples = sorted(
        decorated,
        # the - before the first element sorts descending
        key=lambda k: (k[0], k[1])
    )
    weakest = [ t[1] for t in sorted_tuples ]
    return weakest

An element $int[i] of @ints is called special if i divides n, i.e. n % i == 0.
Where n is the length of the given array. Also the array is 1-indexed for the task.

Input: @ints = (1, 2, 3, 4)
Output: 21

There are exactly 3 special elements in the given array:
$ints[1] since 1 divides 4,
$ints[2] since 2 divides 4, and
$ints[4] since 4 divides 4.

Hence, the sum of the squares of all special elements of given array:
1 * 1 + 2 * 2 + 4 * 4 = 21.

Input: @ints = (2, 7, 1, 19, 18, 3)
Output: 63

There are exactly 4 special elements in the given array:
$ints[1] since 1 divides 6,
$ints[2] since 2 divides 6,
$ints[3] since 3 divides 6, and
$ints[6] since 6 divides 6.

Hence, the sum of the squares of all special elements of given array:
2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63

sub specialElementIndices($n) {
  return (1 .. $n).grep({ $n % $_ == 0 });
}

# code borrowed from my code for PWC 229
sub english_list ( *@list ) {
  # given a list, join it in a way that makes sense
  # to english speakers
  my $last = @list.pop(); # last element in array
  if (@list == 0) {
    # using an array in a scalar context returns
    # the number of elements in the array

    # there was only one element in the list
    return $last;
  }
  my $joined = @list.join(qq{,\n});
  if (@list > 1) {
    # if there's more than element, add an Oxford comma
    $joined ~= q{,};
  }
  return "$joined and\n$last";
}

sub specialNumberSquareSum(@ints) {
  my $n = @ints.elems;

  # find the list of indices for "special" numbers
  my @specialIndices = specialElementIndices($n);
  my $count = @specialIndices.elems;
  my @explain_list = @specialIndices.map({
    "\$ints[$_] since $_ divides $n"
  });
  my $explain = "There are exactly $count special elements "
    ~ "in the given array:\n" ~ english_list(@explain_list);

  # find the special numbers themselves
  my @special = @specialIndices.map({ @ints[$_ - 1] });

  # find the sum of the squares
  my $sum = @special.map({ $_ ** 2 }).sum;

  $explain ~= "\nHence, the sum of the squares of all special "
    ~ "elements of given array:\n"
    ~ @special.map({ "$_ * $_" }).join(' + ')
    ~ " = " ~ $sum;

  return (
    $sum,
    $explain
  );
}

use List::Util qw( sum );

sub specialElementIndices($n) {
  return grep { $n % $_ == 0 } 1 .. $n;
}

sub english_list ( @list ) {
  # given a list, join it in a way that makes sense
  # to english speakers
  my $last = pop @list; # last element in array
  if (@list == 0) {
    # using an array in a scalar context returns
    # the number of elements in the array

    # there was only one element in the list
    return $last;
  }
  my $joined = join qq{,\n}, @list;
  if (@list > 1) {
    # if there's more than element, add an Oxford comma
    $joined .= q{,};
  }
  return "$joined and\n$last";
}

sub specialNumberSquareSum(@ints) {
  # in scalar context, an array evaluates to the number
  # of elements in the array
  my $n = @ints;

  # find the list of indices for "special" numbers
  my @specialIndices = specialElementIndices($n);
  my $count = @specialIndices;
  my @explain_list = map {
    "\$ints[$_] since $_ divides $n"
  } @specialIndices;
  my $explain = "There are exactly $count special elements "
    . "in the given array:\n" . english_list(@explain_list);

  # find the special numbers themselves
  my @special = map { $ints[$_ - 1] } @specialIndices;

  # find the sum of the squares
  my $sum = sum( map { $_ ** 2 } @special);

  $explain .= "\nHence, the sum of the squares of all special "
    . "elements of given array:\n"
    . join(' + ', map { "$_ * $_" } @special)
    . " = " . $sum;

  return (
    $sum,
    $explain
  );
}

def specialElementIndices(n):
    return list( filter(lambda x: n % x == 0, range(1, n+1)) )

def english_list (strlist):
    # given a list, join it in a way that makes sense
    # to english speakers
    last = strlist.pop(-1) # last element in array
    if (len(strlist) == 0):
        # using an array in a scalar context returns
        # the number of elements in the array

        # there was only one element in the list
        return last

    joined = ',\n'.join(strlist)
    if (len(strlist) > 1):
        # if there's more than element, add an Oxford comma
        joined += ','

    return f'{joined} and\n{last}'

def specialNumberSquareSum(ints):
    n = len(ints)

    # find the list of indices for "special" numbers
    specialIndices = specialElementIndices(n)
    count = len(specialIndices)
    explain_list = [
        f"$ints[{x}] since {x} divides {n}"
        for x in specialIndices
    ] 
    explain = (
        "There are exactly $count special elements " +
        "in the given array:\n" + english_list(explain_list)
    )

    # find the special numbers themselves
    special = [ ints[x - 1] for x in specialIndices ]

    # find the sum of the squares
    sumval = sum([ x ** 2 for x in special ])

    explain += '\nHence, the sum of the squares of all special '
    explain += 'elements of given array:\n'
    explain += ' + '.join(map(lambda x: f'{x} * {x}', special))
    explain += f' = {sumval}'

    return (
        sumval,
        explain
    )

Input: $n = 5
Output: (-7, -1, 1, 3, 4)

Two other possible solutions could be as below:
(-5, -1, 1, 2, 3) and (-3, -1, 2, -2, 4).

Input: $n = 3
Output: (-1, 0, 1)

Input: $n = 1
Output: (0)

Example 1:
Input: $n = 5
Output: (-2, -1, 0, 1, 2)

Example 2:
Input: $n = 3
Output: (-1, 0, 1)

Example 3:
Input: $n = 1
Output: (0)

sub uniqueSumZero($input) {
  my $n = $input;
  my @list;
  my $x = 1;
  while ($n > 0) {
    if ($n % 2 == 1) { # $n is odd
      @list.push(0);
      $n -= 1;
    }
    else { # $n is even
      @list.append($x * -1, $x);
      $x += 1;
      $n -= 2;
    }
  }
  return @list.sort;
}

sub uniqueSumZero($n) {
  my @list;
  my $x = 1;
  while ($n > 0) {
    if ($n % 2 == 1) { # $n is odd
      push @list, 0;
      $n--;
    }
    else { # $n is even
      push @list, $x * -1, $x;
      $x++;
      $n -= 2;
    }
  }
  return sort { $a <=> $b } @list;
}

def uniqueSumZero(n):
    zero_sum_list = []
    x = 1
    while n > 0:
        if (n % 2 == 1): # n is odd
            zero_sum_list.append(0)
            n -= 1
        else: # n is even
            zero_sum_list.append(x * -1)
            zero_sum_list.append(x)
            x += 1
            n -= 2
    zero_sum_list.sort()
    return zero_sum_list

For example, the concatenation of 10, 21 is 1021.
The concatenation value of @ints is initially equal to 0.
Perform this operation until @ints becomes empty:

If there exists more than one number in @ints, pick the first element and last element in @ints respectively and add the value of their concatenation to the concatenation value of @ints, then delete the first and last element from @ints.

If one element exists, add its value to the concatenation value of @ints, then delete it.

Input: @ints = (6, 12, 25, 1)
Output: 1286

1st operation: concatenation of 6 and 1 is 61
2nd operation: concatenation of 12 and 25 is 1225

Concatenation Value => 61 + 1225 => 1286

Input: @ints = (10, 7, 31, 5, 2, 2)
Output: 489

1st operation: concatenation of 10 and 2 is 102
2nd operation: concatenation of 7 and 2 is 72
3rd operation: concatenation of 31 and 5 is 315

Concatenation Value => 102 + 72 + 315 => 489

Input: @ints = (1, 2, 10)
Output: 112

1st operation: concatenation of 1 and 10 is 110
2nd operation: only element left is 2

Concatenation Value => 110 + 2 => 112

sub concatenationValue(@ints) {
  return 0        if @ints.elems == 0; # no elements
  return @ints[0] if @ints.elems == 1; # one element

  my $first = @ints.shift; # first element
  my $last  = @ints.pop;   # last element
  my $concat = "$first$last".Int; # concatenate and convert

  return $concat + concatenationValue(@ints);
}

sub concatenationValue(@ints) {
  return 0        if @ints == 0; # no elements
  return $ints[0] if @ints == 1; # one element

  my $first = shift @ints; # first element
  my $last  = pop @ints;   # last element
  my $concat = "$first$last"+0; # concatenate and convert

  return $concat + concatenationValue(@ints);
}

def concatenationValue(ints):
    if len(ints) == 0: # no elements
        return 0
    if len(ints) == 1: # one element
        return ints[0]

    first = ints.pop(0);  # first element
    last  = ints.pop(-1); # last element
    concat = int(f"{first}{last}") # concatenate and convert

    return concat + concatenationValue(ints)

A lucky number is an element of the matrix such that it is
the minimum element in its row and maximum in its column.

Input: $matrix = [ [ 3,  7,  8],
                   [ 9, 11, 13],
                   [15, 16, 17] ];
Output: 15

15 is the only lucky number since it is the minimum in its row
and the maximum in its column.

Input: $matrix = [ [ 1, 10,  4,  2],
                   [ 9,  3,  8,  7],
                   [15, 16, 17, 12] ];
Output: 12

Input: $matrix = [ [7 ,8],
                   [1 ,2] ];
Output: 7

sub maxCols(@matrix) {
  my @rotated; # rotate cols to rows
  for @matrix -> @row {
    for @row.kv -> $k, $v {
      @rotated[$k].push($v);
    }
  }
  # return the max of the now rows!
  return @rotated.map({ $_.max() });
}

sub luckyNumber(@matrix) {
  my @minRows = @matrix.map({ $_.min() });
  my @maxCols = maxCols(@matrix);
  return ( @minRows (&) @maxCols ) // -1;
}

use Array::Utils qw( intersect );
use List::Util qw( min max );

sub maxCols(@matrix) {
  my @rotated; # rotate cols to rows
  foreach my $row ( @matrix ) {
    foreach my $k ( 0 .. $#{$row} ) {
      my $v = $row->[$k];
      push @{$rotated[$k]}, $v;
    }
  }
  # return the max of the now rows!
  return map { max( @$_ ) } @rotated;
}

sub luckyNumber(@matrix) {
  my @minRows = map { min( @$_ ) } @matrix;
  my @maxCols = maxCols(@matrix);
  # intersect() returns an array, so get the first element
  return (intersect( @minRows, @maxCols ))[0] // -1;

def maxCols(matrix):
    # initialize rotated with empty row for each column
    rotated = [ [] for col in matrix[0] ]
    for row in matrix:
        for k, v in enumerate(row):
            rotated[k].append(v)
    # return the max of the now rows!
    return [ max(row) for row in rotated ]

def luckyNumber(matrix):
    mRows = [ min(row) for row in matrix ]
    mCols = maxCols(matrix)
    intersection = list( set(mRows) & set(mCols) )
    if intersection:
        return intersection[0]
    else:
        return -1

Input: @ints = (0, 1, 2)
Output: 0

i=0: 0 mod 10 = 0 == $ints[0].
i=1: 1 mod 10 = 1 == $ints[1].
i=2: 2 mod 10 = 2 == $ints[2].
All indices have i mod 10 == $ints[i], so we return the smallest index 0.

Input: @ints = (4, 3, 2, 1)
Output: 2

i=0: 0 mod 10 = 0 != $ints[0].
i=1: 1 mod 10 = 1 != $ints[1].
i=2: 2 mod 10 = 2 == $ints[2].
i=3: 3 mod 10 = 3 != $ints[3].
2 is the only index which has i mod 10 == $ints[i].

Input: @ints = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
Output: -1
Explanation: No index satisfies i mod 10 == $ints[i].

ints[0] = 1
ints[1] = 2
ints[2] = 3
ints[3] = 4
ints[4] = 5
ints[5] = 6
ints[6] = 7
ints[7] = 8
ints[8] = 9
ints[9] = 0

ints[8]  = 9
ints[9]  = 8
ints[10] = 0

sub smallestIndex(@ints) {
  for 0 .. @ints.end -> $i {
    return $i if ($i mod 10) == @ints[$i];
  }
  return -1;
}

sub smallestIndex(@ints) {
  foreach my $i ( 0 .. $#ints ) {
    return $i if ($i % 10) == $ints[$i];
  }
  return -1;
}

def smallestIndex(ints):
    for i in range(len(ints)):
        if (i % 10) == ints[i]:
            return i
    return -1

a) The numeric representation of the string in base 10 if it is made up of digits only.
b) otherwise the length of the string

Input: @alphanumstr = ("perl", "2", "000", "python", "r4ku")
Output: 6

"perl" consists of letters only so the value is 4.
"2" is digits only so the value is 2.
"000" is digits only so the value is 0.
"python" consists of letters so the value is 6.
"r4ku" consists of letters and digits so the value is 4.

Input: @alphanumstr = ("001", "1", "000", "0001")
Output: 1

sub alphanumValue($str) {
  if ($str ~~ /^\d+$/) {
    return Int($str);
  }
  return $str.chars;
}

sub maxAlphanumValue(@alphanumstr) {
  my @values = @alphanumstr.map({ alphanumValue($_) });
  return @values.max;
}

use List::Util qw( max );

sub alphanumValue($str) {
  if ($str =~ /^\d+$/) {
    return $str + 0;
  }
  return length($str);
}

sub maxAlphanumValue(@alphanumstr) {
  my @values = map { alphanumValue($_) } @alphanumstr;
  return max(@values);
}

import re

is_numeric = re.compile('^\d+$')

def alphanumValue(strval):
    if (is_numeric.match(strval)):
        return int(strval)
    return len(strval)

def maxAlphanumValue(alphanumstr):
    values = [ alphanumValue(x) for x in alphanumstr ]
    return max(values)

a) Each element belongs to exactly one pair.
b) The elements present in a pair are equal.

Input: @ints = (3, 2, 3, 2, 2, 2)
Output: (2, 2), (3, 3), (2, 2)

There are 6 elements in @ints.
They should be divided into 6 / 2 = 3 pairs.
@ints is divided into the pairs (2, 2), (3, 3), and (2, 2) satisfying all the conditions.

Input: @ints = (1, 2, 3, 4)
Output: ()

There is no way to divide @ints 2 pairs such that the pairs satisfy every condition.

sub equalPairs(@ints) {
  my @pairs;
  my %num_count;
  # count how many of each int we have
  for @ints -> $num {
    %num_count{$num}++;
  }
  # first, make sure we have even numbers of each integer
  for %num_count.kv -> $k, $v {
    next if $v % 2 == 0; # it's even, we can make pairs
    return @pairs; # we have an odd number, can't make pairs
  }
  # now make pairs from those integers
  for %num_count.kv -> $k, $v {
    my $count = $v; # the values $k, $v are read-only
    while ($count > 0) {
      @pairs.push( [$k, $k] );
      $count -= 2;
    }
  }
  return @pairs;
}

sub equalPairs(@ints) {
  my @pairs;
  my %num_count;
  # count how many of each int we have
  foreach my $num ( @ints ) {
    $num_count{$num}++;
  }
  # first, make sure we have even numbers of each integer
  foreach my $k ( keys %num_count ) {
    my $v = $num_count{$k};
    next if $v % 2 == 0; # it's even, we can make pairs
    return @pairs; # we have an odd number, can't make pairs
  }
  # now make pairs from those integers
  foreach my $k ( keys %num_count ) {
    my $count = $num_count{$k};
    while ($count > 0) {
      push @pairs, [$k, $k];
      $count -= 2;
    }
  }
  return @pairs;
}

from collections import Counter

def equalPairs(nums):
    pairs = []
    num_count = Counter()
    # count how many of each int we have
    for num in nums:
        num_count[num] += 1

    # first, make sure we have even numbers of each integer
    for k, v in dict(num_count).items():
        if v % 2 == 0: # it's even, we can make pairs
            continue
        else:
            return pairs # we have an odd number, no pairs

    # now make pairs from those integers
    for k, v in dict(num_count).items():
        count = v # the values k, v are read-only
        while count > 0:
            pairs.append( [k, k] )
            count -= 2

    return pairs

s[i] == 'I' ⇒ perm[i] < perm[i + 1]
s[i] == 'D' ⇒ perm[i] > perm[i + 1]

Input: $str = "IDID"
Output: (0, 4, 1, 3, 2)

Input: $str = "III"
Output: (0, 1, 2, 3)

Input: $str = "DDI"
Output: (3, 2, 0, 1)

sub diStringMatch($str) {
  my @permutation;
  # first, generate the list of integers
  # we're making permutations of
  my @nums = 0 .. $str.chars;
  # now let's generate our permutation
  for $str.split('', :skip-empty) -> $c {
    if ($c eq 'D') {
      # take the largest number available
      @permutation.push( @nums.pop() );
    }
    else {
      # take the smallest number available
      @permutation.push( @nums.shift() );
    }
  }
  # add last remaining number
  @permutation.push( @nums[0] );

  return @permutation;
}

sub diStringMatch($str) {
  my @permutation;
  # first, generate the list of integers
  # we're making permutations of
  my @nums = 0 .. length($str);
  # now let's generate our permutation
  foreach my $c ( split(//, $str) ) {
    if ($c eq 'D') {
      # take the largest number available
      push @permutation, pop(@nums);
    }
    else {
      # take the smallest number available
      push @permutation, shift(@nums);
    }
  }
  # add last remaining number
  push @permutation, $nums[0];

  return @permutation;
}

def diStringMatch(str):
    permutation = []
    # first, generate the list of integers
    # we're making permutations of
    nums = list(range(len(str)+1))
    # now let's generate our permutation
    for c in str:
        if c == 'D':
            # take the largest number available
            permutation.append( nums.pop(-1) )
        else:
            # take the smallest number available
            permutation.append( nums.pop(0) )
    # add last remaining number
    permutation.append( nums[0] )

    return permutation

b[i,k] = a[i,k] + a[i,k+1] + a[i+1,k] + a[i+1,k+1]

Input: $a = [
              [1,  2,  3,  4],
              [5,  6,  7,  8],
              [9, 10, 11, 12]
            ]

Output: $b = [
               [14, 18, 22],
               [30, 34, 38]
             ]

Input: $a = [
              [1, 0, 0, 0],
              [0, 1, 0, 0],
              [0, 0, 1, 0],
              [0, 0, 0, 1]
            ]

Output: $b = [
               [2, 1, 0],
               [1, 2, 1],
               [0, 1, 2]
             ]

sub submatrixSum(@a) {
  # subtract 1 because we're 0-indexed
  my $M = @a.elems - 1;    # rows
  my $N = @a[0].elems - 1; # columns
  # we are ASSUMING the matrix is consistent with
  # each row having the same number of columns
  my @b;
  for 0 .. $M - 1 -> $i {
    for 0 .. $N - 1 -> $k {
      @b[$i;$k] = @a[$i;  $k] + @a[$i;  $k+1]
                + @a[$i+1;$k] + @a[$i+1;$k+1];
    }
  }
  return @b;
}

sub submatrixSum(@a) {
  my $M = $#a;       # rows
  my $N = $#{$a[0]}; # columns
  # we are ASSUMING the matrix is consistent with
  # each row having the same number of columns
  my @b;
  foreach my $i ( 0 .. $M - 1 ) {
    push @b, [];
    foreach my $k ( 0 .. $N - 1 ) {
      $b[$i]->[$k] = $a[$i]->[$k]   + $a[$i]->[$k+1]
                   + $a[$i+1]->[$k] + $a[$i+1]->[$k+1];
    }
  }
  return @b;
}

def submatrixSum(a):
    # subtract 1 because we're 0-indexed
    M = len(a) - 1    # rows
    N = len(a[0]) - 1 # columns
    # we are ASSUMING the matrix is consistent with
    # each row having the same number of columns
    b = []
    for i in range(M): # range is 0 .. M-1
        row = []
        for k in range(N):
            row.append( a[i  ][k] + a[i  ][k+1] +
                        a[i+1][k] + a[i+1][k+1] )
        b.append(row)
    return b

distance[i] is the distance from index i to the closest occurrence
of the given character in the given string.

The distance between two indices i and j is abs(i - j).

Input: $str = "loveleetcode", $char = "e"
Output: (3,2,1,0,1,0,0,1,2,2,1,0)

The character 'e' appears at indices 3, 5, 6, and 11 (0-indexed).
The closest occurrence of 'e' for index 0 is at index 3, so the distance is abs(0 - 3) = 3.
The closest occurrence of 'e' for index 1 is at index 3, so the distance is abs(1 - 3) = 2.
For index 4, there is a tie between the 'e' at index 3 and the 'e' at index 5,
but the distance is still the same: abs(4 - 3) == abs(4 - 5) = 1.
The closest occurrence of 'e' for index 8 is at index 6, so the distance is abs(8 - 6) = 2.

Input: $str = "aaab", $char = "b"
Output: (3,2,1,0)

sub shortestDistance($str, $char) {
  # split the string into an array of characters
  my @strchar = $str.split('', :skip-empty);
  # find the positions of the target $char
  my @pos = (0 .. @strchar.end).grep: { @strchar[$_] eq $char };

  my @output;
  for 0 .. @strchar.end -> $i {
    # find the distances
    my @distance = @pos.map: { abs($i - $_) };
    # find the minimum distance
    @output.push( @distance.min );
  }
  return @output;
}

sub shortestDistance($str, $char) {
  # split the string into an array of characters
  my @strchar = split(//, $str);
  # find the positions of the target $char
  my @pos = grep { $strchar[$_] eq $char } 0 .. $#strchar;
  
  my @output;
  foreach my $i ( 0 .. $#strchar ) {
    # find the distances
    my @distance = map { abs($i - $_) } @pos;
    # find the minimum distance
    push @output, min(@distance);
  }
  return @output;
}

def shortestDistance(s, c):
    # split the string into an array of characters
    strchar = list(s)
    # find the positions of the target char
    pos = [ x for x in range(len(s)) if strchar[x] == c ]

    output = []
    for i in range(len(s)):
        # find the distances
        distance = [ abs(i - p) for p in pos ]
        # find the minimum distance
        output.append(  min(distance) )
    return output

The givers are randomly chosen but don't share family names with the receivers.

Input: @names = ('Mr. Wall',
                 'Mrs. Wall',
                 'Mr. Anwar',
                 'Mrs. Anwar',
                 'Mr. Conway',
                 'Mr. Cross',
                );

Output:

    Mr. Conway -> Mr. Wall
    Mr. Anwar -> Mrs. Wall
    Mrs. Wall -> Mr. Anwar
    Mr. Cross -> Mrs. Anwar
    Mr. Wall -> Mr. Conway
    Mrs. Anwar -> Mr. Cross

One gift is given to a family member.

Input: @names = ('Mr. Wall',
                 'Mrs. Wall',
                 'Mr. Anwar',
                );

Output:

    Mr. Anwar -> Mr. Wall
    Mr. Wall -> Mrs. Wall
    Mrs. Wall -> Mr. Anwar

Output:
    Mr. Cross ->
    Mr. Wall -> Mr. Conway
    Mr. Anwar -> Mrs. Wall
    Mrs. Anwar -> Mr. Wall
    Mr. Conway -> Mrs. Anwar
    Mrs. Wall -> Mr. Anwar

sub findRecipient($giver, %recipients) {
  # since %recipients is passed by reference, we can't
  # modify it, so let's make a copy with the giver removed
  my @recipients = %recipients.keys.grep({ !/$giver/ });

  # split on whitespace and take the last element
  # to get the "family name"
  my $family_name = split(" ", $giver)[*-1];

  # now, make a potential recipient hash
  # excluding family members
  my @non_family_members =
    @recipients.grep({ !/$family_name/ });

  if (@non_family_members > 0) {
    return @non_family_members.pick;
  }
  else {
    return @recipients.pick;
  }
}

sub secretSanta(@names) {
  # let's use a hash to hold the giver/recipient pairings
  my %results;
 
  # put our work in a labelled loop
  ASSIGN_RECIPIENTS: loop {
    # convert the array of names into a hash with names as keys
    my %available_recipients = @names.map: * => 1;

    # now go through each of the names and find a
    # recipient for them
    for @names -> $giver {
      my $recipient =
        findRecipient($giver, %available_recipients);

      # occasionally, we assign recipients so in the last
      # iteration of the for loop the only available
      # recipient is $giver. When that happens, the easiest
      # way to fix things is to just re-do the entire list
      redo ASSIGN_RECIPIENTS if ! defined $recipient;

      %results{$giver} = $recipient;
      %available_recipients{$recipient}:delete;
    }
    last; # exit the labelled loop
  }
  return %results;
}

use List::Util qw( sample );

sub findRecipient($giver, $recipients) {
  # since $recipients is a reference to a hash, we can't
  # modify it, so let's make a copy with the giver removed
  my @recipients = grep { !/$giver/ } keys %$recipients;

  # split on whitespace and take the last element
  # to get the "family name"
  my $family_name = (split /\s+/, $giver)[-1];

  # now, make a potential recipient hash
  # excluding family members
  my @non_family_members =
    grep { !/$family_name/ } @recipients;

  if (@non_family_members > 0) {
    return sample(1, @non_family_members);
  }
  else {
    return sample(1, @recipients);
  }
}

sub secretSanta(@names) {
  # let's use a hash to hold the giver/recipient pairings
  my %results;
 
  # put our work in a labelled loop
  ASSIGN_RECIPIENTS: while () {
    # convert the array of names into a hash with names as keys
    my %available_recipients = map { $_ => 1 } @names;

    # now go through each of the names and find a
    # recipient for them
    foreach my $giver ( @names ) {
      my $recipient =
        findRecipient($giver, \%available_recipients);

      # occasionally, we assign recipients so in the last
      # iteration of the for loop the only available
      # recipient is $giver. When that happens, the easiest
      # way to fix things is to just re-do the entire list
      redo ASSIGN_RECIPIENTS if ! defined $recipient;

      $results{$giver} = $recipient;
      delete $available_recipients{$recipient};
    }
    last; # exit the labelled loop
  }
  return %results;
}

from random import sample
import re

def findRecipient(giver, recipients):
    # exclude the giver from the recipient list
    possible_recipients = [
        name for name in recipients if name != giver
    ]

    # if there are no possible recipients, bail early
    if len(recipients) == 0:
        return None

    # split on whitespace and take the last element
    # to get the "family name"
    family_name = re.compile((giver.split())[-1])

    # now, make a potential recipient list
    # excluding family members
    non_family_members = [
        name for name in possible_recipients \
            if not family_name.search(name)
    ]

    # sample() returns a LIST, so just return the first elem
    if len(non_family_members) > 0:
        return sample(non_family_members, 1)[0]
    else:
        return sample(recipients, 1)[0]

def secretSanta(names):
    # let's use a dictionary to hold the giver/recipient
    # pairings
    results = {}
 
    # copy the names into a new list
    available_recipients = names.copy()

    # now go through each of the names and find a
    # recipient for them
    must_redo = False
    for giver in names:
        recipient = findRecipient(giver, available_recipients)
        if recipient is None:
            must_redo = True
        results[giver] = recipient
        available_recipients.remove(recipient)

    if must_redo:
        return secretSanta(names)
    else:
        return results

Input: $s = 'abcdbca'
Output: 'bc'

'bc' appears twice in `$s`

Input: $s = 'cdeabeabfcdfabgcd'
Output: 'ab'

'ab' and 'cd' both appear three times in $s and 'ab' is lexicographically smaller than 'cd'.

use Lingua::Conjunction;
use Lingua::EN::Numbers;

sub pairCount($string) {
  my $s = $string; # make a copy so we can modify it
  my %count;
  while ($s.chars > 1) {
    my $pair = substr($s, 0..1); # the first two characters
    %count{$pair}++;          # count the pair
    $s = substr($s, 1, *); # remove the first character
  }
  return %count;
}

sub mostFrequentPair($s) {
  # count the letter pairs
  my %pairs = pairCount($s);

  # sort the pairs by their counts
  my @sorted = %pairs.keys.sort: {
    # sort by count first
    %pairs{$^b} <=> %pairs{$^a}
    ||
    # then by lexicographical order
    $^a cmp $^b
  };

  my @max_pair  = shift(@sorted); # pull off first value
  my $max_count = %pairs{@max_pair[0]}; # get it's count

  while ( %pairs{@sorted[0]} == $max_count ) {
    # there are pairs on the sorted list that have the
    # same count, so let's put them on the list, too
    @max_pair.append( shift(@sorted) );
  }
  my $explain;

  # set aside the pair that sorted to the top
  my $first_pair = @max_pair[0];

  # now quote all the pairs
  @max_pair = @max_pair.map: { qq{'$_'} };

  # make the count an english word
  my $count =  ($max_count == 1) ?? 'once'      # 🎶
            !! ($max_count == 2) ?? 'twice'     # 🎶
            !! cardinal($max_count) ~ ' times'; # a lady 🎶

  # and format the explanation
  if (@max_pair == 1) {
    $explain = "'$first_pair' appears $count in \$s";
  }
  else {
    my $str = qq{|list| appear $count in \$s and }
            ~ qq{'$first_pair' is lexicographically smallest.};
    $explain = conjunction @max_pair, :$str;
  }

  return $first_pair, $explain;
}

use Lingua::EN::Inflexion qw( noun wordlist );

sub pairCount($s) {
  my %count;
  while (length($s) > 1) {
    my $pair = substr($s, 0, 2); # the first two characters
    $count{$pair}++;        # count the pair
    $s = substr($s, 1); # remove the first character
  }
  return %count;
}

sub mostFrequentPair($s) {
  # count the letter pairs
  my %pairs = pairCount($s);

  # sort the pairs by their 
  my @sorted = sort {
    # sort by count first
    $pairs{$b} <=> $pairs{$a}
    ||
    # then by lexicographical order
    $a cmp $b
  } keys %pairs;

  my @max_pair  = shift(@sorted); # pull off first value
  my $max_count = $pairs{$max_pair[0]}; # get it's count

  while ( $pairs{$sorted[0]} == $max_count ) {
    # there are pairs on the sorted list that have the
    # same count, so let's put them on the list, too
    push @max_pair, shift(@sorted);
  }
  my $explain;

  # set aside the pair that sorted to the top
  my $first_pair = $max_pair[0];

  # now quote all the pairs
  my $pair_list = wordlist( map { qq{'$_'} } @max_pair );

  # make the count an english word
  my $count = ($max_count == 1) ? 'once'             # 🎶
            : ($max_count == 2) ? 'twice'            # 🎶
            : noun($max_count)->cardinal . ' times'; # a lady 🎶

  # and format the explanation
  if (@max_pair == 1) {
    $explain = "'$first_pair' appears $count in \$s";
  }
  else {
    $explain = $pair_list . " appear $count in \$s and "
             . "'$first_pair' is lexicographically smallest.";
  }

  return $first_pair, $explain;
}

from collections import Counter
from num2words import num2words

def conjunction(words):
    if len(words) < 2:
        return(words)
    elif len(words) == 2:
        return(f'{words[0]} and {words[1]}')
    else:
        last = words.pop(-1)
        l = ', '.join(words)
        return(f'{l}, and {last}')

def pairCount(s):
    # instantiate a counter object
    count = Counter()
    while (len(s) > 1):
        pair = s[0:2]    # the first two characters
        count[pair] += 1 # count the pair
        s = s[1:]        # remove the first character
    # convert it back to a dict now that we're done counting
    return dict(count)

def mostFrequentPair(s):
    # count the letter pairs
    pairs = pairCount(s)

    # sort the pairs by their counts
    # use the Decorate-Sort-Undecorate idiom
    # to convert the dict into a list
    decorated = [ (pairs[p], p) for p in pairs.keys() ]
    sorted_tuples = sorted(
        decorated,
        # the - before the first element sorts descending
        key=lambda k: (-k[0], k[1])
    )
    sorted_pairs = [ t[1] for t in sorted_tuples ]

    max_pair = []
    # pull off first value from the sorted pairs
    max_pair.append( sorted_pairs.pop(0) )
    # get it's count
    max_count = pairs[ max_pair[0] ]

    while pairs[ sorted_pairs[0] ] == max_count:
        # there are pairs on the sorted list that have the
        # same count, so let's put them on the list, too
        max_pair.append( sorted_pairs.pop(0) )

    # set aside the pair that sorted to the top
    first_pair = max_pair[0]

    # make the count an english word
    count = (
        'once'  if (max_count == 1) else # 🎶
        'twice' if (max_count == 2) else # 🎶
        num2words(max_count) + ' times'  # a lady 🎶
    )

    # and format the explanation
    if len(max_pair) == 1:
        explain = f"'{first_pair}' appears {count} in \$s"
    else:
        # quote all the pairs
        max_pair = [ f"'{x}'" for x in max_pair]
        explain = f"{conjunction(max_pair)} appear {count} in "
        explain += f"$s and '{first_pair}' is "
        explain += "lexicographically smallest."

    return first_pair, explain

3
10
11
22
38
49

sub sixOutOfFourtyNine {
  return (1 .. 49).pick(6).sort;
}

use List::Util qw( shuffle );

sub sixOutOfFourtyNine {
  return sort { $a <=> $b } ( shuffle(1 .. 49) )[0 .. 5];
}

from random import sample

def sixOutOfFourtyNine():
    return sorted(sample(range(1, 49), 6))

a[n] = p * a[n-2] + q * a[n-1] with n > 1

where p and q must be integers.

Input: @a = (1, 1, 2, 3, 5)
Output: true

@a is the initial part of the Fibonacci sequence a[n] = a[n-2] + a[n-1]
with a[0] = 1 and a[1] = 1.

Input: @a = (4, 2, 4, 5, 7)
Output: false

a[1] and a[2] are even. Any linear combination of two even numbers with integer factors is even, too.
Because a[3] is odd, the given numbers cannot form a linear recurrence of second order with integer factors.

Input: @a = (4, 1, 2, -3, 8)
Output: true

a[n] = a[n-2] - 2 * a[n-1]

p = (a[2] * a[2] - a[1] * a[3]) / (a[0] * a[2] - a[1] * a[1])
q = (a[0] * a[3] - a[2] * a[1]) / (a[0] * a[2] - a[1] * a[1])

sub findPandQ(@a) {
  my $p = (@a[2] * @a[2] - @a[1] * @a[3])
        / (@a[0] * @a[2] - @a[1] * @a[1]);
  my $q = (@a[0] * @a[3] - @a[2] * @a[1])
        / (@a[0] * @a[2] - @a[1] * @a[1]);
  return($p, $q);
}

sub isLinearRecurranceOfSecondOrder(@a) {
  my ($p1, $q1) = findPandQ(@a[0 .. 3]);
  my ($p2, $q2) = findPandQ(@a[1 .. 4]);
  if ($p1 != $p2 || $q1 != $q2) {
    say "Values for P ($p1, $p2) and Q ($q1, $q2) "
      ~ "are not consistent across all five elements";
    return False;
  }
  if ($p1 != $p1.Int || $q1 != $q1.Int) {
    say "Values for P ($p1) and Q ($q1) for first "
      ~ "four elements are not integers";
    return False;
  }
  say "Found integer values for P ($p1) and Q ($q1)";
  return True;
}

$ raku/ch-2.raku
Example 1:
Input: @a = (1, 1, 2, 3, 5)
Found integer values for P (1) and Q (1)
Output: True

Example 2:
Input: @a = (4, 2, 4, 5, 7)
Values for P (0.5) and Q (1) for first four elements are not integers
Output: False

Example 3:
Input: @a = (4, 1, 2, -3, 8)
Found integer values for P (1) and Q (-2)
Output: True

sub findPandQ {
  my @a = @_;
  my $p = ($a[2] * $a[2] - $a[1] * $a[3])
        / ($a[0] * $a[2] - $a[1] * $a[1]);
  my $q = ($a[0] * $a[3] - $a[2] * $a[1])
        / ($a[0] * $a[2] - $a[1] * $a[1]);
  return($p, $q);
}

sub isLinearRecurranceOfSecondOrder {
  my @a = @_;
  my ($p1, $q1) = findPandQ(@a[0 .. 3]);
  my ($p2, $q2) = findPandQ(@a[1 .. 4]);
  if ($p1 != $p2 || $q1 != $q2) {
    say "Values for P ($p1, $p2) and Q ($q1, $q2) "
      . "are not consistent across all five elements";
    return 0;
  }
  if ($p1 != int($p1) || $q1 != int($q1)) {
    say "Values for P ($p1) and Q ($q1) for first "
      . "four elements are not integers";
    return 0;
  }
  say "Found integer values for P ($p1) and Q ($q1)";
  return 1;
}

def findPandQ(a):
    p = (
      (a[2] * a[2] - a[1] * a[3])
      /
      (a[0] * a[2] - a[1] * a[1])
    )
    q = (
      (a[0] * a[3] - a[2] * a[1])
      / 
      (a[0] * a[2] - a[1] * a[1])
    )
    return(p, q)


def isLinearRecurranceOfSecondOrder(a):
    (p1, q1) = findPandQ(a[0:4])
    (p2, q2) = findPandQ(a[1:5])
    if p1 != p2 or q1 != q2:
        print(f'Values for P ({p1}, {p2}) ', end='')
        print(f'and Q ({q1}, {q2}) ', end='')
        print(f'are not consistent across all five elements')
        return False
    if p1 != int(p1) or q1 != int(q1):
        print(f'Values for P ({p1}) ', end='')
        print(f'and Q ({q1}) ', end='')
        print(f'for first four elements are not integers')
        return False

    print(f'Found integer values for P ({int(p1)}) ', end='')
    print(f'and Q ({int(q1)})')
    return True