sub doubleExist(@ints) {
  for 0 .. @ints.end -> $i {
    next unless @ints[$i] %% 2;
    for 0 .. @ints.end -> $j {
      next if $j == $i;
      next if @ints[$j] * 2 != @ints[$i];
      return 'true',
        "For \$i = $i, \$j = $j\n" ~
        "\$ints[\$i] = @ints[$i] => 2 * @ints[$j] => " ~
        "2 * \$ints[\$j]";
    }
  }
  return 'false';
}

sub doubleExist(@ints) {
  foreach my $i ( 0 .. $#ints ) {
    next unless $ints[$i] % 2 == 0;
    foreach my $j ( 0 .. $#ints ) {
      next if $j == $i;
      next if $ints[$j] * 2 != $ints[$i];
      return 'true',
        "For \$i = $i, \$j = $j\n" .
        "\$ints[\$i] = $ints[$i] => 2 * $ints[$j] => " .
        "2 * \$ints[\$j]";
    }
  }
  return 'false';
}

def doubleExist(ints):
  for i in range(len(ints)):
    if ints[i] % 2 != 0:
      continue
    for j in range(len(ints)):
      if j == i:
        continue
      if ints[j] * 2 != ints[i]:
        continue
      explain = (
        f"For $i = {i}, $j = {j}\n" +
        f"$ints[$i] = {ints[i]} => 2 * {ints[j]} => " +
        "2 * $ints[$j]"
      )
      return 'true', explain
  return 'false', False

  require Integer # so we can use is_odd/1 as function

  def doubleExist(ints) do
    iLoop(ints, 0)
  end

  def iLoop(ints, i) when i >= length(ints), do: {false, false}
  def iLoop(ints, i) do
    iVal = Enum.at(ints, i)
    # we can't use Enum functions in a guard,
    # so we need this test here
    {answer, explain} = if Integer.is_odd(iVal) do
      {false, false}
    else
      # start the j loop
      jLoop(ints, i, 0)
    end
    if answer do
      # found an answer, return it
      {answer, explain}
    else
      # go to the next possible i value
      iLoop(ints, i + 1)
    end
  end

  def jLoop(ints, _, j) when j >= length(ints), do: {false, false}
  # skip when i == j
  def jLoop(ints, i, j) when i == j, do: jLoop(ints, i, j + 1)
  def jLoop(ints, i, j) do
    iVal = Enum.at(ints, i)
    jVal = Enum.at(ints, j)
    if jVal * 2 == iVal do
      # we found an answer!
      {
        true,
        "For $i = #{i}, $j = #{j}\n" <>
        "$ints[$i] = #{iVal} => 2 * #{jVal} => " <>
        "2 * $ints[$j]"
      }
    else
      # go to the next possible j value
      jLoop(ints, i, j + 1)
    end
  end

sub luhnCheck($num) {
  # just the numeric digits of the number
  my @digits = $num.comb.grep( /\d/ );
  # the last digit is the payload/checksum
  my $payload = @digits.pop;

  my $to_be_summed;
  my $multiplier = 2; # we'll alternate between 2 & 1

  # pull the last digit off the number
  for @digits.reverse -> $digit {
    $to_be_summed ~= $digit.Int * $multiplier;
    # alternate the multiplier
    $multiplier = ($multiplier == 2) ?? 1 !! 2;
  }
  # add up the digits
  my $sum = [+] $to_be_summed.comb;
  # add the payload back in
  $sum += $payload;
  # is it a multiple of 10
  return $sum %% 10;
}

use List::AllUtils qw( sum );

sub luhnCheck($num) {
  # just the numeric digits of the number
  my @digits = grep { /\d/ } split //, $num;
  # the last digit is the payload/checksum
  my $payload = pop @digits;

  my $to_be_summed;
  my $multiplier = 2; # we'll alternate between 2 & 1
  
  # pull the last digit off the number
  foreach my $digit (reverse @digits) {
    $to_be_summed .= $digit * $multiplier;
    # alternate the multiplier
    $multiplier = ($multiplier == 2) ? 1 : 2;
  }
  # add up the digits
  my $sum = sum(split //, $to_be_summed);
  # add the payload back in
  $sum += $payload;
  # is it a multiple of 10
  return $sum % 10 == 0 ? 'true' : 'false';
}

def luhnCheck(num):
  # just the numeric digits of the number
  digits = [ d for d in num if d.isnumeric() ]
  # the last digit is the payload/checksum
  payload = digits.pop()

  to_be_summed = ''
  multiplier = 2 # we'll alternate between 2 & 1

  digits.reverse() # reverse the digits
  # pull the last digit off the number
  for digit in digits:
    to_be_summed += str(int(digit) * multiplier)
    # alternate the multiplier
    multiplier = 1 if multiplier == 2 else 2

  # add up the digits
  digitSum = sum([ int(d) for d in to_be_summed ])
  # add the payload back in
  digitSum += int(payload)
  # is it a multiple of 10
  return digitSum % 10 == 0

  def sumDigits(num) do
    {_, data} = num
    |> Integer.to_string # turn number into string
    |> String.codepoints # break into chars
    |> Enum.map(fn d -> String.to_integer(d) end) # convert to int
    |> Enum.map_reduce(%{ sum: 0 }, fn digit, data ->
      { digit, Map.put(data, :sum, digit + data[:sum])}
    end)
    data[:sum]
  end

  def luhnCheck?(num) do
    digits = num
    |> String.codepoints # break into chars
    |> Enum.filter(fn d -> Regex.match?(~r/\d/, d) end) # just numeric
    |> Enum.map(fn d -> String.to_integer(d) end) # convert to int
    |> Enum.reverse # reverse the digits

    data = %{
      multiplier: 1, # we'll alternate between 2 & 1
      sum: 0 # let's add the numbers as we process them
    }
    alternate = [0, 2, 1] # trick for alternating between 2 & 1
    {_, data} =
      Enum.map_reduce(digits, data, fn digit, data ->
        multiplier = data[:multiplier]
        product = digit * multiplier
        data = data
        |> Map.put(:multiplier, Enum.at(alternate, multiplier)) # alternate the multiplier
        |> Map.put(:sum, data[:sum] + sumDigits(product))
        { product, data }
      end)
    Kernel.rem(data[:sum], 10) == 0
  end