Automated update

Author: JakubDotPy

output/area_of_a_shape.py

@@ -0,0 +1,18 @@
+"""Kata - Area of a Shape
+
+completed at: 2024-05-14 16:44:00
+by: Jakub Červinka
+
+We'd like to know the area of an arbitrary shape. The only information of the shape is that it is bounded within the square area of four points: (0, 0), (1, 0), (1, 1) and (0, 1).
+
+Given a function `f(x, y)` which returns a boolean representing whether the point `(x, y)` is inside the shape, determine the area of the shape. Your answer is allowed to differ from the true answer by at most 0.01.
+
+Hint: http://bit.ly/1vJJt61
+"""
+
+from random import random as rand
+
+def area_of_the_shape(f):
+    n = 10_000
+    inside = sum(f(rand(), rand()) for _ in range(n))
+    return inside / n

output/crack_the_pin.py

@@ -0,0 +1,49 @@
+"""Kata - Crack the PIN
+
+completed at: 2024-05-14 19:09:24
+by: Jakub Červinka
+
+Given is a md5 hash of a five digits long PIN. It is given as string.
+Md5 is a function to hash your password:
+"password123" ===> "482c811da5d5b4bc6d497ffa98491e38"
+
+Why is this useful?
+Hash functions like md5 can create a hash from string in a short time and it is impossible to find out the password, if you only got the hash. The only way is cracking it, means try every combination, hash it and compare it with the hash you want to crack. (There are also other ways of attacking md5 but that's another story)
+Every Website and OS is storing their passwords as hashes, so if a hacker gets access to the database, he can do nothing, as long the password is safe enough.
+
+<a href="https://en.wikipedia.org/wiki/Hash_function#:~:text=A%20hash%20function%20is%20any,table%20called%20a%20hash%20table." target="_blank">What is a hash?</a>
+
+<a href="https://en.wikipedia.org/wiki/MD5" target="_blank">What is md5?</a>
+
+Note: Many languages have build in tools to hash md5. If not, you can write your own md5 function or google for an example.
+
+<a href="https://www.codewars.com/kata/password-hashes" target="_blank">Here</a> is another kata on generating md5 hashes!
+
+
+Your task is to return the cracked PIN as string.
+
+This is a little fun kata, to show you, how weak PINs are and how important a bruteforce protection is, if you create your own login.
+
+If you liked this kata, <a href="https://www.codewars.com/kata/59146f7b4670ba520900000a" target="_blank">here</a> is an extension with short passwords!
+
+Some of my other katas:
+<br>
+<a href="https://www.codewars.com/kata/5ef9ca8b76be6d001d5e1c3e" target="_blank">Error Correction #1 - Hamming Code</a>
+<br>
+<a href="https://www.codewars.com/kata/5f0795c6e45bc600247ab794" target="_blank">Hack the NSA</a>
+<br>
+<a href="https://www.codewars.com/kata/5ef9c85dc41b4e000f9a645f" target="_blank">Decode the QR-Code</a>
+
+
+
+"""
+
+import hashlib
+
+
+def crack(hash):
+    for n in range(100_000):
+        pwd = f'{n:05}'
+        my_hash = hashlib.md5(pwd.encode('utf-8')).hexdigest()
+        if my_hash == hash:
+            return pwd

output/find_the_strongest_apes.py

@@ -0,0 +1,90 @@
+"""Kata - Find the Strongest Apes
+
+completed at: 2024-05-14 18:45:48
+by: Jakub Červinka
+
+Imagine that you went to a zoo and some zoologists asked you for help.
+They want you to find the strongest ape of its own kind and there are 4 types of apes in the zoo. (Gorilla, Gibbon, Orangutan, Chimpanzee)
+
+* There will be only one parameter which is a list containing lots of dictionaries.
+* Each dictionary will be like this: `{"name": name, "weight": weight, "height": height, "type": type}`
+* To find the strongest ape, you need to compare the sum of weight and height of each apes of that kind.
+* The ape with the highest weight and height will be the strongest ape.
+* You need to return a dictionary which contains the names of the strongest apes of all kinds.`{"Gorilla": strongest_gorilla, "Gibbon": strongest_gibbon, "Orangutan": strongest_orangutan, "Chimpanzee": strongest_chimpanzee}`
+* There can be 2 or more apes which has the same highest weight and height. In that case, you need to sort their names by alphabet and then choose the first one as the strongest ape.
+* If there are no apes for a kind (e.g. Gorilla), you need to return a dictionary like this: `{"Gorilla": None, "Gibbon": strongest_gibbon, "Orangutan": strongest_orangutan, "Chimpanzee": strongest_chimpanzee}`
+
+__Example 1:__
+```
+find_the_strongest_apes(
+            [{"name": "aba", "weight": 101, "height": 99, "type": "Gorilla"},
+             {"name": "abb", "weight": 99, "height": 101, "type": "Gorilla"},
+             {"name": "abc", "weight": 101, "height": 99, "type": "Orangutan"},
+             {"name": "abd", "weight": 99, "height": 101, "type": "Orangutan"}])
+```
+Should return `{'Gorilla': 'aba', 'Gibbon': None, 'Orangutan': 'abc', 'Chimpanzee': None}`
+
+__Example 2:__
+```
+find_the_strongest_apes(
+            [{"name": "aba", "weight": 140, "height": 120, "type": "Gorilla"},
+             {"name": "abb", "weight": 20, "height": 50, "type": "Gibbon"},
+             {"name": "abc", "weight": 75, "height": 110, "type": "Orangutan"},
+             {"name": "abd", "weight": 50, "height": 100, "type": "Chimpanzee"}])
+```
+Should return `{'Gorilla': 'aba', 'Gibbon': 'abb', 'Orangutan': 'abc', 'Chimpanzee': 'abd'}`
+
+__Example 3:__
+```
+find_the_strongest_apes(
+            [{"name": "aba", "weight": 140, "height": 120, "type": "Gorilla"},
+             {"name": "abb", "weight": 150, "height": 120, "type": "Gorilla"},
+             {"name": "abc", "weight": 75, "height": 110, "type": "Orangutan"},
+             {"name": "abd", "weight": 50, "height": 100, "type": "Chimpanzee"}])
+```
+Should return `{'Gorilla': 'abb', 'Gibbon': None, 'Orangutan': 'abc', 'Chimpanzee': 'abd'}`
+
+_*English is not my native language, so some sentences may not be descriptive enough or even give incorrect information. If you find a wrong sentence, please feel free to comment._
+"""
+
+from dataclasses import dataclass
+from dataclasses import field
+from collections import defaultdict
+from itertools import groupby
+from operator import attrgetter
+
+
+@dataclass
+class Ape:
+    type: str
+    power: int = field(init=False)
+    weight: int
+    height: int
+    name: str
+    
+    def __post_init__(self):
+        self.power = self.weight + self.height
+    
+    def __str__(self):
+        return f'{self.type} {self.name!r} p: {self.power}'
+    
+    __repr__ = __str__
+
+
+sort_fn = lambda x: (x.type, -x.power, x.name)
+    
+    
+def find_the_strongest_apes(_list):
+    types = ('Gorilla', 'Gibbon', 'Orangutan', 'Chimpanzee')
+    result = dict.fromkeys(types, None)
+    
+    monkes = sorted((Ape(**data) for data in _list), key=sort_fn)
+    
+    for _, apes in groupby(monkes, key=attrgetter('type')):
+        ape = next(apes)
+        result[ape.type] = ape.name
+
+    return result
+        
+    
+    

output/fizzbuzz_backwards.py

@@ -0,0 +1,42 @@
+"""Kata - FizzBuzz Backwards
+
+completed at: 2024-05-14 16:53:21
+by: Jakub Červinka
+
+Traditionally in FizzBuzz, multiples of 3 are replaced by "Fizz" and multiples of 5 are replaced by "Buzz". But we could also play FizzBuzz with any other integer pair `[n, m]` whose multiples are replaced with Fizz and Buzz. 
+
+For a sequence of numbers, Fizzes, Buzzes and FizzBuzzes, find the numbers whose multiples are being replaced by Fizz and Buzz. Return them as an array `[n, m]`
+
+The Fizz and Buzz numbers will always be integers between 1 and 50, and the sequence will have a maximum length of 100. The Fizz and Buzz numbers might be equal, and might be equal to 1.
+
+## Examples
+* Classic FizzBuzz; multiples of 3 are replaced by Fizz, multiples of 5 are replaced by Buzz:
+```
+[1, 2, "Fizz", 4, "Buzz", 6]  ==>  [3, 5] 
+```
+* Multiples of 2 are replaced by Fizz, multiples of 3 are replaced by Buzz:
+```
+[1, "Fizz", "Buzz", "Fizz", 5, "FizzBuzz"]  ==>  [2, 3]
+```
+* Multiples of 2 are replaced by Fizz and Buzz:
+```
+[1, "FizzBuzz", 3, "FizzBuzz", 5, "FizzBuzz"]  ==>  [2, 2]
+```
+* Fizz = 1, Buzz = 6:
+```
+["Fizz", "Fizz", "Fizz", "Fizz", "Fizz", "FizzBuzz"]  ==>  [1, 6]
+```
+"""
+
+def reverse_fizz_buzz(array):
+    fizz = buzz = None
+    for i, elem in enumerate(array, start=1):
+        elem = str(elem)
+        if 'Fizz' in elem and not fizz:
+            fizz = i
+        if 'Buzz' in elem and not buzz:
+            buzz = i
+        if fizz and buzz:
+            return fizz, buzz
+        
+