06: další úkoly

Author: ZelenyMartin

06/README.md

@@ -1,10 +1,21 @@
 # GitHub a pull requesty
 
-* **Nic nedělej dopředu.** Budeme pracovat až společně na srazu.
+## Před srazem
+* Doporučuju projít si materiály https://naucse.python.cz/2019/gitworking-openalt/
+* Nainstaluj si Git
+* Na Windows pracuj v příkazové řádce Git Bash (v Průzkumníku si ho můžeš otevřít v kontextovém menu přes pravé tlačítko myši). Na Linux a v MacOS pracuj normálně.
+* Nakonfiguruj si Git
+    * jméno
+    * e-mail
+    * editor
+* **Nedělej úkoly dopředu.** Rozdělíme si práci až společně na srazu.
+
+## Aktivita na sraz
+
+* Společně si všichni zkontrolujeme, že máme správně a shodně nastavený Git.
 * Toto je speciální aktivita, kde se nebudeme řídit postupem pro odevzdávání úkolů, který jsem říkal doposud.
 * Toto bude reprezentovat **skutečný způsob práce na GitHubu**, kdy budete chtít dosáhnout umístění svého kódu v branchi main v hlavním repu.
 
-## Aktivita na sraz
 
 1. Vybereš si na jakém tasku budeš dělat. Napíšeme na tabuli, kdo na čem bude dělat.
 1. Vyřešíš task a commitneš řešení do nové branche
@@ -17,7 +28,11 @@
 ChatGPT mi vytvořilo podle zadání bashový skript, který vygeneroval všechny tasky i unit testy. Musel jsem to trochu upravit, protože to nefungovalo hned out-of-the-box. Příkaz `pytest` spustí všechny testy. Jednotlivý test spustíš:
 
 ```
-pytest test_01_sum_two_numbers.py
+pytest test_01_sum_two_numbers.py -vv
 ```
 
+Parametr `-v` a `-vv` zvyšuje vypisování detailů chyb.
+
 Funkce s tasky používají typing annotation - je to moderní způsob psaní funkcí v Pythonu, kdy určujeme datové typy parametrů funkce a datový typ návratové hodnoty.
+
+Úkoly 01 až 25 jsou jednoduché. Výzvou jsou až úkoly 25 až 35.

06/generate_adv_tasks.py

@@ -0,0 +1,258 @@
+#!/bin/bash
+
+mkdir -p tasks
+
+function write_task_and_test() {
+  num=$1
+  name=$2
+  task_code=$3
+  test_code=$4
+
+  task_file="tasks/task_${num}_${name}.py"
+  test_file="test_${num}_${name}.py"
+
+  echo "# task_${num}_${name}.py" > "$task_file"
+  echo -e "$task_code" >> "$task_file"
+
+  echo "# test_${num}_${name}.py" > "$test_file"
+  echo -e "$test_code" >> "$test_file"
+}
+
+
+write_task_and_test "26" "is_palindrome_sentence" '
+def is_palindrome_sentence(s: str) -> bool:
+    """
+    Vrátí True, pokud je věta palindrom (ignoruje mezery, interpunkci a velikost písmen).
+    """
+' '
+import pytest
+from tasks.task_26_is_palindrome_sentence import is_palindrome_sentence
+
+def test_is_palindrome_sentence():
+    assert is_palindrome_sentence("A man, a plan, a canal: Panama")
+    assert is_palindrome_sentence("No lemon, no melon")
+    assert is_palindrome_sentence("Eva, can I see bees in a cave?")
+    assert is_palindrome_sentence("Was it a car or a cat I saw?")
+    assert not is_palindrome_sentence("This is not a palindrome")
+    assert not is_palindrome_sentence("And this also not")
+'
+
+
+write_task_and_test "27" "group_anagrams" '
+def group_anagrams(words: list[str]) -> list[list[str]]:
+    """
+    Skupiny anagramů v seznamu slov. Seznamy musí být seřazené. Anagramy v seznamech také seřazené.
+    """
+' '
+import pytest
+from tasks.task_27_group_anagrams import group_anagrams
+
+def test_group_anagrams():
+    assert group_anagrams(["bat", "cat", "tab", "act"]) == [["act", "cat"], ["bat", "tab"]]
+    assert group_anagrams(["google", "silent", "gogole", "listen", "enlist"]) == [["enlist", "listen", "silent"], ["gogole", "google"]]
+    assert group_anagrams([]) == []
+    assert group_anagrams(["abc"]) == [["abc"]]
+    assert group_anagrams(["cab", "xyz", "abc", "zyx", "bca"]) == [["abc", "bca", "cab"], ["xyz", "zyx"]]
+    assert group_anagrams(["rat", "tar", "art", "star", "tars", "cheese"]) == [["art", "rat", "tar"], ["cheese"], ["star", "tars"]]
+'
+
+
+write_task_and_test "28" "flatten_list" '
+def flatten_list(nested: list[list[int]]) -> list[int]:
+    """
+    Převede dvourozměrný seznam na jednorozměrný.
+    """
+' '
+import pytest
+from tasks.task_28_flatten_list import flatten_list
+
+def test_flatten_list():
+    assert flatten_list([[1, 2], [3, 4]]) == [1, 2, 3, 4]
+    assert flatten_list([[], [1], [], [2, 3]]) == [1, 2, 3]
+    assert flatten_list([]) == []
+    assert flatten_list([[1]]) == [1]
+    assert flatten_list([[1, 2, 3], [], [4], [5, 6]]) == [1, 2, 3, 4, 5, 6]
+    assert flatten_list([[0], [0, 0]]) == [0, 0, 0]
+    assert flatten_list([[10, 20], [30], [], [40, 50, 60]]) == [10, 20, 30, 40, 50, 60]
+    assert flatten_list([[1], [], [], [], [2]]) == [1, 2]
+'
+
+
+write_task_and_test "29" "longest_common_prefix" '
+def longest_common_prefix(strings: list[str]) -> str:
+    """
+    Vrátí nejdelší společný prefix v seznamu řetězců.
+    """
+' '
+import pytest
+from tasks.task_29_longest_common_prefix import longest_common_prefix
+
+def test_longest_common_prefix():
+    assert longest_common_prefix(["flower", "flow", "flight"]) == "fl"
+    assert longest_common_prefix(["dog", "racecar", "car"]) == ""
+    assert longest_common_prefix(["interspace", "interstellar", "interstate"]) == "inters"
+    assert longest_common_prefix(["throne", "throne"]) == "throne"
+    assert longest_common_prefix(["prefix", "pre", "presume", "presentation"]) == "pre"
+    assert longest_common_prefix(["a"]) == "a"
+    assert longest_common_prefix([]) == ""
+    assert longest_common_prefix(["abc", "abcde", "abcdef"]) == "abc"
+    assert longest_common_prefix(["", "abc"]) == ""
+    assert longest_common_prefix(["aaa", "aa", "aaa", "aaaaa"]) == "aa"
+'
+
+
+write_task_and_test "30" "remove_duplicates" '
+def remove_duplicates(nums: list[int]) -> list[int]:
+    """
+    Odstraní duplikáty ze seznamu a zachová pořadí.
+    """
+' '
+import pytest
+from tasks.task_30_remove_duplicates import remove_duplicates
+
+def test_remove_duplicates():
+    assert remove_duplicates([1,2,2,3,1]) == [1,2,3]
+    assert remove_duplicates([]) == []
+    assert remove_duplicates([1,1,1,1]) == [1]
+    assert remove_duplicates([3,2,1,2,3]) == [3,2,1]
+'
+
+
+write_task_and_test "31" "reverse_words" '
+def reverse_words(s: str) -> str:
+    """
+    Otočí pořadí slov ve větě.
+    """
+' '
+import pytest
+from tasks.task_31_reverse_words import reverse_words
+
+def test_reverse_words():
+    assert reverse_words("hello world") == "world hello"
+    assert reverse_words("one two three") == "three two one"
+    assert reverse_words("single") == "single"
+    assert reverse_words("a b c d") == "d c b a"
+    assert reverse_words("   spaced   words  test ") == "test words spaced"
+    assert reverse_words("") == ""
+'
+
+
+write_task_and_test "32" "decode_string" '
+def decode_string(s: str) -> str:
+    """
+    Dekóduje zakódovaný řetězec ve formátu k[encoded_string],
+    např. "3[a]2[bc]" → "aaabcbc".
+    """
+' '
+import pytest
+from tasks.task_32_decode_string import decode_string
+
+def test_decode_string():
+    assert decode_string("3[a]2[bc]") == "aaabcbc"
+    assert decode_string("2[abc]3[cd]ef") == "abcabccdcdcdef"
+    assert decode_string("3[a2[c]]") == "accaccacc"
+    assert decode_string("2[2[b]3[a]]") == "bbaaabbaaa"
+    assert decode_string("10[a]") == "aaaaaaaaaa"
+    assert decode_string("3[z]2[2[y]pq4[2[jk]e1[f]]]ef") == "zzzyypqjkjkefjkjkefjkjkefjkjkefyypqjkjkefjkjkefjkjkefjkjkefef"
+    assert decode_string("abc3[cd]xyz") == "abccdcdcdxyz"
+    assert decode_string("2[ab3[c]]") == "abcccabccc"
+    assert decode_string("100[code]") == "code" * 100
+    assert decode_string("0[abc]") == ""
+'
+
+
+write_task_and_test "33" "valid_parentheses" '
+def valid_parentheses(s: str) -> bool:
+    """
+    Zjistí, zda má řetězec validní závorky.
+    """
+' '
+import pytest
+from tasks.task_33_valid_parentheses import valid_parentheses
+
+def test_valid_parentheses():
+    assert valid_parentheses("()")
+    assert valid_parentheses("()[]{}")
+    assert not valid_parentheses("(]")
+    assert not valid_parentheses("([)]")
+    assert valid_parentheses("{[]}")
+    assert not valid_parentheses("(")
+    assert not valid_parentheses("(()")
+    assert not valid_parentheses(")(")
+    assert valid_parentheses("((()))")
+    assert valid_parentheses("{[()]}[]({})")
+    assert not valid_parentheses("{[}]")
+    assert valid_parentheses("")
+'
+
+
+write_task_and_test "34" "rotate_list" '
+def rotate_list(lst: list[int], k: int) -> list[int]:
+    """
+    Posune prvky seznamu o k pozic doprava.
+    """
+' '
+import pytest
+from tasks.task_34_rotate_list import rotate_list
+
+def test_rotate_list():
+    assert rotate_list([1,2,3,4,5], 2) == [4,5,1,2,3]
+    assert rotate_list([1,2,3], 1) == [3,1,2]
+    assert rotate_list([1,2,3], 0) == [1,2,3]
+    assert rotate_list([1,2,3], 3) == [1,2,3]
+    assert rotate_list([], 2) == []
+    assert rotate_list([1], 10) == [1]
+'
+
+
+write_task_and_test "35" "rotate_matrix" '
+def rotate_matrix(matrix: list[list[int]]) -> list[list[int]]:
+    """
+    Otočí čtvercovou matici o 90 stupňů ve směru hodinových ručiček.
+    """
+' '
+import pytest
+from tasks.task_35_rotate_matrix import rotate_matrix
+
+def test_rotate_matrix():
+    assert rotate_matrix([[1]]) == [[1]]
+
+    assert rotate_matrix([
+        [1, 2],
+        [3, 4]
+    ]) == [
+        [3, 1],
+        [4, 2]
+    ]
+
+    assert rotate_matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+    ]) == [
+        [7, 4, 1],
+        [8, 5, 2],
+        [9, 6, 3]
+    ]
+
+    assert rotate_matrix([
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+        [9, 10,11,12],
+        [13,14,15,16]
+    ]) == [
+        [13, 9, 5, 1],
+        [14,10, 6, 2],
+        [15,11, 7, 3],
+        [16,12, 8, 4]
+    ]
+
+    assert rotate_matrix([
+        [0, 1],
+        [2, 3]
+    ]) == [
+        [2, 0],
+        [3, 1]
+    ]
+
+'

06/generate_tasks.sh

@@ -101,19 +101,48 @@ def test_count_vowels():
     assert count_vowels("AEIOU") == 5
 '
 
-write_task_and_test "06" "count_vowels" '
-def count_vowels(s: str) -> int:
+write_task_and_test "06" "filter_by_age" '
+def filter_by_age(people: dict):
     """
-    Vrátí počet samohlásek v řetězci (a, e, i, o, u).
+    Napiš funkci filter_by_age, která vezme seznam slovníků, kde každý slovník
+    představuje osobu (s klíči name a age), a vrátí seznam osob, které jsou
+    starší než 18 let.
     """
 ' '
 import pytest
-from tasks.task_06_count_vowels import count_vowels
-
-def test_count_vowels():
-    assert count_vowels("hello") == 2
-    assert count_vowels("xyz") == 0
-    assert count_vowels("AEIOU") == 5
+from tasks.task_06_filter_by_age import filter_by_age
+
+def test_filter_by_age():
+    # Test pro seznam osob, kde některé mají věk nad 18
+    people = [
+        {"name": "Alice", "age": 20},
+        {"name": "Bob", "age": 17},
+        {"name": "Charlie", "age": 22},
+        {"name": "David", "age": 18}
+    ]
+    result = filter_by_age(people)
+    assert result == [
+        {"name": "Alice", "age": 20},
+        {"name": "Charlie", "age": 22},
+        {"name": "David", "age": 18}
+    ]
+
+    # Test pro prázdný seznam
+    assert filter_by_age([]) == []
+
+    # Test pro všechny osoby mladší než 18
+    people = [
+        {"name": "Eve", "age": 17},
+        {"name": "Frank", "age": 16}
+    ]
+    assert filter_by_age(people) == []
+
+    # Test pro všechny osoby starší než 18
+    people = [
+        {"name": "Grace", "age": 25},
+        {"name": "Hank", "age": 30}
+    ]
+    assert filter_by_age(people) == people
 '
 
 write_task_and_test "07" "reverse_string" '

06/tasks/task_06_count_vowels.py

@@ -0,0 +1,9 @@
+# task_06_filter_by_age.py
+
+def filter_by_age(people: dict):
+    """
+    Napiš funkci filter_by_age, která vezme seznam slovníků, kde každý slovník
+    představuje osobu (s klíči name a age), a vrátí seznam osob, které jsou
+    starší než 18 let.
+    """
+

06/tasks/task_06_filter_by_age.py

@@ -0,0 +1,7 @@
+# task_26_is_palindrome_sentence.py
+
+def is_palindrome_sentence(s: str) -> bool:
+    """
+    Vrátí True, pokud je věta palindrom (ignoruje mezery, interpunkci a velikost písmen).
+    """
+

06/tasks/task_26_is_palindrome_sentence.py

@@ -0,0 +1,7 @@
+# task_27_group_anagrams.py
+
+def group_anagrams(words: list[str]) -> list[list[str]]:
+    """
+    Skupiny anagramů v seznamu slov. Seznamy musí být seřazené. Anagramy v seznamech také seřazené.
+    """
+

06/tasks/task_27_group_anagrams.py

@@ -0,0 +1,7 @@
+# task_28_flatten_list.py
+
+def flatten_list(nested: list[list[int]]) -> list[int]:
+    """
+    Převede dvourozměrný seznam na jednorozměrný.
+    """
+