sub strongPassword($str) {
  my ($hasUpper, $hasLower, $hasDigit, @runs) = (0, 0, 0);

  for $str.comb -> $char {
    # identify runs of characters
    if (@runs == 0 || @runs[*-1].substr(*-1,1) ne $char) {
      # we have no previous run of characters, or the last
      # character of the last run doesn't match this character
      @runs.push($char);
    }
    else {
      # append the latest character to the run
      @runs[*-1] ~= $char;
    }

    # count the character classes we're interested in
    if    ($char ~~ / <:Lu> /) { $hasUpper++ }
    elsif ($char ~~ / <:Ll> /) { $hasLower++ }
    elsif ($char ~~ / <:N> /)  { $hasDigit++ }
  }

  # count how many characters need to be REPLACED
  my $replacements = 0;
  for @runs -> $run {
    # the run isn't 3 or more characters
    next unless $run.chars >= 3;
    # we need one replacement per multiple of 3
    $replacements += ($run.chars / 3).Int;
  }

  # figure out how many changes are needed
  my $changes = 0;
  my $length  = $str.chars;

  for [$hasUpper, $hasLower, $hasDigit] -> $has {
    if ($has == 0) {
      $changes++; # we need to add a character of this type

      # if we have characters that need to be REPLACED, we don't
      # need to add to the string length to make the change
      if ($replacements > 0) {
        $replacements--;
      }
      else {
        # we need to add characters to make the change
        $length++;
      }
    }
  }
  if ($length < 6) {
    # not enough characters, we need MORE!
    $changes += 6 - $length;
  }
  if ($replacements > 0) {
    # if we need more replacements, add them to the total
    $changes += $replacements;
  }

  return $changes;
}

use utf8;
binmode STDOUT, ':utf8';

sub strongPassword($str) {
  my ($hasUpper, $hasLower, $hasDigit, @runs) = (0, 0, 0);

  foreach my $char ( split //, $str ) {
    # identify runs of characters
    if (@runs == 0 || substr($runs[-1],-1,1) ne $char) {
      # we have no previous run of characters, or the last
      # character of the last run doesn't match this character
      push @runs, $char;
    }
    else {
      # append the latest character to the run
      $runs[-1] .= $char;
    }

    # count the character classes we're interested in
    if    ($char =~ /\p{Lu}/) { $hasUpper++ }
    elsif ($char =~ /\p{Ll}/) { $hasLower++ }
    elsif ($char =~ /\p{N}/)  { $hasDigit++ }
  }

  # count how many characters need to be REPLACED
  my $replacements = 0;
  foreach my $run ( @runs ) {
    # the run isn't 3 or more characters
    next unless length($run) >= 3;
    # we need one replacement per multiple of 3
    $replacements += int(length($run) / 3);
  }

  # figure out how many changes are needed
  my $changes = 0;
  my $length  = length($str);

  foreach my $has ($hasUpper, $hasLower, $hasDigit) {
    if ($has == 0) {
      $changes++; # we need to add a character of this type

      # if we have characters that need to be REPLACED, we don't
      # need to add to the string length to make the change
      if ($replacements > 0) {
        $replacements--;
      }
      else {
        # we need to add characters to make the change
        $length++;
      }
    }
  }
  if ($length < 6) {
    # not enough characters, we need MORE!
    $changes += 6 - $length;
  }
  if ($replacements > 0) {
    # if we need more replacements, add them to the total
    $changes += $replacements;
  }

  return $changes;
}

import regex

def strongPassword(str):
  hasUpper = 0
  hasLower = 0
  hasDigit = 0
  runs = []

  for char in str:
    # identify runs of characters
    if len(runs) == 0 or runs[-1][-1] != char:
      # we have no previous run of characters, or the last
      # character of the last run doesn't match this character
      runs.append(char)
    else:
      # append the latest character to the run
      runs[-1] += char

    # count the character classes we're interested in
    if   regex.match(r"\p{Lu}", char):
      hasUpper += 1
    elif regex.match(r"\p{Ll}", char):
      hasLower += 1
    elif regex.match(r"\p{N}", char):
      hasDigit += 1

  # count how many characters need to be REPLACED
  replacements = 0
  for run in runs:
    # if the run is 3 or more characters
    if len(run) >= 3:
      # we need one replacement per multiple of 3
      replacements += int(len(run) / 3)

  # figure out how many changes are needed
  changes = 0
  length  = len(str)

  for has in [hasUpper, hasLower, hasDigit]:
    if has == 0:
      changes += 1 # we need to add a character of this type

      # if we have characters that need to be REPLACED, we don't
      # need to add to the string length to make the change
      if replacements > 0:
        replacements -= 1
      else:
        # we need to add characters to make the change
        length += 1

  if length < 6:
    # not enough characters, we need MORE!
    changes += 6 - length

  if replacements > 0:
    # if we need more replacements, add them to the total
    changes += replacements

  return changes

  defp countHas(has, data) when has != 0, do: data

  defp countHas(_, data) do
    # we need to add a character of this type
    data = Map.put(data, :changes, data[:changes]+1)

    if data[:replacements] > 0 do
      # if we have characters that need to be REPLACED,
      # we don't need to add to the string length to
      # make the change
      Map.put(data, :replacements, data[:replacements]-1)
    else
      # we need to add characters to make the change
      Map.put(data, :length, data[:length]+1)
    end
  end

  defp putIf(map, condition, _, _) when not condition,
  do: map

  defp putIf(map, _, key, value) do
    Map.put(map, key, value)
  end

  def strongPassword(str) do
    data = %{
      hasUpper: 0,
      hasLower: 0,
      hasDigit: 0,
      runs: []
    }

    chars = String.graphemes(str)

    {_, data} =
      Enum.map_reduce(chars, data, fn char, data ->
        # identify runs of characters
        runs = data[:runs]
        runs = cond do
          # we have no previous run of characters, or the last
          # character of the last run doesn't match this character
          length(runs) == 0
          or
          List.last(runs) |> String.last != char ->
            runs ++ [ char ]

          # append the latest character to the run
          true ->
            List.replace_at(runs, -1, List.last(runs) <> char)
        end

        # put the runs back in the data map
        data = Map.put(data, :runs, runs)

        # count the character classes we're interested in
        # and return the data map to Enum.map_reduce/3
        {
          char,
          cond do
            Regex.match?(~r/\p{Lu}/u, char) ->
              Map.put(data, :hasUpper, data[:hasUpper]+1)
            Regex.match?(~r/\p{Ll}/u, char) ->
              Map.put(data, :hasLower, data[:hasLower]+1)
            Regex.match?(~r/\p{N}/u, char) ->
              Map.put(data, :hasDigit, data[:hasDigit]+1)
          end
        }
      end)

    # count how many characters need to be REPLACED
    {_, replacements} =
      Enum.map_reduce(data[:runs], 0, fn run, replacements ->
        {
          run,
          if String.length(run) >= 3 do
            replacements + trunc(String.length(run) / 3)
          else
            replacements
          end
        }
      end)

    # store some more stuff in our data map
    data = data
    |> Map.put(:changes, 0)
    |> Map.put(:length, String.length(str))
    |> Map.put(:replacements, replacements)

    hasList = [
      data[:hasUpper], data[:hasLower], data[:hasDigit]
    ]

    # figure out how many changes are needed
    {_, data} =
      Enum.map_reduce(hasList, data, fn has, data ->
        { has, countHas(has, data) }
      end)

    data
    |> putIf(data[:length] < 6, :changes,
             data[:changes] + 6 - data[:length] )
    |> putIf(data[:replacements] > 0, :changes,
             data[:changes] + data[:replacements])
    |> Map.get(:changes)
  end

grammar IsNumber {
  rule TOP { [
    <integerNumber><exponent>? | <decimalNumber><exponent>?
  ] }

  token sign { <[ + \- ]> }

  token digits { \d+ }

  token integerNumber { <sign>? <digits> }

  token decimalNumber {
    <sign>? [ <digits> '.' | <digits> '.' <digits> | '.' <digits> ]
  }

  token exponent { [ "e" | "E" ] <integerNumber> }
}

sub solution($str) {
  say qq{Input: \$str = "$str"};
  say 'Output: ' ~ (IsNumber.parse($str) ?? True !! False);
}

use utf8;
binmode STDOUT, ':utf8';

my $sign = qr/ [+\-] /x;

my $digits = qr/ \d+ /x;

my $integerNumber = qr/ $sign? $digits /x;

my $decimalNumber = qr/
  $sign? (?: $digits\. | $digits\.$digits | \.$digits)
/x;

my $exponent = qr/(?: [eE] $integerNumber )/x;

my $TOP = qr/
  ^ (?: $integerNumber$exponent? | $decimalNumber$exponent? ) $
/x;

sub solution($str) {
  say qq{Input: \$str = "$str"};
  say 'Output: ' . ($str =~ /$TOP/ ? 'True' : 'False');
}

import re

sign = r'[+\-]'

digits = r'\d+'

integerNumber = fr' {sign}? {digits} '

decimalNumber = fr"""
  {sign}? (?: {digits}\. | {digits}\.{digits} | \.{digits} )
"""

exponent = fr'(?:[eE]{integerNumber})'

TOP = re.compile(fr"""
  ^ (?:
      {integerNumber}{exponent}? |
      {decimalNumber}{exponent}?
    ) $
  """,
  re.VERBOSE
)

def solution(str):
    print(f'Input: $str = "{str}"')
    match = True if re.search(TOP, str) else False
    print(f'Output: {match}')

  def top() do
    ~r/
      ^
        (?:
          [+-]? \p{N}+ (?: [eE] (?: [+-]? \p{N}+ ) )?
          |
          [+-]? (?: \p{N}+ \. | \p{N}+ \. \p{N}+ | \. \p{N}+ )
          (?: [eE] (?: [+-]? \p{N}+ ) )?
        )
      $
    /ux
  end

  def solution(str) do
    IO.puts("Input: $str = \"#{str}\"")
    IO.puts("Output: #{ String.match?(str, top()) }")
  end