sub thirdMaximum(@ints) {
  my %distinct = @ints.Bag; # get distinct integers
  if (%distinct.elems < 3) {
    # not enough values for a third max, return max
    return %distinct.keys.max();
  }
  # sort and then get the third from the end
  return( (%distinct.keys.sort)[*-3] );
}

use List::AllUtils qw( max );

sub thirdMaximum(@ints) {
  my %distinct; $distinct{$_}=1 for @ints; # get distinct integers
  if ((keys %distinct) < 3) {
    # not enough values for a third max, return max
    return max(keys %distinct);
  }
  # sort and then get the third from the end
  return( (sort keys %distinct)[-3] );
}

from collections import Counter

def thirdMaximum(ints):
  distinct = Counter(ints) # get distinct integers
  if len(list(distinct)) < 3:
    # not enough values for a third max, return max
    return max(list(distinct))
  # sort and then get the third from the end
  return sorted(list(distinct))[-3]

  def thirdMaximum(ints) do
    distinct = Bag.from_enum(ints) # get distinct integers
    if (length(Map.keys(distinct)) < 3) do
      # not enough values for a third max, return max
      Enum.max(Map.keys(distinct))
    else
      # sort and then get the third from the end
      Map.keys(distinct)
      |> Enum.sort(:desc)
      |> Enum.at(2)
    end
  end

sub rearrange($word is copy) {
  return $word unless $word.chars > 2;
  my @chars = $word.comb; # break word into characters
  my @letters = @chars.grep(/ <:L> /); # only letters
  my $first = @letters.shift; # remove the first letter
  my $last  = @letters.pop;   # remove the last letter
  @letters .= pick(*);        # shuffle the remaining letters
  @letters.unshift($first);   # put the first letter back
  @letters.push($last);       # put the last letter back

  # reassemble the word
  $word = '';
  # loop over the char list
  for 0 .. @chars.end -> $i {
    if ( @chars[$i] ~~ / <:L> / ) {
      # if it's a letter, pull it's replacement
      # off the @letters array
      $word ~= @letters.shift;
    }
    else {
      # otherwise, it's punctuation, so
      # leave it alone
      $word ~= @chars[$i];
    }
  }

  return $word;
}

sub jumbleLetters($text) {
  my @words = $text.comb(/\S+/);
  for @words <-> $word {
    $word = rearrange($word);
  }
  return @words.join(" ");
} 

use List::AllUtils qw( shuffle );
use Text::Wrap;

sub rearrange($word) {
  return $word unless length($word) > 2;
  my @chars = split //, $word; # break word into characters
  my @letters = grep {/\p{L}/} @chars; # only letters
  my $first = shift @letters; # remove the first letter
  my $last  = pop @letters;   # remove the last letter
  @letters = shuffle @letters; # shuffle the remaining letters
  unshift @letters, $first;   # put the first letter back
  push @letters, $last;       # put the last letter back

  # reassemble the word
  $word = '';
  # loop over the char list
  foreach my $i (0 .. $#chars) {
    if ( $chars[$i] =~ /\p{L}/ ) {
      # if it's a letter, pull it's replacement
      # off the @letters array
      $word .= shift @letters;
    }
    else {
      # otherwise, it's punctuation, so
      # leave it alone
      $word .= $chars[$i];
    }
  }

  return $word;
}

sub jumbleLetters($text) {
  my @words = split /\s+/, $text;
  foreach my $word (@words) {
    $word = rearrange($word);
  }
  return join(" ", @words);
}

from textwrap import fill
from random   import shuffle
from regex    import match

def rearrange(word):
  if len(word) < 3:
    return word

  chars = [ c for c in word ] # break word into characters
  letters = list(filter(lambda c: match(r"\p{L}", c), chars)) # only letters
  first = letters.pop(0);  # remove the first letter
  last  = letters.pop(-1); # remove the last letter
  shuffle(letters)         # shuffle the remaining letters
  letters.insert(0, first) # put the first letter back
  letters.append(last)     # put the last letter back

  # reassemble the word
  word = ''
  # loop over the char list
  for i in range(len(chars)):
    if match(r"\p{L}", chars[i]):
      # if it's a letter, pull it's replacement
      # off the @letters array
      word += letters.pop(0)
    else:
      # otherwise, it's punctuation, so
      # leave it alone
      word += chars[i]

  return word

def jumbleLetters(text):
  words = text.split()
  words[:] = [ rearrange(word) for word in words ]
  return " ".join(words)

  def reassemble([], _, word), do: word

  def reassemble(, letters, word) do
    cond do
      Regex.match?(~r/\p{L}/u, c) ->
        # if it's a letter, pull it's replacement
        # off the letters array
        {next, letters} = List.pop_at(letters, 0)
        reassemble(remaining, letters, word <> next)
      true ->
        # otherwise, it's punctuation, so
        # leave it alone
        reassemble(remaining, letters, word <> c)
    end
  end

  def rearrange(word) when length(word) < 3, do: word

  def rearrange(word) do
    chars = String.codepoints(word) # break word into characters
    letters = Enum.filter(
      chars,
      fn c -> Regex.match?(~r/\p{L}/u, c) end # only letters
    )
    {first, letters} = List.pop_at(letters, 0) # remove the first letter
    {last, letters}  = List.pop_at(letters,-1) # remove the last letter
    letters = Enum.shuffle(letters) # shuffle the remaining letters
    |> List.insert_at(0, first)     # put the first letter back
    |> List.insert_at(-1, last)     # put the last letter back

    # reassemble the word
    reassemble(chars, letters, "")
  end

  def jumbleLetters(text) do
    String.split(text)
    |> Enum.map(fn word -> rearrange(word) end)
    |> Enum.join(" ")
  end