Merge branch 'master' of https://github.com/manwar/perlweeklychallenge-club

7 files changed, 406 insertions, 2 deletions

diff --git a/challenge-284/0rir/raku/ch-2.raku b/challenge-284/0rir/raku/ch-2.raku
index 5b4be54966..4de0440bd7 100644
--- a/challenge-284/0rir/raku/ch-2.raku
+++ b/challenge-284/0rir/raku/ch-2.raku
@@ -1,8 +1,6 @@
 #!/usr/bin/env raku
 # :vim ft=raku sw=4 expandtab  # 🦋 ∅∪∩∋∈∉⊆ ≡ ≢ «␤ » ∴
 use v6.d;
-INIT $*RAT-OVERFLOW = FatRat;
-use lib $?FILE.IO.cleanup.parent(2).add("lib");
 use Test;
 
 =begin comment
diff --git a/challenge-284/lubos-kolouch/perl/ch-1.pl b/challenge-284/lubos-kolouch/perl/ch-1.pl
new file mode 100644
index 0000000000..17a5769fe9
--- /dev/null
+++ b/challenge-284/lubos-kolouch/perl/ch-1.pl
@@ -0,0 +1,59 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 3;
+
+=pod
+
+=head1 DESCRIPTION
+
+This script finds the lucky integer in a given array of integers.
+
+A lucky integer is defined as an integer whose frequency in the array is equal to its value.
+
+If there are multiple lucky integers, the largest one is returned. If no lucky integers are found, -1 is returned.
+
+=head1 FUNCTIONS
+
+=head2 find_lucky_integer(\@ints)
+
+Given an array reference of integers, returns the lucky integer as per the problem definition.
+
+=over 4
+
+=item * C<\@ints> - Reference to an array of integers.
+
+=back
+
+Returns the lucky integer if found, otherwise -1.
+
+=cut
+
+sub find_lucky_integer {
+    my ($ints_ref) = @_;
+    my %freq;
+
+    foreach my $num (@$ints_ref) {
+        $freq{$num}++;
+    }
+
+    my @lucky_integers;
+    foreach my $num (keys %freq) {
+        if ($num == $freq{$num}) {
+            push @lucky_integers, $num;
+        }
+    }
+
+    if (@lucky_integers) {
+        return (sort { $b <=> $a } @lucky_integers)[0];
+    } else {
+        return -1;
+    }
+}
+
+# Unit Tests
+is(find_lucky_integer([2, 2, 3, 4]), 2, 'Example 1');
+is(find_lucky_integer([1, 2, 2, 3, 3, 3]), 3, 'Example 2');
+is(find_lucky_integer([1, 1, 1, 3]), -1, 'Example 3');
+
+done_testing();
diff --git a/challenge-284/lubos-kolouch/perl/ch-2.pl b/challenge-284/lubos-kolouch/perl/ch-2.pl
new file mode 100644
index 0000000000..2579cd474e
--- /dev/null
+++ b/challenge-284/lubos-kolouch/perl/ch-2.pl
@@ -0,0 +1,88 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 3;
+
+=pod
+
+=head1 DESCRIPTION
+
+This script sorts the elements of @list1 based on the relative order defined in @list2. Elements in @list1 that are not in @list2 are placed at the end in ascending order.
+
+=head1 FUNCTIONS
+
+=head2 relative_sort(\@list1, \@list2)
+
+Sorts @list1 based on the order of elements in @list2.
+
+=over 4
+
+=item * C<\@list1> - Reference to the first list of integers.
+
+=item * C<\@list2> - Reference to the second list of integers defining the relative order.
+
+=back
+
+Returns a sorted array.
+
+=cut
+
+sub relative_sort {
+    my ($list1_ref, $list2_ref) = @_;
+    my %order;
+    my @result;
+
+    # Assign order to elements in @list2
+    my $idx = 0;
+    foreach my $num (@$list2_ref) {
+        $order{$num} = $idx++;
+    }
+
+    # Separate elements that are in @list2 and not in @list2
+    my @in_list2;
+    my @not_in_list2;
+
+    foreach my $num (@$list1_ref) {
+        if (exists $order{$num}) {
+            push @in_list2, $num;
+        } else {
+            push @not_in_list2, $num;
+        }
+    }
+
+    # Sort elements in @list1 that are in @list2 based on the order in @list2
+    @in_list2 = sort {
+        $order{$a} <=> $order{$b}
+            ||
+        $a <=> $b  # To handle duplicates
+    } @in_list2;
+
+    # Sort elements not in @list2 in ascending order
+    @not_in_list2 = sort { $a <=> $b } @not_in_list2;
+
+    # Combine the two lists
+    @result = (@in_list2, @not_in_list2);
+
+    return @result;
+}
+
+# Unit Tests
+is_deeply(
+    [relative_sort([2, 3, 9, 3, 1, 4, 6, 7, 2, 8, 5], [2, 1, 4, 3, 5, 6])],
+    [2, 2, 1, 4, 3, 3, 5, 6, 7, 8, 9],
+    'Example 1'
+);
+
+is_deeply(
+    [relative_sort([3, 3, 4, 6, 2, 4, 2, 1, 3], [1, 3, 2])],
+    [1, 3, 3, 3, 2, 2, 4, 4, 6],
+    'Example 2'
+);
+
+is_deeply(
+    [relative_sort([3, 0, 5, 0, 2, 1, 4, 1, 1], [1, 0, 3, 2])],
+    [1, 1, 1, 0, 0, 3, 2, 4, 5],
+    'Example 3'
+);
+
+done_testing();
diff --git a/challenge-284/lubos-kolouch/python/ch-1.py b/challenge-284/lubos-kolouch/python/ch-1.py
new file mode 100644
index 0000000000..2f817578f1
--- /dev/null
+++ b/challenge-284/lubos-kolouch/python/ch-1.py
@@ -0,0 +1,51 @@
+from typing import List
+import unittest
+
+
+def find_lucky_integer(ints: List[int]) -> int:
+    """
+    Finds the lucky integer in the given list of integers.
+
+    A lucky integer is an integer whose frequency in the array is equal to its value.
+
+    If there are multiple lucky integers, returns the largest one.
+    If no lucky integers are found, returns -1.
+
+    Args:
+        ints (List[int]): A list of integers.
+
+    Returns:
+        int: The lucky integer if found, otherwise -1.
+    """
+    from collections import Counter
+    freq = Counter(ints)
+    lucky_integers = [num for num, count in freq.items() if num == count]
+    if lucky_integers:
+        return max(lucky_integers)
+    else:
+        return -1
+
+
+# Unit Tests
+class TestFindLuckyInteger(unittest.TestCase):
+
+    def test_example1(self):
+        self.assertEqual(find_lucky_integer([2, 2, 3, 4]), 2, 'Example 1')
+
+    def test_example2(self):
+        self.assertEqual(find_lucky_integer([1, 2, 2, 3, 3, 3]), 3,
+                         'Example 2')
+
+    def test_example3(self):
+        self.assertEqual(find_lucky_integer([1, 1, 1, 3]), -1, 'Example 3')
+
+    def test_additional(self):
+        self.assertEqual(find_lucky_integer([5, 5, 5, 5, 5]), 5,
+                         'All same number')
+        self.assertEqual(find_lucky_integer([2, 2, 2, 3, 3]), -1,
+                         'No lucky integer')
+        self.assertEqual(find_lucky_integer([]), -1, 'Empty list')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/challenge-284/lubos-kolouch/python/ch-2.py b/challenge-284/lubos-kolouch/python/ch-2.py
new file mode 100644
index 0000000000..c0fb8a888b
--- /dev/null
+++ b/challenge-284/lubos-kolouch/python/ch-2.py
@@ -0,0 +1,66 @@
+from typing import List
+import unittest
+
+
+def relative_sort(list1: List[int], list2: List[int]) -> List[int]:
+    """
+    Sorts the elements of list1 based on the relative order defined in list2.
+    Elements not in list2 are placed at the end in ascending order.
+
+    Args:
+        list1 (List[int]): The list of integers to sort.
+        list2 (List[int]): The list defining the relative order.
+
+    Returns:
+        List[int]: The sorted list.
+    """
+    order = {num: idx for idx, num in enumerate(list2)}
+    in_list2 = []
+    not_in_list2 = []
+
+    for num in list1:
+        if num in order:
+            in_list2.append(num)
+        else:
+            not_in_list2.append(num)
+
+    # Sort elements in list1 that are in list2 based on the order in list2
+    in_list2.sort(key=lambda x: (order[x], x))
+
+    # Sort elements not in list2 in ascending order
+    not_in_list2.sort()
+
+    return in_list2 + not_in_list2
+
+
+# Unit Tests
+class TestRelativeSort(unittest.TestCase):
+
+    def test_example1(self):
+        list1 = [2, 3, 9, 3, 1, 4, 6, 7, 2, 8, 5]
+        list2 = [2, 1, 4, 3, 5, 6]
+        expected = [2, 2, 1, 4, 3, 3, 5, 6, 7, 8, 9]
+        self.assertEqual(relative_sort(list1, list2), expected, 'Example 1')
+
+    def test_example2(self):
+        list1 = [3, 3, 4, 6, 2, 4, 2, 1, 3]
+        list2 = [1, 3, 2]
+        expected = [1, 3, 3, 3, 2, 2, 4, 4, 6]
+        self.assertEqual(relative_sort(list1, list2), expected, 'Example 2')
+
+    def test_example3(self):
+        list1 = [3, 0, 5, 0, 2, 1, 4, 1, 1]
+        list2 = [1, 0, 3, 2]
+        expected = [1, 1, 1, 0, 0, 3, 2, 4, 5]
+        self.assertEqual(relative_sort(list1, list2), expected, 'Example 3')
+
+    def test_additional(self):
+        list1 = [7, 5, 9, 4, 8, 6]
+        list2 = [5, 7, 6]
+        expected = [5, 7, 6, 4, 8, 9]
+        self.assertEqual(relative_sort(list1, list2), expected,
+                         'Additional Test')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/challenge-284/santiago-leyva/perl/ch-1.pl b/challenge-284/santiago-leyva/perl/ch-1.pl
new file mode 100644
index 0000000000..27060bf1a2
--- /dev/null
+++ b/challenge-284/santiago-leyva/perl/ch-1.pl
@@ -0,0 +1,56 @@
+=begin 
+You are given an array of integers, @ints.
+
+Write a script to find the lucky integer if found otherwise return -1. If there are more than one then return the largest.
+
+A lucky integer is an integer that has a frequency in the array equal to its value.
+
+Example 1
+Input: @ints = (2, 2, 3, 4)
+Output: 2
+Example 2
+Input: @ints = (1, 2, 2, 3, 3, 3)
+Output: 3
+Example 3
+Input: @ints = (1, 1, 1, 3)
+Output: -1
+=cut
+
+use strict;
+use Data::Dumper;
+
+
+my @inputs = ([2, 2, 3, 4],[1, 2, 2, 3, 3, 3],[1, 1, 1, 3]);
+
+foreach(@inputs){
+  my $arr = $_;
+  my @A = @$arr;
+  my $result = luckyNumber(\@A);
+  print $result."\n";
+}
+
+sub luckyNumber {
+  my $array = shift;
+  my @nums = @$array;
+
+  my %set;
+
+  foreach(@nums){
+    if(exists($set{$_})){
+      $set{$_} += 1;
+    }else{
+      $set{$_} = 1;
+    }
+  }
+  
+  my @largest;
+  foreach(sort {$a <=> $b} keys %set){
+    if($set{$_} == $_){
+      push @largest,$_;
+    }
+  }
+
+  return $largest[-1] if (@largest);
+  return -1;
+
+}
\ No newline at end of file
diff --git a/challenge-284/santiago-leyva/perl/ch-2.pl b/challenge-284/santiago-leyva/perl/ch-2.pl
new file mode 100644
index 0000000000..c2c454f4de
--- /dev/null
+++ b/challenge-284/santiago-leyva/perl/ch-2.pl
@@ -0,0 +1,86 @@
+=begin 
+You are given two list of integers, @list1 and @list2. The elements in the @list2 are distinct and also in the @list1.
+
+Write a script to sort the elements in the @list1 such that the relative order of items in @list1 is same as in the @list2. Elements that is missing in @list2 should be placed at the end of @list1 in ascending order.
+
+Example 1
+Input: @list1 = (2, 3, 9, 3, 1, 4, 6, 7, 2, 8, 5)
+       @list2 = (2, 1, 4, 3, 5, 6)
+Ouput: (2, 2, 1, 4, 3, 3, 5, 6, 7, 8, 9)
+Example 2
+Input: @list1 = (3, 3, 4, 6, 2, 4, 2, 1, 3)
+       @list2 = (1, 3, 2)
+Ouput: (1, 3, 3, 3, 2, 2, 4, 4, 6)
+Example 3
+Input: @list1 = (3, 0, 5, 0, 2, 1, 4, 1, 1)
+       @list2 = (1, 0, 3, 2)
+Ouput: (1, 1, 1, 0, 0, 3, 2, 4, 5)
+=cut
+
+use strict;
+use Data::Dumper;
+
+
+my @A = (2, 3, 9, 3, 1, 4, 6, 7, 2, 8, 5);
+my @B = (2, 1, 4, 3, 5, 6);
+
+my @result = customSort(\@A,\@B);
+print join(" ",@result)."\n";
+
+my @A = (3, 3, 4, 6, 2, 4, 2, 1, 3);
+my @B = (1, 3, 2);
+my @result = customSort(\@A,\@B);
+print join(" ",@result)."\n";
+
+my @A = (3, 0, 5, 0, 2, 1, 4, 1, 1);
+my @B = (1, 0, 3, 2);
+my @result = customSort(\@A,\@B);
+print join(" ",@result)."\n";
+
+sub customSort {
+  my ($arr1,$arr2) = @_;
+
+  my @list1 = @$arr1;
+  my @list2 = @$arr2;
+
+  my %set1 = createSet(\@list1);
+  my @sorted;
+  foreach(@list2){
+    if(exists($set1{$_})){
+      push @sorted,$_;
+      if(($set1{$_}) > 1){
+        for(my $i=1;$i<(scalar($set1{$_}));$i++){
+          push @sorted,$_;
+        }
+      }
+      delete $set1{$_};
+    }
+  }
+
+  foreach(sort {$a<=>$b} keys %set1){
+      push @sorted,$_;
+      if(($set1{$_}) > 1){
+        for(my $i=1;$i<(scalar($set1{$_}));$i++){
+          push @sorted,$_;
+        }
+      }
+  }
+  #print join(" ",@sorted)."\n";
+  return @sorted;
+
+}
+
+sub createSet {
+  my $input = shift;
+  my @A = @$input;
+  my %_set;
+  foreach(@A){
+    if(exists($_set{$_})){
+      $_set{$_} += 1;
+    }else{
+      $_set{$_} = 1;
+    }
+  }
+
+  return %_set;
+}