Automated update

Author: JakubDotPy

output/message_validator.py

@@ -0,0 +1,42 @@
+"""Kata - Message Validator
+
+completed at: 2024-09-06 18:51:26
+by: Jakub Červinka
+
+In this kata, you have an input string and you should check whether it is a valid message. To decide that, you need to split the string by the numbers, and then compare the numbers with the number of characters in the following substring.
+
+For example `"3hey5hello2hi"` should be split into `3, hey, 5, hello, 2, hi` and the function should return `true`, because `"hey"` is 3 characters, `"hello"` is 5, and `"hi"` is 2; as the numbers and the character counts match, the result is `true`.
+      
+      
+**Notes:**
+* Messages are composed of only letters and digits
+* Numbers may have multiple digits: e.g. `"4code13hellocodewars"` is a valid message
+* Every number must match the number of character in the following substring, otherwise the message is invalid: e.g. `"hello5"` and `"2hi2"` are invalid
+* If the message is an empty string, you should return `true`
+
+"""
+
+import re
+from itertools import tee
+from itertools import islice
+from itertools import zip_longest
+
+def is_a_valid_message(message):
+    parts = re.split(r'(\d+)', message)
+    parts = filter(None, parts)  # remove empty strings
+    
+    # prepare iterators
+    first_it, second_it = tee(parts, 2)
+    
+    nums = islice(first_it, 0, None, 2)
+    nums = map(int, nums)
+    texts = islice(second_it, 1, None, 2)
+    
+    try:
+        for num, text in zip_longest(nums, texts):
+            assert len(text) == num
+    except (AssertionError, ValueError, TypeError):
+        return False
+    
+    # all passed
+    return True

output/so_many_permutations.py

@@ -0,0 +1,36 @@
+"""Kata - So Many Permutations!
+
+completed at: 2024-09-06 18:55:10
+by: Jakub Červinka
+
+In this kata, your task is to create all permutations of a non-empty input string and remove duplicates, if present. 
+
+Create as many "shufflings" as you can!
+
+Examples:
+```
+With input 'a':
+Your function should return: ['a']
+
+With input 'ab':
+Your function should return ['ab', 'ba']
+
+With input 'abc':
+Your function should return ['abc','acb','bac','bca','cab','cba']
+
+With input 'aabb':
+Your function should return ['aabb', 'abab', 'abba', 'baab', 'baba', 'bbaa']
+```
+
+Note: The order of the permutations doesn't matter.
+
+Good luck!
+
+
+
+"""
+
+from itertools import permutations as perm
+
+def permutations(s):
+    return set(''.join(p) for p in perm(s))

output/the_observed_pin.py

@@ -0,0 +1,59 @@
+"""Kata - The observed PIN
+
+completed at: 2024-09-06 19:18:17
+by: Jakub Červinka
+
+Alright, detective, one of our colleagues successfully observed our target person, Robby the robber. We followed him to a secret warehouse, where we assume to find all the stolen stuff. The door to this warehouse is secured by an electronic combination lock. Unfortunately our spy isn't sure about the PIN he saw, when Robby entered it.
+
+The keypad has the following layout:
+```
+┌───┬───┬───┐
+│ 1 │ 2 │ 3 │
+├───┼───┼───┤
+│ 4 │ 5 │ 6 │
+├───┼───┼───┤
+│ 7 │ 8 │ 9 │
+└───┼───┼───┘
+    │ 0 │
+    └───┘
+```
+He noted the PIN `1357`, but he also said, it is possible that each of the digits he saw could actually be another adjacent digit (horizontally or vertically, but not diagonally). E.g. instead of the `1` it could also be the `2` or `4`. And instead of the `5` it could also be the `2`, `4`, `6` or `8`.
+
+He also mentioned, he knows this kind of locks. You can enter an unlimited amount of wrong PINs, they never finally lock the system or sound the alarm. That's why we can try out all possible (*) variations.
+
+\* possible in sense of: the observed PIN itself and all variations considering the adjacent digits
+
+Can you help us to find all those variations? It would be nice to have a function, that returns an array (or a list in Java/Kotlin and C#)  of all variations for an observed PIN with a length of 1 to 8 digits. We could name the function `getPINs` (`get_pins` in python, `GetPINs` in C#). But please note that all PINs, the observed one and also the results, must be strings, because of potentially leading '0's. We already prepared some test cases for you.
+
+Detective, we are counting on you!
+
+```if:csharp
+***For C# user:*** Do not use Mono. Mono is too slower when run your code.
+```
+
+"""
+
+from itertools import chain
+from itertools import product
+
+def get_pins(observed):
+    adjacents = {
+        '0': ('0', '8'),
+        '1': ('1', '2', '4'),
+        '2': ('2', '1', '3', '5'),
+        '3': ('3', '2', '6'),
+        '4': ('4', '1', '5', '7'),
+        '5': ('5', '2', '4', '6', '8'),
+        '6': ('6', '3', '5', '9'),
+        '7': ('7', '4', '8'),
+        '8': ('8', '5', '7', '9', '0'),
+        '9': ('9', '6', '8')
+    }
+    options = product(*[adjacents[num] for num in observed])
+    return (''.join(opt) for opt in options)
+    
+    
+
+    
+
+