sub luckyInteger(@ints) {
  my @lucky =
    @ints.Bag                      # count occurrences
         .pairs                    # get key/value pairs
         .grep({ .value == .key }) # keys that match freq
         .map({ .key })            # return just the keys
         .sort({ .Int });          # sort by integer value
  return -1 if @lucky == 0; # return -1 if no lucky int was found
  return @lucky[*-1]; # return the largest lucky int
}

sub luckyInteger(@ints) {
  # thanks to Niels van Dijke (https://github.com/PerlBoy1967)
  # for putting postfix "for" back in my brain!
  my %bag; $bag{$_}++ for @ints; # count occurrences

  my @lucky;
  foreach my($k, $v) (%bag) { # get key/value pairs
    next unless $k == $v; # skip keys that don't match freq
    push @lucky, $k;
  }

  return -1 if @lucky == 0; # return -1 if no lucky int was found
  return (sort @lucky)[-1]; # return the largest lucky int
}

from collections import Counter

def luckyInteger(ints):
  bag = Counter(ints)  # count occurrences
  keys = [
    k                      # return just the keys
    for k,v in bag.items() # get key/value pairs
    if v == k              # keys that match freq
  ]

  if len(keys) == 0:
    return -1  # return -1 if no lucky int was found

  return sorted(keys).pop(-1) # return the largest lucky int

defmodule Bag do
  @moduledoc """
  Generates a Multiset/Bag implemented as a Map.

  https://en.wikipedia.org/wiki/Multiset
  """
  @moduledoc since: "1.0.0"

  @doc """
  Generates a Bag from an enum.
  """
  def from_enum(enum) do
    {_, bag} = Enum.map_reduce(enum, %{}, fn i, bag ->
      { i, Map.put(bag, i, Map.get(bag, i, 0) + 1) }
    end)
    bag
  end
end

  def luckyInteger(ints) do
    bag = Bag.from_enum(ints)
    # filter for keys that match their frequency
    keys = Enum.filter(Map.keys(bag), fn k -> k == Map.get(bag, k) end)
    if length(keys) == 0 do
      -1 # return -1 if no lucky int was found
    else
      # return the largest lucky int
      keys |> Enum.sort |> List.last
    end
  end

sub relativeSort(@list1, @list2) {
  my %bag1 = @list1.BagHash; # because we want to remove elements
  my %bag2 = @list2.Bag;

  # condition checking
  return '@list2 is not distinct'
    unless %bag2.values.all == 1;

  # build the sorted array
  my @sorted;
  for @list2 -> $l2 {
    return "$l2 ∈ \@list2 but $l2 ∉ \@list1"
      if %bag1{$l2}:!exists;

    # put the appropriate number into the list
    @sorted.push(Slip($l2 xx %bag1{$l2}));

    # remove $l2 from what's remaining in @list1
    %bag1{$l2}:delete;
  }

  # push the remaining numbers from @list1 that
  # weren't in @list2 into the output
  for %bag1.keys.sort -> $l1 {
    @sorted.push(Slip($l1 xx %bag1{$l1}));
  }

  return '(' ~ @sorted.join(', ') ~ ')';
} 

use List::MoreUtils qw( all );

sub relativeSort($list1, $list2) {
  # thanks to Niels van Dijke (https://github.com/PerlBoy1967)
  # for putting postfix "for" back in my brain!
  my %bag1; $bag1{$_}++ for @$list1;
  my %bag2; $bag2{$_}++ for @$list2;

  # condition checking
  return '@list2 is not distinct'
    unless all {$_ == 1} values %bag2;

  # build the sorted array
  my @sorted;
  foreach my $l2 (@$list2) {
    return "$l2 ∈ \@list2 but $l2 ∉ \@list1"
      if ! exists $bag1{$l2};

    # put the appropriate number into the list
    push @sorted, $_ for ($l2) x $bag1{$l2};

    # remove $l2 from what's remaining in @list1
    delete $bag1{$l2};
  }

  # push the remaining numbers from @list1 that
  # weren't in @list2 into the output
  foreach my $l1 (sort keys %bag1) {
    push @sorted, $_ for ($l1) x $bag1{$l1};
  }

  return '(' . join(', ', @sorted) . ')';
}

from collections import Counter

def comma_join(arr):
  return ', '.join(map(lambda i: str(i), arr))

def relativeSort(list1, list2):
  bag1 = Counter(list1)
  bag2 = Counter(list2)

  # condition checking
  if len([ k for k,v in bag2.items() if v != 1 ]):
    return '@list2 is not distinct'

  # build the sorted_list array
  sorted_list = []
  for l2 in list2:
    if l2 not in list1:
      return f"{l2} ∈ @list2 but {l2} ∉ @list1"

    # put the appropriate number into the list; if we
    # use .append, sorted_list will be a list of lists
    sorted_list.extend([ l2 for n in range(bag1[l2]) ])

    # remove l2 from what's remaining in list1
    bag1.pop(l2)

  # push the remaining numbers from list1 that
  # weren't in list2 into the output
  for l1 in sorted(bag1.keys()):
    sorted_list.extend([ l1 for n in range(bag1[l1]) ])

  return '(' + comma_join(sorted_list) + ')'

  @doc """
  Helper function to append the element "num"
  to a list "count" times.
  """
  def addToList(list, num, count) do
    {_, list} = Enum.map_reduce(
      1 .. count,
      list,
      fn n, acc -> {n, acc ++ [num]} end
    )
    list
  end

  # when we have exhausted list2, put the remaining elements
  # from list1 into the sorted list in numerical order
  def relativeSort([], bag1, sorted) do
    {_, sorted} = Enum.map_reduce(
      Enum.sort(Map.keys(bag1)),
      sorted,
      fn k, sorted ->
        { k, addToList(sorted, k, Map.get(bag1, k))}
      end
    )
    "(" <> Enum.join(sorted, ", ") <> ")"
  end

  # process list2 element by element, adding elements to
  # the sorted list as many times as they occur in list1
  def relativeSort([next | rest], bag1, sorted) do
    count = Map.get(bag1, next)
    relativeSort(
      rest,
      Map.delete(bag1, next),
      addToList(sorted, next, count)
    )
  end

  # process the two lists, check error conditions, then
  # recursively call relativeSort/3 to build the sorted output
  def relativeSort(list1, list2) do
    bag1 = Bag.from_enum(list1)
    bag2 = Bag.from_enum(list2)

    cond do
      Enum.any?(Map.values(bag2), fn x -> x != 1 end) ->
        "@list2 is not distinct"
      Enum.any?(Map.keys(bag2), fn k -> !Map.has_key?(bag1, k) end) ->
        "At least one element in @list2 is not in @list1"
      true ->
        relativeSort(list2, bag1, [])
    end
  end