From 9243782e5c4fe456e60eff6b8565f66af495c4dc Mon Sep 17 00:00:00 2001
From: Paulo Custodio <pauloscustodio@gmail.com>
Date: Sun, 8 Sep 2024 18:11:41 +0100
Subject: Add Python solution to challenge 053

---
 challenge-053/paulo-custodio/perl/ch-2.pl   | 10 ++---
 challenge-053/paulo-custodio/python/ch-1.py | 42 +++++++++++++++++++
 challenge-053/paulo-custodio/python/ch-2.py | 64 +++++++++++++++++++++++++++++
 3 files changed, 111 insertions(+), 5 deletions(-)
 create mode 100644 challenge-053/paulo-custodio/python/ch-1.py
 create mode 100644 challenge-053/paulo-custodio/python/ch-2.py

diff --git a/challenge-053/paulo-custodio/perl/ch-2.pl b/challenge-053/paulo-custodio/perl/ch-2.pl
index 8eb54e16fa..bb13b9cdb4 100644
--- a/challenge-053/paulo-custodio/perl/ch-2.pl
+++ b/challenge-053/paulo-custodio/perl/ch-2.pl
@@ -9,15 +9,15 @@
 #
 # The string should follow the following rules:
 #
-# ‘a’ can only be followed by ‘e’ and ‘i’.
+# 'a' can only be followed by 'e' and 'i'.
 #
-# ‘e’ can only be followed by ‘i’.
+# 'e' can only be followed by 'i'.
 #
-# ‘i’ can only be followed by ‘a’, ‘e’, ‘o’, and ‘u’.
+# 'i' can only be followed by 'a', 'e', 'o', and 'u'.
 #
-# ‘o’ can only be followed by ‘a’ and ‘u’.
+# 'o' can only be followed by 'a' and 'u'.
 #
-# ‘u’ can only be followed by ‘o’ and ‘e’.
+# 'u' can only be followed by 'o' and 'e'.
 #
 # For example, if the given integer N = 2 then script should print the following
 # strings:
diff --git a/challenge-053/paulo-custodio/python/ch-1.py b/challenge-053/paulo-custodio/python/ch-1.py
new file mode 100644
index 0000000000..c323b6f3a8
--- /dev/null
+++ b/challenge-053/paulo-custodio/python/ch-1.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+# Challenge 053
+#
+# TASK #1
+# Rotate Matrix
+# Write a script to rotate the followin matrix by given 90/180/270 degrees
+# clockwise.
+#
+# [ 1, 2, 3 ]
+# [ 4, 5, 6 ]
+# [ 7, 8, 9 ]
+# For example, if you rotate by 90 degrees then expected result should be like
+# below
+#
+# [ 7, 4, 1 ]
+# [ 8, 5, 2 ]
+# [ 9, 6, 3 ]
+
+m = [[ 1, 2, 3 ],
+     [ 4, 5, 6 ],
+     [ 7, 8, 9 ]];
+
+def rotate90(m):
+    return [[ m[2][0], m[1][0], m[0][0] ],
+            [ m[2][1], m[1][1], m[0][1] ],
+            [ m[2][2], m[1][2], m[0][2] ]]
+
+def rotate180(m):
+    return rotate90(rotate90(m))
+
+def rotate270(m):
+    return rotate90(rotate90(rotate90(m)))
+
+def display(m):
+    for row in m:
+        print("[ "+", ".join([str(x) for x in row])+" ]")
+    print("")
+
+display(rotate90(m))
+display(rotate180(m))
+display(rotate270(m))
diff --git a/challenge-053/paulo-custodio/python/ch-2.py b/challenge-053/paulo-custodio/python/ch-2.py
new file mode 100644
index 0000000000..2672f2d84a
--- /dev/null
+++ b/challenge-053/paulo-custodio/python/ch-2.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+
+# Challenge 053
+#
+# TASK #2
+# Vowel Strings
+# Write a script to accept an integer 1 <= N <= 5 that would print all possible
+# strings of size N formed by using only vowels (a, e, i, o, u).
+#
+# The string should follow the following rules:
+#
+# 'a' can only be followed by 'e' and 'i'.
+#
+# 'e' can only be followed by 'i'.
+#
+# 'i' can only be followed by 'a', 'e', 'o', and 'u'.
+#
+# 'o' can only be followed by 'a' and 'u'.
+#
+# 'u' can only be followed by 'o' and 'e'.
+#
+# For example, if the given integer N = 2 then script should print the following
+# strings:
+#
+# ae
+# ai
+# ei
+# ia
+# io
+# iu
+# ie
+# oa
+# ou
+# uo
+# ue
+
+import sys
+
+def show_vowels(n, string):
+    if len(string) == n:
+        print(string)
+    elif string == "":
+        for vowel in ['a', 'e', 'i', 'o', 'u']:
+            show_vowels(n, string+vowel)
+    elif string[-1] == 'a':
+        for vowel in ['e', 'i']:
+            show_vowels(n, string+vowel)
+    elif string[-1] == 'e':
+        for vowel in ['i']:
+            show_vowels(n, string+vowel)
+    elif string[-1] == 'i':
+        for vowel in ['a', 'e', 'o', 'u']:
+            show_vowels(n, string+vowel)
+    elif string[-1] == 'o':
+        for vowel in ['a', 'u']:
+            show_vowels(n, string+vowel)
+    elif string[-1] == 'u':
+        for vowel in ['e', 'o']:
+            show_vowels(n, string+vowel)
+    else:
+        print("expected vowel, got "+string)
+
+n = int(sys.argv[1])
+show_vowels(n, "")
-- 
cgit 


From 451d779420e30ac64a61beadea91da317b8dc6b2 Mon Sep 17 00:00:00 2001
From: Paulo Custodio <pauloscustodio@gmail.com>
Date: Sun, 8 Sep 2024 19:21:24 +0100
Subject: Add Python solution to challenge 054

---
 challenge-054/paulo-custodio/perl/ch-2.pl   | 36 ++++++++++++------
 challenge-054/paulo-custodio/python/ch-1.py | 29 +++++++++++++++
 challenge-054/paulo-custodio/python/ch-2.py | 58 +++++++++++++++++++++++++++++
 challenge-054/paulo-custodio/t/test-2.yaml  |  7 +++-
 4 files changed, 117 insertions(+), 13 deletions(-)
 create mode 100644 challenge-054/paulo-custodio/python/ch-1.py
 create mode 100644 challenge-054/paulo-custodio/python/ch-2.py

diff --git a/challenge-054/paulo-custodio/perl/ch-2.pl b/challenge-054/paulo-custodio/perl/ch-2.pl
index 5aa109c437..b6929a1e54 100644
--- a/challenge-054/paulo-custodio/perl/ch-2.pl
+++ b/challenge-054/paulo-custodio/perl/ch-2.pl
@@ -11,7 +11,8 @@
 # $n = 3*$n + 1 when $n is odd
 # For example, if we start at 23, we get the following sequence:
 #
-# 23 ? 70 ? 35 ? 106 ? 53 ? 160 ? 80 ? 40 ? 20 ? 10 ? 5 ? 16 ? 8 ? 4 ? 2 ? 1
+# 23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8
+# -> 4 -> 2 -> 1
 #
 # Write a function that finds the Collatz sequence for any positive integer.
 # Notice how the sequence itself may go far above the original starting number.
@@ -23,21 +24,32 @@
 
 use Modern::Perl;
 
-my @longest;
-for my $n (1..1e6) {
-    my @seq = collatz($n);
-    my $len = scalar(@seq);
-    push @longest, [$n => $len];
-    @longest = sort {$b->[1] <=> $a->[1]} @longest;
-    pop @longest if @longest > 20;
+@ARGV or die "Usage: $0 -l|n\n";
+my $arg = shift;
+if ($arg eq "-l") {
+    print_longest(20)
 }
+else {
+    print join(" -> ", collatz_seq($arg))
+}
+
+sub print_longest {
+    my @longest;
+    for my $n (1..1e6) {
+        my @seq = collatz_seq($n);
+        my $len = scalar(@seq);
+        push @longest, [$n => $len];
+        @longest = sort {$b->[1] <=> $a->[1]} @longest;
+        pop @longest if @longest > 20;
+    }
 
-for (@longest) {
-    my($n, $len) = @$_;
-    say "$n $len";
+    for (@longest) {
+        my($n, $len) = @$_;
+        say "$n $len";
+    }
 }
 
-sub collatz {
+sub collatz_seq {
     my($n) = @_;
     my @out = ($n);
     while ($n != 1) {
diff --git a/challenge-054/paulo-custodio/python/ch-1.py b/challenge-054/paulo-custodio/python/ch-1.py
new file mode 100644
index 0000000000..6bb39a6f43
--- /dev/null
+++ b/challenge-054/paulo-custodio/python/ch-1.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+# Challenge 054
+#
+# TASK #1
+# kth Permutation Sequence
+# Write a script to accept two integers n (>=1) and k (>=1). It should print the
+# kth permutation of n integers. For more information, please follow the wiki
+# page.
+#
+# For example, n=3 and k=4, the possible permutation sequences are listed below:
+#
+# 123
+# 132
+# 213
+# 231
+# 312
+# 321
+# The script should print the 4th permutation sequence 231.
+
+import sys
+from itertools import permutations
+
+n = int(sys.argv[1])
+k = int(sys.argv[2])
+
+perm = permutations([x for x in range(1, n+1)], k)
+for i in list(perm):
+    print("".join([str(x) for x in i]))
diff --git a/challenge-054/paulo-custodio/python/ch-2.py b/challenge-054/paulo-custodio/python/ch-2.py
new file mode 100644
index 0000000000..860174b483
--- /dev/null
+++ b/challenge-054/paulo-custodio/python/ch-2.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+# Challenge 054
+#
+# TASK #2
+# Collatz Conjecture
+# Contributed by Ryan Thompson
+# It is thought that the following sequence will always reach 1:
+#
+# $n = $n / 2 when $n is even
+# $n = 3*$n + 1 when $n is odd
+# For example, if we start at 23, we get the following sequence:
+#
+# 23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8
+# -> 4 -> 2 -> 1
+#
+# Write a function that finds the Collatz sequence for any positive integer.
+# Notice how the sequence itself may go far above the original starting number.
+#
+# Extra Credit
+# Have your script calculate the sequence length for all starting numbers up to
+# 1000000 (1e6), and output the starting number and sequence length for the
+# longest 20 sequences.
+
+import sys
+
+def collatz_seq(n):
+    out = [n]
+    while n != 1:
+        if n % 2 == 0:
+            n = int(n/2)
+        else:
+            n = 3*n + 1
+        out.append(n)
+    return out
+
+def print_longest():
+    longest = []
+    for n in range(1, int(1e6)+1):
+        count = len(collatz_seq(n))
+        longest.append([n, count])
+        longest.sort(key=lambda x:x[0])
+        longest = longest[::-1]
+        longest.sort(key=lambda x:x[1])
+        longest = longest[::-1]
+        if len(longest) > 20:
+            longest.pop()
+
+    for i in longest:
+        print(str(i[0])+" "+str(i[1]))
+
+
+if sys.argv[1] == "-l":
+    print_longest()
+else:
+    n = int(sys.argv[1])
+    seq = collatz_seq(n)
+    print(" -> ".join([str(x) for x in seq]))
diff --git a/challenge-054/paulo-custodio/t/test-2.yaml b/challenge-054/paulo-custodio/t/test-2.yaml
index 78babb1408..eef2d4d68b 100644
--- a/challenge-054/paulo-custodio/t/test-2.yaml
+++ b/challenge-054/paulo-custodio/t/test-2.yaml
@@ -1,6 +1,11 @@
 - setup:
   cleanup:
-  args:     20
+  args:     23
+  input:
+  output:   23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
+- setup:
+  cleanup:
+  args:     -l
   input:
   output:   |
             |837799 525
-- 
cgit