Automated update

Author: JakubDotPy

output/find_the_integer_sequences.py

@@ -0,0 +1,58 @@
+"""Kata - Find the integer sequences
+
+completed at: 2024-04-16 16:14:07
+by: Jakub Červinka
+
+>When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process  --myjinxin2015 said
+
+# Description:
+ Complete function `findSequences`. It accepts a positive integer `n`. Your task is to find such integer sequences:
+
+ <span style="background:#000000"><font size=4>Continuous positive integer and their sum value equals to n </font></span>
+ 
+ ```
+ For example, n = 15 
+ valid integer sequences:
+ [1,2,3,4,5]  (1+2+3+4+5==15)
+ [4,5,6]          (4+5+6==15)
+ [7,8]              (7+8==15)
+ 
+ ```
+ The result should be an array `[sequence 1,sequence 2...sequence n]`, sorted by ascending order of the length of sequences; If no result found, return [].
+ 
+  
+# Some examples:
+
+```
+
+findSequences(3) === [[1,2]]
+
+findSequences(15) === [[7,8],[4,5,6],[1,2,3,4,5]]
+
+findSequences(20) === [[2, 3, 4, 5, 6]]
+
+findSequences(100) === [[18, 19, 20, 21, 22], [9, 10, 11, 12, 13, 14, 15, 16]]
+
+findSequences(1) === []
+```
+
+"""
+
+def find_sequences(n):
+    sequences = []
+    start = 1
+    end = 1
+    current_sum = 0
+    while start <= n // 2:
+        if current_sum < n:
+            current_sum += end
+            end += 1
+        elif current_sum > n:
+            current_sum -= start
+            start += 1
+        else:
+            sequences.append(list(range(start, end)))
+            current_sum -= start
+            start += 1
+    return sorted(sequences, key=len)
+

output/real_password_cracker.py

@@ -0,0 +1,35 @@
+"""Kata - Real Password Cracker
+
+completed at: 2024-04-16 18:23:59
+by: Jakub Červinka
+
+### Story
+
+You are a h4ck3r n00b: you "acquired" a bunch of password hashes, and you want to decypher them. Based on the length, you already guessed that they must be SHA-1 hashes. You also know that these are weak passwords: maximum 5 characters long and use only lowercase letters (`a-z`), no other characters.
+
+Happy hacking!
+
+**Notes:**
+* pre-generating the full hash table is not advised, due to the time-limit on the CW platform
+* there will be only a few tests for 5-letter words *(hint: start from the beginning of the alphabet)*
+* if your solution times out, try running it again - the CW runner is sometimes a bit slow(er)
+
+---
+
+### My other katas
+
+If you enjoyed this kata then please try [my other katas](https://www.codewars.com/users/anter69/authored)! :-)
+
+#### *Translations are welcome!*
+"""
+
+from hashlib import sha1
+from itertools import product
+from string import ascii_lowercase as al
+
+def password_cracker(hash):
+    for l in range(1, 6):
+        for word in product(al, repeat=l):
+            word = ''.join(word)
+            if sha1(word.encode()).hexdigest() == hash:
+                return word

output/summarize_ranges.py

@@ -0,0 +1,73 @@
+"""Kata - Summarize ranges
+
+completed at: 2024-04-16 21:02:17
+by: Jakub Červinka
+
+Given a sorted array of numbers, return the summary of its ranges.
+
+
+## Examples
+```javascript
+summaryRanges([1, 2, 3, 4]) === ["1->4"]
+summaryRanges([1, 1, 1, 1, 1]) === ["1"]
+summaryRanges([0, 1, 2, 5, 6, 9]) === ["0->2", "5->6", "9"]
+summaryRanges([0, 1, 2, 3, 3, 3, 4, 5, 6, 7]) === ["0->7"]
+summaryRanges([0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10]) === ["0->7", "9->10"]
+summaryRanges([-2,0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10, 12]) ===["-2", "0->7", "9->10", "12"]
+```
+```python
+summary_ranges([1, 2, 3, 4]) == ["1->4"]
+summary_ranges([1, 1, 1, 1, 1]) == ["1"]
+summary_ranges([0, 1, 2, 5, 6, 9]) == ["0->2", "5->6", "9"]
+summary_ranges([0, 1, 2, 3, 3, 3, 4, 5, 6, 7]) == ["0->7"]
+summary_ranges([0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10]) == ["0->7", "9->10"]
+summary_ranges([-2, 0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10, 12]) == ["-2", "0->7", "9->10", "12"]
+```
+```ruby
+summary_ranges([1, 2, 3, 4]) == ["1->4"]
+summary_ranges([1, 1, 1, 1, 1]) == ["1"]
+summary_ranges([0, 1, 2, 5, 6, 9]) == ["0->2", "5->6", "9"]
+summary_ranges([0, 1, 2, 3, 3, 3, 4, 5, 6, 7]) == ["0->7"]
+summary_ranges([0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10]) == ["0->7", "9->10"]
+summary_ranges([-2, 0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10, 12]) == ["-2", "0->7", "9->10", "12"]
+```
+"""
+
+from itertools import pairwise
+
+
+def find_consecutive_start(arr):
+    for i, (a, b) in enumerate(pairwise(arr)):
+        if b > a + 1:
+            return arr[:i + 1]
+    return arr
+
+
+def ranges_to_string(ranges):
+    result = []
+    for start, end in ranges:
+        if start == end:
+            result.append(str(start))
+        else:
+            result.append(f'{start}->{end}')
+    return result
+
+
+def summary_ranges(arr):
+    # setup
+    start, end = 0, 1
+    output = []
+
+    # edge cases
+    if not arr: return output
+    if len(arr) == 1: return [str(arr[0])]
+
+    while arr:
+        sub_arr = find_consecutive_start(arr)
+        output.append([sub_arr[0], sub_arr[-1]])
+        arr = arr[len(sub_arr):]
+
+    output = ranges_to_string(output)
+    return output
+            
+