from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Prüfen Sie, ob in der angegebenen Zahlenliste zwei Zahlen näher beieinander liegen als
    der angegebene Schwellenwert.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Prüfen Sie, ob in der gegebenen Liste von Zahlen zwei beliebige Zahlen näher beieinander liegen als
    gegebenen Schwellenwert.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Überprüfen Sie, ob in der gegebenen Liste von Zahlen zwei Zahlen näher beieinander liegen als
    der angegebene Schwellenwert.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Die Eingabe für diese Funktion ist eine Zeichenfolge, die mehrere Gruppen verschachtelter Klammern enthält. Ihr Ziel ist es,
    diese Gruppen in separate Zeichenfolgen aufzuteilen und die Liste dieser zurückzugeben.
    Separate Gruppen sind ausgeglichen (jede öffnende Klammer ist ordnungsgemäß geschlossen) und nicht ineinander verschachtelt.
    Ignorieren Sie alle Leerzeichen in der Eingabezeichenfolge.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Die Eingabe für diese Funktion ist eine Zeichenfolge, die mehrere Gruppen von verschachtelten Klammern enthält. Ihr Ziel ist es,
    Ziel ist es, diese Gruppen in separate Zeichenfolgen zu trennen.
    Separate Gruppen sind ausgeglichen (jede Klammer ist korrekt geschlossen) und nicht ineinander verschachtelt
    Ignorieren Sie alle Leerzeichen in der Eingabezeichenfolge.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Die Eingabe für diese Funktion ist eine Zeichenkette mit mehreren Gruppen von verschachtelten Klammern. Ihr Ziel ist es
    diese Gruppen in einzelne Zeichenketten aufzuteilen und die Liste dieser Gruppen zurückzugeben.
    Getrennte Gruppen sind ausgeglichen (jede offene Klammer ist richtig geschlossen) und nicht ineinander verschachtelt
    Leerzeichen in der Eingabezeichenfolge werden ignoriert.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Gegeben eine positive Gleitkommazahl, kann man sie in einen
    ganzzahligen Teil (die größte ganze Zahl, die kleiner oder gleich der gegebenen Zahl ist) und Dezimalstellen
    (der verbleibende Teil, der immer kleiner als 1 ist) zerlegen.

    Gibt den Dezimalteil der Zahl zurück.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Eine positive Fließkommazahl kann zerlegt werden in
    und ganzzahligen Teil (größte ganze Zahl kleiner als die gegebene Zahl) und Dezimalzahlen
    (verbleibender Teil immer kleiner als 1).
    Gibt den Dezimalteil der Zahl zurück.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Bei einer positiven Gleitkommazahl kann sie in
    und ganzzahliger Teil (größte ganze Zahl, die kleiner als die Zahl ist) und den Dezimalteil
    (der immer kleiner als 1 ist).

    Gibt den Dezimalteil der Zahl zurück.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Sie erhalten eine Liste von Einzahlungs- und Abhebungsoperationen auf ein Bankkonto, das mit
    einem Nullsaldo beginnt. Ihre Aufgabe ist es zu erkennen, ob der Kontostand zu irgendeinem Zeitpunkt unter Null fällt, und
    in diesem Fall sollte die Funktion True zurückgeben. Andernfalls sollte sie False zurückgeben.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Sie erhalten eine Liste von Ein- und Auszahlungsvorgängen auf einem Bankkonto, die beginnt mit
    Nullsaldo. Ihre Aufgabe ist es, zu erkennen, ob der Kontostand zu irgendeinem Zeitpunkt unter Null fällt, und
    Zu diesem Zeitpunkt sollte die Funktion True zurückgeben. Andernfalls sollte False zurückgegeben werden.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Sie erhalten eine Liste von Ein- und Auszahlungsvorgängen für ein Bankkonto, das mit
    Saldo Null. Ihre Aufgabe ist es, zu erkennen, ob der Kontostand zu irgendeinem Zeitpunkt unter Null fällt, und
    zu diesem Zeitpunkt sollte die Funktion True zurückgeben. Andernfalls sollte sie False zurückgeben.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Berechnen Sie für eine gegebene Liste von Eingabezahlen die mittlere absolute Abweichung
    um den Mittelwert dieses Datensatzes.
    Die mittlere absolute Abweichung ist die durchschnittliche absolute Differenz zwischen jedem
    Element und einem Mittelpunkt (in diesem Fall der Mittelwert):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Für eine gegebene Liste von Zahlen als Eingabe die Mittlere Absolute Abweichung
    um den Mittelwert dieses Datensatzes berechnen.
    Die Mittlere Absolute Abweichung ist die durchschnittliche absolute Differenz zwischen jedem
    Element und einem zentralen Punkt (Mittelwert in diesem Fall):
    MAA = Mittelwert | x - x_mittel |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Für eine gegebene Liste von Eingabezahlen berechnen Sie die mittlere absolute Abweichung
    um den Mittelwert dieses Datensatzes.
    Die mittlere absolute Abweichung ist die durchschnittliche absolute Differenz zwischen jedem
    -Element und einen Mittelpunkt (in diesem Fall Mittelwert):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Füge zwischen jeweils zwei aufeinanderfolgenden Elementen der Eingabeliste `numbers' ein Zahlen-'Trennzeichen' ein
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Einfügen einer Zahl 'delimeter' zwischen jeweils zwei aufeinanderfolgenden Elementen der Eingabeliste `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Fügen Sie eine Zahl 'delimeter' zwischen jeweils zwei aufeinanderfolgenden Elementen der Eingabeliste 'Zahlen' ein
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Die Eingabe für diese Funktion ist eine Zeichenfolge, die mehrere Gruppen für verschachtelte Klammern darstellt, die durch Leerzeichen getrennt sind.
    Geben Sie für jede Gruppe die tiefste Verschachtelungsebene der Klammern aus.
    Zum Beispiel hat (()()) maximal zwei Verschachtelungsebenen, während ((())) drei hat.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Die Eingabe für diese Funktion ist eine Zeichenfolge, die mehrere Gruppen für verschachtelte Klammern darstellt, die durch Leerzeichen getrennt sind.
    Geben Sie für jede Gruppe die tiefste Verschachtelungsebene der Klammern aus.
    Z.B. hat (()()) maximal zwei Verschachtelungsebenen, während ((())) drei hat.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Eingabe für diese Funktion ist eine Zeichenkette, die mehrere Gruppen für verschachtelte Klammern darstellt, die durch Leerzeichen getrennt sind.
    Geben Sie für jede Gruppe die tiefste Verschachtelungsebene der Klammern aus.
    Z. B. hat (()()) maximal zwei Verschachtelungsebenen, während ((())) drei hat.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Eine Eingabeliste von Zeichenketten nur nach solchen filtern, die eine bestimmte Teilzeichenkette enthalten
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtert eine Liste von Eingabestrings nur nach denen, die die gegebene Teilzeichenfolge enthalten
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtert eine Eingabeliste von Strings nur nach denen, die den angegebenen Teilstring enthalten
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Für eine gegebene Liste von ganzen Zahlen gibt die Funktion ein Tupel zurück, das aus der Summe und dem Produkt aller Zahlen in der Liste besteht.
    Die leere Summe muss gleich 0 sein und das leere Produkt muss gleich 1 sein.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Für eine gegebene Liste von ganzen Zahlen ein Tupel zurückgeben, das aus einer Summe und einem Produkt aller ganzen Zahlen in einer Liste besteht.
    Die leere Summe sollte gleich 0 sein und das leere Produkt sollte gleich 1 sein.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Für eine gegebene Liste von Ganzzahlen wird ein Tupel zurückgegeben, das aus einer Summe und einem Produkt aller Ganzzahlen in einer Liste besteht.
    Die leere Summe sollte gleich 0 und das leere Produkt gleich 1 sein.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Erstellen Sie aus einer gegebenen Liste von ganzen Zahlen eine Liste der rollierenden maximalen Elemente, die bis zu einem bestimmten Zeitpunkt
    in der Sequenz gefunden wurden.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Aus einer gegebenen Liste von ganzen Zahlen wird eine Liste des bisher gefundenen maximalen Elements
    in der Sequenz erzeugt.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """
    Aus einer gegebenen Liste von ganzen Zahlen wird eine Liste der maximalen Elemente bis zu jedem Punkt
    in der Sequenz erzeugt.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Prüft, ob die gegebene Zeichenkette ein Palindrom ist """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Ermittelt das kürzeste Palindrom, das mit der gegebenen Zeichenkette beginnt.
    Die Idee des Algorithmus ist einfach:
    - Finde das längste Suffix der gegebenen Zeichenkette, das ein Palindrom ist.
    - Füge am Ende der Zeichenkette das umgekehrte Präfix der Zeichenkette hinzu, das vor dem palindromischen Suffix kommt.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Testet, ob die gegebene Zeichenkette ein Palindrom ist """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Findet das kürzeste Palindrom, das mit einer gegebenen Zeichenkette beginnt.
    Die Idee des Algorithmus ist einfach:
    - Finde das längste Suffix der gegebenen Zeichenkette, das ein Palindrom ist.
    - Füge am Ende der Zeichenkette das umgekehrte Präfix der Zeichenkette hinzu, das vor dem palindromischen Suffix kommt.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Testen, ob die angegebene Zeichenkette ein Palindrom ist """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Ermitteln Sie das kürzeste Palindrom, das mit einer angegebenen Zeichenkette beginnt.
    Die Idee des Algorithmus ist einfach:
    - Sucht das längste Postfix der bereitgestellten Zeichenfolge, bei dem es sich um ein Palindrom handelt.
    - Hängt an das Ende der Zeichenkette die Umkehrung eines Zeichenfolgenpräfixes an, das vor dem palindromischen Suffix steht.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ Die Eingaben sind zwei Zeichenketten a und b, die nur aus 1 und 0 bestehen.
    Führt ein binäres XOR auf diesen Eingaben aus und gibt das Ergebnis ebenfalls als Zeichenfolge zurück.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Als Eingabe dienen zwei Zeichenfolgen a und b, die nur aus Einsen und Nullen bestehen.
    Führen Sie ein binäres XOR auf diese Eingaben aus und geben Sie das Ergebnis ebenfalls als Zeichenfolge zurück.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Eingabe sind zwei Strings a und b, die nur aus 1en und 0en bestehen.
    Führe eine binäre XOR-Verknüpfung dieser Eingaben durch und gib das Ergebnis ebenfalls als String zurück.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Aus der Liste der Zeichenketten die längste zurückgeben. Bei mehreren Zeichenketten gleicher Länge die erste zurückgeben.
    „None“ zurückgeben, wenn die Eingabeliste leer ist.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Aus der Liste der Zeichenfolgen gibt die längste zurück. Gibt die erste zurück, wenn mehrere
    Zeichenfolgen gleicher Länge. Gibt None zurück, falls die Eingabeliste leer ist.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Aus der Liste der Strings wird der längste zurückgegeben. Bei mehreren
    Strings gleicher Länge wird der erste zurückgegeben. Bei leerer Eingabeliste wird None zurückgegeben.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """


def greatest_common_divisor(a: int, b: int) -> int:
    """ Gibt den größten gemeinsamen Teiler (ggT) der beiden ganzen Zahlen a und b zurück
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Liefert den größten gemeinsamen Teiler zweier Ganzzahlen a und b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Gibt den größten gemeinsamen Teiler zweier ganzer Zahlen a und b zurück
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """
    Gibt eine Liste aller Präfixe, vom kürzesten zum längsten, des gegebenen Strings zurück.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Gibt eine Liste aller Präfixe vom kürzesten bis zum längsten der Eingabezeichenfolge zurück
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Rückgabe der Liste aller Präfixe von der kürzesten bis zur längsten Länge der Eingabezeichenfolge
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Gibt eine Zeichenkette mit durch Leerzeichen getrennten Zahlen von 0 bis einschließlich n zurück.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Gibt eine Zeichenkette zurück, die durch Leerzeichen getrennte Zahlen von 0 bis einschließlich n enthält.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Gibt einen String zurück, der durch Leerzeichen getrennte Zahlen enthält, beginnend bei 0 bis einschließlich n.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Finden Sie bei einer gegebenen Zeichenfolge heraus, aus wie vielen unterschiedlichen Zeichen (unabhängig von der Groß-/Kleinschreibung) diese besteht.
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Gegeben eine Zeichenkette, bestimmt, wie viele verschiedene Zeichen (unabhängig von Groß- oder Kleinschreibung) sie enthält
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Finden Sie anhand einer Zeichenkette heraus, aus wie vielen verschiedenen Zeichen (unabhängig von der Groß-/Kleinschreibung) sie besteht.
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Der Eingang dieser Funktion ist eine Zeichenkette, die musikalische Noten in einem speziellen ASCII-Format darstellt.
    Ihre Aufgabe ist es, diese Zeichenkette zu analysieren und eine Liste von ganzen Zahlen zurückzugeben, die angeben,
    wie lange jede Note dauert.

    Hier ist die Legende:
    'o' - ganze Note, dauert vier Schläge
    'o|' - halbe Note, dauert zwei Schläge
    '.|' - Viertelnote, dauert einen Schlag

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Die Eingabe für diese Funktion ist eine Zeichenfolge, die Musiknoten in einem speziellen ASCII-Format darstellt.
    Ihre Aufgabe besteht darin, diese Zeichenfolge zu analysieren und eine Liste von Ganzzahlen zurückzugeben, die der Anzahl der Schläge entsprechen, die jeder
    nicht dauert.

    Hier ist eine Legende:
    'o' – ganze Note, dauert vier Schläge
    'o|' – halbe Note, dauert zwei Schläge
    '.|' – Viertelnote, dauert einen Schlag

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Die Eingabe für diese Funktion ist eine Zeichenkette, die Musiknoten in einem speziellen ASCII-Format darstellt.
    Ihre Aufgabe ist es, diese Zeichenkette zu analysieren und eine Liste von Ganzzahlen zurückzugeben, die der Anzahl der Schläge entsprechen.
    Nicht zuletzt.

    Hier ist eine Legende:
    'o' - ganze Note, dauert vier Schläge
    'o|' - halbe Note, dauert zwei Schläge
    '.|' - Viertelnote, dauert einen Schlag

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ Ermitteln, wie oft eine bestimmte Teilzeichenkette in der ursprünglichen Zeichenkette gefunden werden kann. Zählen Sie überlappende Fälle.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Finde heraus, wie oft eine gegebene Teilzeichenfolge in der Originalzeichenfolge vorkommt. Zähle überlappende Fälle.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Findet heraus, wie oft ein gegebenes Teilstring im Originalstring gefunden werden kann. Zählt überlappende Fälle.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ Die Eingabe ist eine durch Leerzeichen getrennte Zeichenkette mit Zahlwörtern von ‘zero’ bis ‘nine’.
    Gültige Optionen sind 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' und 'nine'.
    Gibt die Zeichenkette mit den Zahlen sortiert von klein nach groß zurück
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Die Eingabe ist eine durch Leerzeichen getrennte Folge von Ziffern von 'zero' bis 'nine'.
    Gültige Auswahlmöglichkeiten sind 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' und 'nine'.
    Geben Sie die Zeichenfolge mit den Zahlen in aufsteigender Reihenfolge zurück.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Die Eingabe ist eine durch Leerzeichen getrennte Zeichenkette von Zahlen von 'zero' bis 'nine'.
    Gültige Optionen sind 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' und 'nine'.
    Gibt die Zeichenkette mit den Zahlen sortiert von klein nach groß zurück
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Wählen Sie aus einer vorgegebenen Liste von Zahlen (mit einer Länge von mindestens zwei) zwei aus, die einander am nächsten liegen, und geben Sie sie
    in der Reihenfolge (kleinere Zahl, größere Zahl) zurück.
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Aus einer gegebenen Liste von Zahlen (mit einer Länge von mindestens zwei) wählt und gibt zwei zurück, die
    einander am nächsten sind, und gibt sie in der Reihenfolge (kleinere Zahl, größere Zahl) zurück.
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Aus einer bereitgestellten Liste von Zahlen (mit einer Länge von mindestens zwei) werden die zwei Zahlen ausgewählt und zurückgegeben, die am nächsten beieinander liegen
    und in der Reihenfolge zurückgegeben (kleinere Zahl, größere Zahl).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Wenden Sie bei einer gegebenen Liste von Zahlen (von mindestens zwei Elementen) eine lineare Transformation auf diese Liste an,
    so dass die kleinste Zahl zu 0 und die größte zu 1 wird
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Gegebene Liste von Zahlen (mit mindestens zwei Elementen), wenden Sie eine lineare Transformation auf diese Liste an,
    sodass die kleinste Zahl 0 und die größte 1 wird
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Wenden Sie bei einer Liste von Zahlen (mit mindestens zwei Elementen) eine lineare Transformation auf diese Liste an,
    so dass die kleinste Zahl zu 0 und die größte zu 1 wird
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtert die gegebene Liste von beliebigen Python-Werten nur für ganze Zahlen
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtern Sie die angegebene Liste beliebiger Python-Werte nur für Ganzzahlen
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtern einer Liste beliebiger Python-Werte nur nach ganzen Zahlen
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Gibt die Länge der angegebenen Zeichenkette zurück
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Gibt die Länge des angegebenen Strings zurück
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Gibe die Länge der gegebenen Zeichenkette zurück
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Für eine gegebene Zahl n, finde die größte Zahl, die n gleichmäßig teilt und kleiner als n ist
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Für eine gegebene Zahl n, finde die größte Zahl, die n ohne Rest teilt und kleiner als n ist.
    >>> groesster_teiler(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Für eine gegebene Zahl n, finde die größte Zahl, die n genau teilt, kleiner als n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Gibt eine Liste der Primfaktoren der angegebenen Ganzzahl in der Reihenfolge vom kleinsten zum größten zurück.
    Jeder der Faktoren sollte so oft aufgeführt werden, wie er in der Faktorisierung vorkommt.
    Die Eingabezahl sollte dem Produkt aller Faktoren entsprechen.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Gibt eine Liste der Primfaktoren der gegebenen Zahl in aufsteigender Reihenfolge zurück.
    Jeder Faktor muss so oft erscheinen, wie er in der Faktorisierung vorkommt.
    Die Eingabezahl muss gleich dem Produkt aller Faktoren sein.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Gibt die Liste der Primfaktoren der gegebenen ganzen Zahl in der Reihenfolge vom kleinsten zum größten zurück.
    Jeder der Faktoren sollte so oft aufgeführt werden, wie er in der Faktorisierung vorkommt.
    Die Eingabezahl sollte gleich dem Produkt aller Faktoren sein
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Aus einer Liste von ganzen Zahlen werden alle Elemente entfernt, die mehr als einmal vorkommen.
    Behält die Reihenfolge der verbleibenden Elemente bei, wie sie im Eingang ist.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Aus einer Liste von Ganzzahlen alle Elemente entfernen, die mehr als einmal vorkommen.
    Die Reihenfolge der verbleibenden Elemente muss dieselbe sein wie in der Eingabe.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Aus einer Liste von ganzen Zahlen alle Elemente entfernen, die mehr als einmal vorkommen.
    Die Reihenfolge der übrig gebliebenen Elemente muss die gleiche sein wie in der Eingabe.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Für eine gegebene Zeichenfolge Kleinbuchstaben in Großbuchstaben und Großbuchstaben in Kleinbuchstaben umwandeln.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Für eine bestimmte Zeichenfolge werden Kleinbuchstaben in Großbuchstaben und Großbuchstaben in Kleinbuchstaben umgewandelt.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Für eine gegebene Zeichenkette werden Kleinbuchstaben in Großbuchstaben und Großbuchstaben in Kleinbuchstaben umgewandelt.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Verkettet eine Liste von Zeichenketten zu einer einzigen Zeichenkette.
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Liste von Strings zu einem einzigen String verketten
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Verknüpfen Sie eine Liste von Zeichenketten zu einer einzigen Zeichenkette
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtert eine Eingabeliste von Zeichenfolgen nur nach solchen, die mit einem bestimmten Präfix beginnen.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Eine Eingabeliste von Zeichenketten nur nach solchen filtern, die mit einem bestimmten Präfix beginnen.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Gibt nur die positiven Zahlen in der Liste zurück.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """Gibt nur positive Zahlen in der Liste zurück.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """Gibt True zurück, wenn eine gegebene Zahl eine Primzahl ist, andernfalls False.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Gibt true zurück, wenn eine gegebene Zahl eine Primzahl ist, und andernfalls false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Gibt true zurück, wenn eine gegebene Zahl eine Primzahl ist, andernfalls false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Bewertet das Polynom mit den Koeffizienten xs an der Stelle x.
    gibt xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n zurück
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sind die Koeffizienten eines Polynoms.
    find_zero findet x, so dass poly(x) = 0.
    find_zero gibt nur eine Nullstelle zurück, auch wenn es mehrere gibt.
    Außerdem nimmt find_zero nur die Liste xs mit einer geraden Anzahl von Koeffizienten
    und dem größten nicht null Koeffizienten, da dies eine Lösung garantiert.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Bewertet das Polynom mit den Koeffizienten xs im Punkt x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sind Koeffizienten eines Polynoms.
    find_zero findet x, so dass poly(x) = 0.
    find_zero gibt nur eine Nullstelle zurück, auch wenn es mehrere gibt.
    Außerdem nimmt find_zero nur die Liste xs mit einer geraden Anzahl von Koeffizienten
    und den größten Nicht-Null-Koeffizienten, da dies eine
    eine Lösung garantiert.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Bewertet das Polynom mit den Koeffizienten xs am Punkt x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sind Koeffizienten eines Polynoms.
    find_zero findet x so, dass poly(x) = 0 ist.
    find_zero gibt nur einen Nullpunkt zurück, auch wenn es viele sind.
    Darüber hinaus nimmt find_zero nur die Liste xs mit der geraden Anzahl von Koeffizienten
    und den größten Koeffizienten ungleich Null, da er
    eine Lösung garantiert.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine Liste l' zurück, so dass
    l' in den Indizes, die nicht durch drei teilbar sind, mit l identisch ist, während seine Werte in den Indizes, die durch drei teilbar sind, gleich
    den Werten der entsprechenden Indizes von l sind, aber sortiert.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine solche Liste l' zurück, dass
    l' in den Indizes, die nicht durch drei teilbar sind, mit l identisch ist, während ihre Werte in den Indizes, die durch drei teilbar sind, gleich sind
    mit den Werten der entsprechenden Indizes von l übereinstimmen, jedoch sortiert sind.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine Liste l' zurück, so dass
    l' ist in den Indizes, die nicht durch drei teilbar sind, identisch mit l, während seine Werte bei den Indizes, die durch drei teilbar sind,
    den Werten der entsprechenden Indizes in l entsprechen, aber sortiert sind.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Gibt die eindeutigen, sortierten Elemente in einer Liste zurück
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Gibt sortierte eindeutige Elemente in einer Liste zurück
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Sortierte, eindeutige Elemente in einer Liste zurückgeben
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Gibt das maximale Element in der Liste zurück.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """Das maximale Element in der Liste zurückgeben.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Gibt die Anzahl der Male zurück, die die Ziffer 7 in den ganzen Zahlen erscheint, die kleiner als n sind und durch 11 oder 13 teilbar sind.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Geben Sie die Anzahl der Vorkommen der Ziffer 7 in ganzen Zahlen kleiner als n an, die durch 11 oder 13 teilbar sind.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Gibt die Anzahl zurück, mit der die Ziffer 7 in ganzen Zahlen kleiner als n vorkommt, die durch 11 oder 13 teilbar sind.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine Liste l' zurück, sodass
    l' in den ungeraden Indizes mit l identisch ist, während die Werte in den geraden Indizes
    den Werten der geraden Indizes von l entsprechen, aber sortiert sind.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine Liste l' zurück, so dass
    l' an den ungeraden Indizes identisch mit l ist, während die Werte an den
    geraden Indizes den Werten der geraden Indizes von l entsprechen, jedoch sortiert sind.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Diese Funktion nimmt eine Liste l und gibt eine Liste l' zurück, so dass
    l' in den ungeraden Indizes identisch mit l ist, während seine Werte in den geraden Indizes gleich
    den Werten der geraden Indizes von l sind, aber sortiert.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    Gibt eine codierte Zeichenkette zurück, indem Gruppen von drei Zeichen zyklisch verschoben werden.
    """
    # Zeichenkette in Gruppen aufteilen. Jede Gruppe hat eine Länge von 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Elemente in jeder Gruppe zyklisch verschieben. Es sei denn, die Gruppe hat weniger als 3 Elemente.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Nimmt eine mit der Funktion „encode_cyclic“ codierte Eingabezeichenfolge. Gibt eine decodierte Zeichenfolge zurück.
    """

def encode_cyclic(s: str):
    """
    Gibt die codierte Zeichenfolge zurück, indem Gruppen von drei Zeichen zyklisch verschoben werden.
    """
    # String in Gruppen aufteilen. Jeder der Länge 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Zykluselemente in jeder Gruppe. Es sei denn, die Gruppe enthält weniger Elemente als 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Nimmt als Eingabezeichenfolge an, die mit encode_cyclic Funktion codiert ist. Gibt eine decodierte Zeichenfolge zurück.
    """

def encode_cyclic(s: str):
    """
    Gibt den kodierten String zurück, indem Gruppen von drei Zeichen rotiert werden.
    """
    # Teilt den String in Gruppen auf. Jede Gruppe hat eine Länge von 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Zykelt die Elemente in jeder Gruppe. Außer wenn die Gruppe weniger als 3 Elemente hat.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Nimmt einen mit der encode_cyclic-Funktion kodierten String als Eingabe. Gibt den dekodierten String zurück.
    """


def prime_fib(n: int):
    """
    prime_fib gibt die n-te Zahl zurück, die eine Fibonacci-Zahl und außerdem eine Primzahl ist.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib gibt die n-te Zahl zurück, die eine Fibonacci-Zahl ist und auch eine Primzahl ist.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib gibt die n-te Zahl zurück, die eine Fibonacci-Zahl ist und auch eine Primzahl.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero verwendet eine Liste von Ganzzahlen als Eingabe.
    Es gibt True zurück, wenn es in der Liste drei verschiedene Elemente gibt,
    deren Summe Null ergibt, andernfalls False.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero nimmt eine Liste von ganzen Zahlen als Eingabe.
    Es gibt „True“ zurück, wenn es drei verschiedene Elemente in der Liste gibt, deren
    Summe Null ergibt, und andernfalls „False“.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero nimmt eine Liste von ganzen Zahlen als Eingabe.
    Gibt True zurück, wenn es drei verschiedene Elemente in der Liste gibt, die
    zu null addieren, und False andernfalls.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    Stellen Sie sich eine Straße vor, die eine vollkommen gerade, unendlich lange Linie ist.
    n Autos fahren von links nach rechts; gleichzeitig fährt eine andere Gruppe von n Autos
    von rechts nach links. Die beiden Gruppen von Autos sind anfangs sehr weit voneinander
    entfernt. Alle Autos bewegen sich mit der gleichen Geschwindigkeit. Zwei Autos kollidieren,
    wenn ein Auto, das sich von links nach rechts bewegt, ein Auto trifft, das sich von rechts nach links bewegt.
    Die Autos sind jedoch unendlich robust und stark; daher bewegen sie sich
    weiter auf ihrer Flugbahn, als ob sie nicht kollidiert wären.

    Diese Funktion gibt die Anzahl solcher Kollisionen aus.
    """

def car_race_collision(n: int):
    """
    Stellen Sie sich eine Straße vor, die eine perfekt geradlinige, unendlich lange Linie ist.
    n Autos fahren von links nach rechts;  Gleichzeitig wird ein anderer Satz von n Wagen
    von rechts nach links fahren.   Die beiden Autogruppen sind zu Beginn sehr weit voneinander entfernt
    Gegenseitig.  Alle Autos bewegen sich im gleichen Tempo.  Zwei Autos sollen kollidieren
    Wenn ein Auto, das sich von links nach rechts bewegt, auf ein Auto trifft, das sich von rechts nach links bewegt.
    Die Autos sind jedoch unendlich robust und stark; Infolgedessen bewegen sie sich weiter
    in ihrer Flugbahn, als ob sie nicht kollidiert wären.

    Diese Funktion gibt die Anzahl solcher Kollisionen aus.
    """

def car_race_collision(n: int):
    """
    Stellen Sie sich eine Straße vor, die eine perfekt gerade, unendlich lange Linie ist.
    n Autos fahren von links nach rechts; gleichzeitig fährt eine andere Gruppe von n Autos
    von rechts nach links. Die beiden Gruppen von Autos sind zu Beginn sehr weit voneinander entfernt.
    Alle Autos bewegen sich mit der gleichen Geschwindigkeit. Zwei Autos kollidieren,
    wenn ein Auto, das sich von links nach rechts bewegt, auf ein Auto trifft, das sich von rechts nach links bewegt.
    Die Autos sind jedoch unendlich robust und stark, sodass sie sich
    in ihrer Flugbahn weiterbewegen, als ob sie nicht kollidiert wären.

    Diese Funktion gibt die Anzahl solcher Kollisionen aus.
    """


def incr_list(l: list):
    """Gibt eine Liste mit um 1 inkrementierten Elementen zurück.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Gibt eine Liste zurück mit um 1 inkrementierten Elementen.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Liste mit um 1 erhöhten Elementen zurückgeben.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero nimmt eine Liste von ganzen Zahlen als Eingabe.
    Es gibt True zurück, wenn es zwei unterschiedliche Elemente in der Liste gibt, die eine Summe von Null ergibt.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero nimmt eine Liste von Ganzzahlen als Eingabe.
    Gibt True zurück, wenn es zwei verschiedene Elemente in der Liste gibt, deren Summe Null ergibt, und False andernfalls.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero verwendet eine Liste von Ganzzahlen als Eingabe.
    Es gibt True zurück, wenn es in der Liste zwei verschiedene Elemente gibt,
    deren Summe Null ergibt, andernfalls False.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False


def change_base(x: int, base: int):
    """Ändert die numerische Basis der Eingabezahl x zur angegebenen Basis.
    Gibt die Zeichenkettenrepräsentation nach der Umwandlung zurück.
    Die Basisziffern sind kleiner als 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Ändere die numerische Basis der Eingabezahl x in Basis.
    Gibt die Stringdarstellung nach der Konvertierung zurück.
    Basiszahlen sind kleiner als 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Ändere die numerische Basis der Eingangszahl x in Basis.
    Rückgabe der Zeichenkette nach der Konvertierung.
    Basiszahlen sind kleiner als 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Gegeben die Länge einer Seite und die Höhe, gibt die Fläche eines Dreiecks zurück.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Gegeben die Länge einer Seite und die Höhe, gibt die Funktion die Fläche eines Dreiecks zurück.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Die Zahlenfolge Fib4 ist eine Sequenz, die der Fibbonacci-Folge ähnelt und wie folgt definiert ist:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Bitte schreiben Sie eine Funktion, um das n-te Element der Zahlenfolge fib4 effizient zu berechnen.  Verwenden Sie keine Rekursion.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Die Fib4-Zahlenfolge ist eine der Fibbonacci-Folge ähnliche Folge, die wie folgt definiert ist:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Bitte schreiben Sie eine Funktion, um das n-te Element der Fib4-Zahlenfolge effizient zu berechnen. Verwenden Sie keine Rekursion.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Die Fib4-Zahlenfolge ist eine der Fibbonacci-Sequenz ähnliche Folge, die wie folgt definiert ist:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Schreiben Sie eine Funktion zur effizienten Berechnung des n-ten Elements der Zahlenfolge fib4.  Verwenden Sie keine Rekursion.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Gibt den Median der Elemente in der Liste l zurück.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Median der Elemente in der Liste l zurückgeben.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Überprüft, ob die angegebene Zeichenfolge ein Palindrom ist
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Überprüft, ob die gegebene Zeichenkette ein Palindrom ist
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Prüft, ob die angegebene Zeichenkette ein Palindrom ist
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Gibt 2^n modulo p zurück (achten Sie auf numerische Werte).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Gib 2^n modulo p zurück (achten Sie auf Zahlen).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Gibt 2^n modulo p zurück (Zahlen beachten).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    gibt eine kodierte Zeichenkette zurück, indem jedes Zeichen im Alphabet um 5 verschoben wird.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    nimmt als Eingabe eine mit der Funktion encode_shift kodierte Zeichenkette. Gibt dekodierte Zeichenkette zurück.
    """

def encode_shift(s: str):
    """
    gibt eine kodierte Zeichenkette zurück, indem jeder Buchstabe um 5 Positionen im Alphabet verschoben wird.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    nimmt eine mit der Funktion encode_shift kodierte Zeichenkette als Eingabe. Gibt die dekodierte Zeichenkette zurück.
    """

def encode_shift(s: str):
    """
    Gibt eine codierte Zeichenfolge zurück, indem jedes Zeichen im Alphabet um 5 verschoben wird.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) für ch in s])

def decode_shift(s: str):
    """
    Nimmt als Eingabezeichenfolge an, die mit encode_shift Funktion codiert ist. Gibt eine decodierte Zeichenfolge zurück.
    """


def remove_vowels(text):
    """
    remove_vowels ist eine Funktion, die eine Zeichenkette akzeptiert und eine Zeichenkette ohne Vokale zurückgibt.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels ist eine Funktion, die einen String annimmt und einen String ohne Vokale zurückgibt.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels ist eine Funktion, die eine Zeichenkette nimmt und eine Zeichenkette ohne Vokale zurückgibt.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Gibt True zurück, wenn alle Zahlen in der Liste l unter dem Schwellenwert t liegen.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Gibt True zurück, wenn alle Zahlen in der Liste l unterhalb des Schwellenwerts t liegen.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Addiere zwei Zahlen x und y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Zwei Zahlen x und y addieren
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Überprüft, ob zwei Wörter die gleichen Zeichen haben.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    Überprüft, ob zwei Wörter die gleichen Zeichen enthalten.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Gibt die n-te Fibonacci-Zahl zurück.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets ist eine Zeichenkette aus "<" und ">".
    gibt True zurück, wenn jede öffnende Klammer eine entsprechende schließende Klammer hat.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    "" Klammern sind eine Zeichenfolge aus "<" und ">".
    Gibt True zurück, wenn jede öffnende Klammer eine entsprechende schließende Klammer hat.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets ist eine Zeichenkette aus „<“ und „>“.
    return True, wenn jede öffnende Klammer eine entsprechende schließende Klammer hat.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """Gibt True zurück, wenn die Elemente der Liste monoton steigend oder fallend sind.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Gibt True zurück, wenn die Listenelemente monoton steigend oder fallend sind.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Gibt die gemeinsamen, einzigartigen, sortierten Elemente für zwei Listen zurück.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Gibt sortierte eindeutige gemeinsame Elemente für zwei Listen zurück.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Sortierte, eindeutige gemeinsame Elemente für zwei Listen zurückgeben.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Gibt den größten Primfaktor von n zurück. Angenommen, n > 1 und n ist keine Primzahl.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Rückgabe des größten Primfaktors von n. Angenommen, n > 1 und ist keine Primzahl.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Gebe den größten Primfaktor von n zurück. Angenommen, n > 1 und n ist keine Primzahl.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n ist eine Funktion, die Zahlen von 1 bis n summiert.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n ist eine Funktion, die die Zahlen von 1 bis n addiert.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets ist eine Zeichenkette aus "(" und ")".
    gibt True zurück, wenn jede öffnende Klammer eine entsprechende schließende Klammer hat.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ Klammern sind ein String von „(“ und „)“.
    Gibt „True“ zurück, wenn jede öffnende Klammer eine entsprechende schließende Klammer hat.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ xs repräsentiert die Koeffizienten eines Polynoms.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Gibt die Ableitung dieses Polynoms in derselben Form zurück.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs stellen Koeffizienten eines Polynoms dar.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Die Ableitung dieses Polynoms in derselben Form zurückgeben.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """Die FibFib-Zahlenfolge ist eine Folge, die der Fibonacci-Folge ähnelt und wie folgt definiert ist:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Bitte schreiben Sie eine Funktion, um das n-te Element der FibFib-Zahlenfolge effizient zu berechnen.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Die FibFib-Zahlenfolge ist eine Sequenz, die der Fibbonacci-Folge ähnelt und wie folgt definiert ist:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Bitte schreiben Sie eine Funktion, um das n-te Element der Fibfib-Zahlenfolge effizient zu berechnen.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Die FibFib-Zahlenfolge ist eine der Fibbonacci-Folge ähnliche Folge, die wie folgt definiert ist:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Bitte schreiben Sie eine Funktion, um das n-te Element der Fibfib-Zahlenfolge effizient zu berechnen.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Fügen Sie weitere Testfälle hinzu.
"""

def vowels_count(s):
    """Schreiben Sie eine Funktion vowels_count, die eine Zeichenkette, die
    ein Wort darstellt, als Eingabe entgegennimmt und die Anzahl der Vokale in der Zeichenkette zurückgibt.
    Vokale sind in diesem Fall 'a', 'e', 'i', 'o', 'u'. 'y' ist hier auch ein
    Vokal, aber nur, wenn es am Ende des gegebenen Wortes steht.

    Beispiel:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Add more test cases.
"""

def vowels_count(s):
    """Schreiben Sie eine Funktion vowels_count die eine Zeichenkette annimmt, die
    Ein Wort als Eingabe und gibt die Anzahl der Vokale in der Zeichenkette zurück.
    Vokale sind in diesem Fall 'a', 'e', 'i', 'o', 'u'. Hier ist 'y' auch ein
    Vokal, aber nur, wenn er am Ende des gegebenen Wortes steht.

    Beispiel:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Fügen Sie mehr Testfälle hinzu.
"""

def vowels_count(s):
    """Schreiben Sie eine Funktion vowels_count, die eine Zeichenkette,
    die ein Wort darstellt, als Eingabe nimmt und die Anzahl der Vokale
    in der Zeichenkette zurückgibt. Die Vokale in diesem Fall sind 'a',
    'e', 'i', 'o', 'u'. Hier ist 'y' auch ein Vokal, aber nur, wenn es
    am Ende des gegebenen Wortes steht.

    Beispiel:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """zyklische Verschiebung der Ziffern der ganzen Zahl x, Verschiebung der Ziffern um shift Stellen nach rechts
    und das Ergebnis als Zeichenkette zurückgeben.
    Wenn shift größer als die Anzahl der Ziffern ist, werden die Ziffern umgekehrt zurückgegeben.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    ""Verschiebt die Ziffern der Ganzzahl x kreisförmig, verschiebt die Ziffern um shift nach rechts
    und gibt das Ergebnis als Zeichenfolge zurück.
    Wenn shift > Anzahl der Ziffern, gibt die Ziffern umgekehrt zurück.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Zirkulare Verschiebung der Ziffern der Ganzzahl x, Verschiebung der Ziffern nach rechts um shift
    und Rückgabe des Ergebnisses als string.
    Wenn shift größer als die Anzahl der Ziffern ist, gibt die Ziffern in umgekehrter Reihenfolge zurück.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Aufgabe
    Schreiben Sie eine Funktion, die eine Zeichenkette als Eingabe nimmt und die Summe der ASCII-Codes
    nur der Großbuchstaben zurückgibt.

    Beispiele:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Aufgabe
    Schreiben Sie eine Funktion, die eine Zeichenkette als Eingabe verwendet und nur die Summe der Großbuchstaben zurückgibt.
    ASCII codes.

    Beispiele:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s, n):
    """
    In dieser Aufgabe erhalten Sie eine Zeichenkette, die die Anzahl von Äpfeln und Orangen
    darstellt, die in einem Obstkorb enthalten sind. Dieser Korb enthält
    Äpfel, Orangen und Mangos. Gegeben ist die Zeichenkette, die die Gesamtzahl
    der Äpfel und Orangen angibt, sowie eine ganze Zahl, die die Gesamtzahl der Früchte
    im Korb darstellt. Geben Sie die Anzahl der Mangos im Korb zurück.

    Zum Beispiel:
    fruit_distribution("5 apples and 6 oranges", 19) -> 19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges", 3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 orange", 120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    In dieser Aufgabe erhalten Sie eine Zeichenkette, die eine Anzahl von Äpfeln und Orangen
    darstellt, die in einem Obstkorb befinden . Dieser Korb enthält
    Äpfel, Orangen und Mangos. Gegeben ist die Zeichenkette, die die Gesamtzahl der
    Orangen und Äpfel darstellt, und eine ganze Zahl, die die Gesamtzahl der Früchte
    im Korb darstellt, gibt die Anzahl der Mangos im Korb zurück.
    zum Beispiel:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    In dieser Aufgabe erhalten Sie eine Zeichenfolge, die eine Anzahl von Äpfeln und Orangen darstellt,
    die in einem Obstkorb verteilt sind. Dieser Korb enthält
    Äpfel, Orangen und Mangofrüchte. Aus der Zeichenfolge, die die Gesamtzahl
    der Orangen und Äpfel darstellt, und einer Ganzzahl, die die Gesamtzahl
    der Früchte im Korb darstellt, wird die Anzahl der Mangofrüchte im Korb zurückgegeben.
    Zum Beispiel:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Angenommen, Sie haben ein Array, das einen Ast eines Baumes mit nicht-negativen ganzen Zahlen als Knoten darstellt.
    Ihre Aufgabe ist es, einen der Knoten zu „pflücken“ und zurückzugeben.
    Der „gepflückte“ Knoten sollte der Knoten mit dem kleinsten geraden Wert sein.
    Falls mehrere Knoten mit demselben kleinsten geraden Wert vorhanden sind, geben Sie den Knoten mit dem kleinsten Index zurück.

    Der „gepflückte“ Knoten sollte in einer Liste zurückgegeben werden: [kleinster Wert, dessen Index].
    Wenn keine geraden Werte vorhanden sind oder das gegebene Array leer ist, geben Sie [] zurück.

    Beispiel 1:
        Eingabe: [4,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert und 2 hat den kleinsten Index.

    Beispiel 2:
        Eingabe: [1,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert und 2 hat den kleinsten Index.

    Beispiel 3:
        Eingabe: []
        Ausgabe: []

    Beispiel 4:
        Eingabe: [5, 0, 3, 0, 4, 2]
        Ausgabe: [0, 1]
        Erklärung: 0 ist der kleinste Wert, aber es gibt zwei Nullen,
                     daher wählen wir die erste Null, die den kleinsten Index hat.

    Einschränkungen:
        * 1 <= Knoten.length <= 10000
        * 0 <= Knotenwert
    """

def pluck(arr):
    """
    "Angenommen, ein Array repräsentiert einen Ast eines Baumes, der nicht-negative ganze Zahlen als Knoten hat,
    Ihre Aufgabe ist es, einen der Knoten zu pflücken und zurückzugeben.
    Der gepflückte Knoten muss der Knoten mit dem kleinsten geraden Wert sein.
    Wenn mehrere Knoten denselben kleinsten geraden Wert haben, geben Sie den Knoten mit dem kleinsten Index zurück.

    Der gepflückte Knoten muss in einer Liste zurückgegeben werden, [ kleinster_Wert, sein_Index ],
    Wenn kein Knoten gerade Werte hat oder das gegebene Array leer ist, geben Sie [] zurück.

    Beispiel 1:
        Eingabe: [4,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert, und 2 hat den kleinsten Index.

    Beispiel 2:
        Eingabe: [1,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert, und 2 hat den kleinsten Index.

    Beispiel 3:
        Eingabe: []
        Ausgabe: []

    Beispiel 4:
        Eingabe: [5, 0, 3, 0, 4, 2]
        Ausgabe: [0, 1]
        Erklärung: 0 ist der kleinste Wert, aber es gibt zwei Nullen,
                     daher wählen wir die erste Null, die den kleinsten Index hat.

    Einschränkungen:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Gegeben ist ein Array, das einen Zweig eines Baums darstellt, der nicht-negative ganzzahlige Knoten hat
    Ihre Aufgabe ist es, einen der Knoten zu pflücken und zurückzugeben.
    Der gezupfte Knoten sollte der Knoten mit dem kleinsten geraden Wert sein.
    Wenn mehrere Knoten mit demselben kleinsten geraden Wert gefunden werden, wird der Knoten mit dem kleinsten Index zurückgegeben.

    Der gezupfte Knoten sollte in einer Liste zurückgegeben werden, [ smallest_value, its index ],
    Wenn es keine geraden Werte gibt oder das angegebene Array leer ist, geben Sie [] zurück.

    Beispiel 1:
        Eingabe: [4,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert und 2 den kleinsten Index.

    Beispiel 2:
        Eingabe: [4,2,3]
        Ausgabe: [2, 1]
        Erklärung: 2 hat den kleinsten geraden Wert und 2 den kleinsten Index.

    Beispiel 3:
        Eingabe: []
        Ausgabe: []

    Beispiel 4:
        Eingabe: [5, 0, 3, 0, 4, 2]
        Ausgabe: [0, 1]
        Erklärung: 0 ist der kleinste Wert, aber es gibt zwei Nullen,
                     Wir wählen also die erste Null, die den kleinsten Index hat.

    Zwänge:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Sie erhalten eine nicht leere Liste positiver Ganzzahlen. Geben Sie die größte Ganzzahl zurück, die größer als
    Null ist und eine Häufigkeit aufweist, die größer oder gleich dem Wert der Ganzzahl selbst ist.
    Die Häufigkeit einer Ganzzahl ist die Anzahl, wie oft sie in der Liste vorkommt.
    Wenn kein solcher Wert vorhanden ist, geben Sie -1 zurück.
    Beispiele:
    search([4, 1, 2, 2, 3, 1]) == 2
    search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
    search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Gegeben ist eine nicht-leere Liste von positiven ganzen Zahlen. Gibt die größte Zahl zurück,
    die größer als null ist und deren Häufigkeit größer oder gleich ihrem eigenen Wert ist.
    Die Häufigkeit einer Zahl ist die Anzahl der Male, die sie in der Liste erscheint.
    Wenn es keinen solchen Wert gibt, gibt -1 zurück.
    Beispiele:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Given a non-empty list of positive integers. Returns the largest integer,
    that is greater than zero and whose frequency is greater than or equal to the value of the number itself.
    The frequency of a number is the number of times it appears in the list.
    If there is no such value, returns -1.
    Examples:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Bei gegebener Liste von ganzen Zahlen wird die Liste in seltsamer Reihenfolge zurückgegeben.
    Eine seltsame Sortierung ist, wenn man mit dem kleinsten Wert beginnt,
    dann mit dem größten der verbleibenden ganzen Zahlen, dann mit dem kleinsten und so weiter.

    Beispiele:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Gegeben eine Liste von Ganzzahlen, Liste in seltsamer Reihenfolge zurückgeben.
    Seltsame Sortierung ist, wenn Sie mit dem den kleinsten Wert beginnen,
    dann mit dem den größten Wert der verbleibenden Ganzzahlen, dann mit dem den kleinsten Wert usw.

    Beispiele:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Bei einer gegebenen Liste von ganzen Zahlen wird die Liste in seltsamer Reihenfolge zurückgegeben.
    Seltsame Sortierung ist, wenn Sie mit dem minimalen Wert beginnen,
    dann das Maximum der verbleibenden ganzen Zahlen, dann das Minimum und so weiter.

    Beispiele:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Gegeben sind die Längen der drei Seiten eines Dreiecks. Gibt die Fläche
    des Dreiecks auf 2 Dezimalstellen gerundet zurück, wenn die drei Seiten ein gültiges Dreieck bilden.
    Andernfalls wird -1 zurückgegeben.
    Drei Seiten bilden ein gültiges Dreieck, wenn die Summe zweier beliebiger Seiten größer
    als die dritte Seite ist.
    Beispiel:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Gegeben sind die Längen der drei Seiten eines Dreiecks. Gib den Flächeninhalt des
    des Dreiecks, gerundet auf 2 Dezimalstellen, wenn die drei Seiten ein gültiges Dreieck bilden.
    Andernfalls wird -1 zurückgegeben.
    Drei Seiten bilden ein gültiges Dreieck, wenn die Summe von zwei beliebigen Seiten größer ist
    als die dritte Seite ist.
    Beispiel:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Gegeben sind die Längen der drei Seiten eines Dreiecks. Gibt die Fläche des Dreiecks zurück, die auf zwei Dezimalstellen gerundet ist, wenn die drei Seiten ein gültiges Dreieck bilden. Andernfalls gibt die Funktion -1 zurück. Ein Dreieck ist gültig, wenn die Summe zweier beliebiger Seiten größer ist als die dritte Seite.
    Beispiel:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Schreiben Sie eine Funktion, die True zurückgibt, wenn das Objekt q fliegt, und andernfalls False.
    Das Objekt q fliegt, wenn es ausgeglichen ist (es handelt sich um eine palindromische Liste) und die Summe seiner Elemente kleiner oder gleich dem maximal möglichen Gewicht w ist.

    Beispiel:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 ist kleiner als das maximal mögliche Gewicht, aber es ist unbalanciert.

    will_it_fly([3, 2, 3], 1) ➞ False
    # Es ist ausgewogen, aber 3+2+3 ist mehr als das maximal mögliche Gewicht.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 ist kleiner als das maximal mögliche Gewicht, und es ist ausgeglichen.

    will_it_fly([3], 5) ➞ True
    # 3 ist kleiner als das maximal mögliche Gewicht, und es ist ausgeglichen.
    '''

def will_it_fly(q,w):
    '''
    Schreiben Sie eine Funktion, die True zurückgibt, wenn das Objekt q fliegen wird, und False andernfalls.
    Das Objekt q wird fliegen, wenn es ausgeglichen ist (es ist eine palindromische Liste) und die Summe seiner Elemente kleiner oder gleich dem maximal möglichen Gewicht w ist.

    Beispiel:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 ist kleiner als das maximal mögliche Gewicht, aber es ist nicht ausgeglichen.

    will_it_fly([3, 2, 3], 1) ➞ False
    # es ist ausgeglichen, aber 3+2+3 ist mehr als das maximal mögliche Gewicht.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 ist kleiner als das maximal mögliche Gewicht, und es ist ausgeglichen.

    will_it_fly([3], 5) ➞ True
    # 3 ist kleiner als das maximal mögliche Gewicht, und es ist ausgeglichen.
    '''

def will_it_fly(q,w):
    '''
    Schreibe eine Funktion, die True zurückgibt, wenn das Objekt q fliegen wird, und False andernfalls.
    Das Objekt q wird fliegen, wenn es ausgeglichen ist (es ist eine palindromische Liste) und die Summe seiner Elemente kleiner oder gleich dem maximal möglichen Gewicht w ist.

    Beispiel:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 ist kleiner als das maximal mögliche Gewicht, aber es ist unausgeglichen.

    will_it_fly([3, 2, 3], 1) ➞ False
    # es ist ausgeglichen, aber 3+2+3 ist mehr als das maximal mögliche Gewicht.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 ist weniger als das maximal mögliche Gewicht, und es ist ausgeglichen.

    will_it_fly([3], 5) ➞ True
    # 3 ist kleiner als das maximal mögliche Gewicht, und es ist ausgeglichen.
    '''


def smallest_change(arr):
    """
    Ermitteln Sie bei einem Array arr von ganzen Zahlen die minimale Anzahl von Elementen, die
    geändert werden müssen, um das Array palindromisch zu machen. Ein palindromisches Array ist ein Array, das
    wird vorwärts und rückwärts gleich gelesen. Mit einer Änderung können Sie ein Element in jedes andere Element ändern.

    Zum Beispiel:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    ""
    Finden Sie bei einem Array arr aus Ganzzahlen die Mindestanzahl von Elementen, die
    geändert werden müssen, damit das Array palindromisch wird. Ein palindromisches Array ist ein Array, das
    vorwärts und rückwärts gleich gelesen wird. Mit einer Änderung können Sie ein Element in ein beliebiges anderes Element ändern.

    Beispiel:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Bei einer Reihe von ganzen Zahlen soll die Mindestanzahl der Elemente ermittelt werden, die
    geändert werden müssen, damit die Reihe palindromisch wird. Eine palindromische Reihe ist eine Reihe, die
    vorwärts und rückwärts gleich gelesen wird. Bei einer Änderung kann ein Element in ein beliebiges anderes Element geändert werden.

    Zum Beispiel:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Schreiben Sie eine Funktion, die zwei Listen mit Zeichenfolgen akzeptiert und die Liste zurückgibt, deren Gesamtzahl an Zeichen in allen Zeichenfolgen der Liste kleiner ist als die der
    anderen Liste.

    Wenn die beiden Listen die gleiche Anzahl an Zeichen haben, geben Sie die erste Liste zurück.

    Beispiele
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Schreiben Sie eine Funktion, die zwei Listen von Zeichenketten akzeptiert und die Liste zurückgibt, deren
    die Gesamtzahl der Zeichen in allen Zeichenketten der Liste kleiner ist als in der anderen Liste.

    Wenn die beiden Listen die gleiche Anzahl von Zeichen enthalten, wird die erste Liste zurückgegeben.

    Beispiele
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Schreiben Sie eine Funktion, die zwei Listen von Zeichenfolgen akzeptiert und die Liste mit der geringeren Gesamtzahl an Zeichen zurückgibt, die
    Die Liste mit der geringeren Gesamtzahl an Zeichen wird zurückgegeben.

    Wenn die beiden Listen die gleiche Anzahl von Zeichen haben, wird die erste Liste zurückgegeben.

    Beispiele
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Schreiben Sie eine Funktion, die wahr zurückgibt, wenn die gegebene Zahl das Produkt von 3 Primzahlen ist
    und falsch im gegenteiligen Fall.
    Dabei ist (a) kleiner als 100.
    Beispiel:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Schreiben Sie eine Funktion, die true zurückgibt, wenn die angegebene Zahl die Multiplikation von 3 Primzahlen ist
    und andernfalls false.
    Dabei ist zu beachten, dass (a) kleiner als 100 ist.
    Beispiel:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Schreibe eine Funktion, die true zurückgibt, wenn die gegebene Zahl die Multiplikation von 3 Primzahlen ist
    und andernfalls falsch ist.
    Wissend, dass (a) kleiner als 100 ist.
    Beispiel:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu schreiben, die true liefert, wenn eine Zahl x eine einfache
    Potenz von n ist und falsch in anderen Fällen.
    x ist eine einfache Potenz von n, wenn n**int=x
    Zum Beispiel:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu schreiben, die true zurückgibt, wenn eine Zahl x eine einfache ist
    Potenz von n und false in anderen Fällen.
    x ist eine einfache Potenz von n, wenn n**int=x
    Zum Beispiel:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu schreiben, die true zurückgibt, wenn eine Zahl x eine einfache
    Potenz von n ist, und false in allen anderen Fällen.
    x ist eine einfache Potenz von n, wenn n**int=x
    Beispiel:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Schreiben Sie eine Funktion, die eine ganze Zahl a entgegennimmt und True zurückgibt,
    wenn diese Zahl ein Kubus einer ganzen Zahl ist.
    Hinweis: Sie können davon ausgehen, dass die Eingabe stets gültig ist.
    Beispiele:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Schreiben Sie eine Funktion, die eine Ganzzahl a annimmt und True zurückgibt,
    wenn diese Ganzzahl die dritte Potenz einer Ganzzahl ist.
    Hinweis: Sie können davon ausgehen, dass die Eingabe immer gültig ist.
    Beispiele:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Schreiben Sie eine Funktion, die eine ganze Zahl a entgegennimmt und „Wahr“ zurückgibt,
    wenn diese Zahl ein Kubus einer ganzen Zahl ist.
    Hinweis: Sie können davon ausgehen, dass die Eingabe immer gültig ist.
    Beispiele:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """Du wurdest beauftragt, eine Funktion zu schreiben, die
    eine Hexadezimalzahl als String empfängt und die Anzahl der Hexadezimalziffern zählt,
     die Primzahlen sind (eine Primzahl ist eine natürliche Zahl
    größer als 1, die nicht das Produkt zweier kleinerer natürlicher Zahlen ist).

    Hexadezimalzahlen sind 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Primzahlen sind 2, 3, 5, 7, 11, 13, 17,...
    Du musst also eine Reihe der folgenden Ziffern bestimmen: 2, 3, 5, 7,
    B (=dezimal 11), D (=dezimal 13).
    Hinweis: Du kannst davon ausgehen, dass die Eingabe immer korrekt ist oder eine leere Zeichenkette,
    und die Symbole A, B, C, D, E, F sind immer in Großbuchstaben.
    Beispiele:
    Für num = "AB" sollte die Ausgabe 1 sein.
    Für num = "1077E" sollte die Ausgabe 2 sein.
    Für num = "ABED1A33" sollte die Ausgabe 4 sein.
    Für num = "123456789ABCDEF0" sollte die Ausgabe 6 sein.
    Für num = "2020" sollte die Ausgabe 2 sein.
    """

def hex_key(num):
    """Schreiben Sie eine Funktion, die eine hexadezimale Zahl als String erhält
    und die Anzahl der hexadezimalen Ziffern zählt, die Primzahlen sind
    (eine Primzahl ist eine natürliche Zahl größer als 1, die nicht das Produkt
    zweier kleinerer natürlicher Zahlen ist).
    Die hexadezimalen Ziffern sind 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Die Primzahlen sind 2, 3, 5, 7, 11, 13, 17,...
    Sie sollen also die Anzahl folgender Ziffern bestimmen: 2, 3, 5, 7,
    B (=dezimal 11), D (=dezimal 13).
    Hinweis: Sie können davon ausgehen, dass die Eingabe immer korrekt ist oder
    aus einem leeren String besteht, und die Symbole A, B, C, D, E, F sind
    immer großgeschrieben.
    Beispiele:
    Bei num = "AB" sollte die Ausgabe 1 sein.
    Bei num = "1077E" sollte die Ausgabe 2 sein.
    Bei num = "ABED1A33" sollte die Ausgabe 4 sein.
    Bei num = "123456789ABCDEF0" sollte die Ausgabe 6 sein.
    Bei num = "2020" sollte die Ausgabe 2 sein.
    """

def hex_key(num):
    ""Sie haben die Aufgabe, eine Funktion zu schreiben, die eine
    hexadezimale Zahl als Zeichenfolge empfängt und die Anzahl der hexadezimalen
    Ziffern zählt, die Primzahlen sind (eine Primzahl oder Primzahl ist eine natürliche Zahl
    größer als 1, die nicht das Produkt zweier kleinerer natürlicher Zahlen ist).
    Hexadezimale Ziffern sind 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Primzahlen sind 2, 3, 5, 7, 11, 13, 17,...
    Sie müssen also eine Anzahl der folgenden Ziffern bestimmen: 2, 3, 5, 7,
    B (= Dezimalzahl 11), D (= Dezimalzahl 13).
    Hinweis: Sie können davon ausgehen, dass die Eingabe immer korrekt oder eine leere Zeichenfolge ist,
    und die Symbole A, B, C, D, E, F immer in Großbuchstaben.
    Beispiele:
    Für num = „AB“ sollte die Ausgabe 1 sein.
    Für num = „1077E“ sollte die Ausgabe 2 sein.
    Für num = „ABED1A33“ sollte die Ausgabe 4 sein.
    Für num = „123456789ABCDEF0“ sollte die Ausgabe 6 sein.
    Für num = „2020“ sollte die Ausgabe 2 sein.
    """


def decimal_to_binary(decimal):
    """Sie erhalten eine Zahl in dezimaler Form und Ihre Aufgabe ist es, diese in
    Binärformat umzuwandeln. Die Funktion sollte eine Zeichenkette zurückgeben, bei der jedes Zeichen für eine Binärzahl
    Zahl darstellt. Jedes Zeichen in der Zeichenkette ist '0' oder '1'.

    Am Anfang und am Ende der Zeichenkette gibt es ein paar zusätzliche Zeichen „db“.
    Die zusätzlichen Zeichen dienen zur Unterstützung der Formatierung.

    Beispiele:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    ""Sie erhalten eine Zahl in Dezimalform und Ihre Aufgabe ist es, diese in das
    Binärformat umzuwandeln. Die Funktion sollte eine Zeichenfolge zurückgeben, wobei jedes Zeichen eine Binärzahl darstellt. Jedes Zeichen in der Zeichenfolge ist „0“ oder „1“.

    Am Anfang und am Ende der Zeichenfolge stehen zwei zusätzliche Zeichen, „db“.
    Die zusätzlichen Zeichen dienen der Formatierung.

    Beispiele:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    ""Sie erhalten eine Zahl in Dezimalform und Ihre Aufgabe ist es, sie in Binärformat
    umzuwandeln. Die Funktion sollte eine Zeichenkette zurückgeben, wobei jedes Zeichen eine Binärzahl darstellt
    Zahl. Jedes Zeichen in der Zeichenfolge ist '0' oder '1'.

    Es gibt ein paar zusätzliche Zeichen 'db' am Anfang und am Ende der Zeichenfolge.
    Die zusätzlichen Zeichen sind dazu da, bei der Formatierung zu helfen.

    Beispiele:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """Du bekommst eine Zeichenkette s.
    Ihre Aufgabe ist es, zu prüfen, ob die Zeichenkette glücklich ist oder nicht.
    Eine Zeichenkette ist glücklich, wenn ihre Länge mindestens 3 beträgt und alle 3 aufeinanderfolgenden Buchstaben verschieden sind.
    Zum Beispiel:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Du bekommst eine Zeichenkette s.
    Ihre Aufgabe ist es, zu überprüfen, ob die Zeichenkette  glücklich ist oder nicht.
    Eine Zeichenkette ist glücklich, wenn ihre Länge mindestens 3 beträgt und alle 3 aufeinanderfolgenden Buchstaben unterschiedlich sind
    Zum Beispiel:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Sie erhalten eine Zeichenkette s.
    Ihre Aufgabe ist es zu überprüfen, ob die Zeichenkette glücklich ist oder nicht.
    Eine Zeichenkette ist glücklich, wenn ihre Länge mindestens 3 beträgt und jede 3 aufeinanderfolgenden Buchstaben unterschiedlich sind.
    Zum Beispiel:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """Es ist die letzte Woche des Semesters und der Professor muss die Noten
    an die Studenten vergeben. Der Professor hat seinen eigenen Algorithmus
    zur Benotung erstellt. Das einzige Problem ist, dass er den Code verloren hat,
    den er zur Benotung verwendet hat. Er hat Ihnen eine Liste von GPAs für einige
    Studenten gegeben und Sie müssen eine Funktion schreiben, die eine Liste von
    Buchstabennoten unter Verwendung der folgenden Tabelle zurückgeben kann:
             GPA       |    Buchstabennote
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Beispiel:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Es ist die letzte Woche des Semesters und der Lehrer muss den Schülern die Noten geben
    an die Schüler verteilen. Die Lehrerin hat ihren eigenen Algorithmus für die Benotung entwickelt.
    Das einzige Problem ist, dass sie den Code, den sie für die Benotung verwendet hat, verloren hat.
    Sie hat Ihnen eine Liste von GPAs für einige Schüler gegeben und Sie müssen eine Funktion schreiben
    eine Funktion schreiben, die eine Liste von Buchstabennoten unter Verwendung der folgenden Tabelle ausgibt:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Beispiel:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Schreiben Sie eine Funktion, die einen String annimmt und True zurückgibt, wenn die Stringlänge
    eine Primzahl ist, andernfalls False.
    Beispiele
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Schreiben Sie eine Funktion, die eine Zeichenkette annimmt und True zurückgibt, wenn die Zeichenkette
    Länge eine Primzahl ist oder andernfalls False zurückgibt
    Beispiele
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Schreiben Sie eine Funktion, die eine Zeichenkette entgegennimmt und „Wahr“ zurückgibt, wenn die
    Länge der Zeichenkette eine Primzahl ist, oder andernfalls „Falsch“ zurückgibt.
    Beispiele
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Geben Sie bei einer positiven Ganzzahl n die Anzahl der n-stelligen
    positiven Ganzzahlen zurück, die mit 1 beginnen oder enden.
    """

def starts_one_ends(n):
    """
    Bei einer positiven ganzen Zahl n wird die Anzahl der n-stelligen
    positiven ganzen Zahlen zurückgegeben, die mit 1 beginnen oder enden.
    """

def starts_one_ends(n):
    """
    Bei einer positiven Ganzzahl n gibt die Anzahl zurück der n-stelligen
    positiven ganzen Zahlen, die mit 1 beginnen oder enden.
    """


def solve(N):
    """Bei einer positiven ganzen Zahl N die Gesamtsumme ihrer Ziffern in binärer Form zurückgeben.

    Beispiel
        Für N = 1000, die Summe der Ziffern ist 1. Die Ausgabe sollte „1“ sein.
        Für N = 150, die Summe der Ziffern beträgt 6. Die Ausgabe sollte „110“ lauten.
        Für N = 147, die Summe der Ziffern beträgt 12. Die Ausgabe sollte „1100“ lauten.

    Variablen:
        @N integer
             Einschränkungen: 0 ≤ N ≤ 10000.
    Ausgabe:
         eine Folge von Binärzahl
    """

def solve(N):
    ""Geben Sie bei einer positiven Ganzzahl N die Gesamtsumme ihrer Ziffern im Binärwert zurück.

    Beispiel
        Bei N = 1000 ist die Summe der Ziffern 1, die Ausgabe sollte "1" sein.
        Bei N = 150 ist die Summe der Ziffern 6, die Ausgabe sollte "110" sein.
        Bei N = 147 ist die Summe der Ziffern 12, die Ausgabe sollte "1100" sein.

    Variablen:
        @N Ganzzahl
             Einschränkungen: 0 ≤ N ≤ 10000.
    Ausgabe:
         eine Zeichenfolge mit Binärzahlen
    ""

def solve(N):
    ""Geben Sie bei einer positiven Ganzzahl N die Gesamtsumme ihrer Ziffern im Binärzahl zurück.

    Beispiel
    Bei N = 1000 ist die Summe der Ziffern 1, die Ausgabe sollte "1" sein.
    Bei N = 150 ist die Summe der Ziffern 6, die Ausgabe sollte "110" sein.
    Bei N = 147 ist die Summe der Ziffern 12, die Ausgabe sollte "1100" sein.

    Variablen:
        @N Ganzzahl
              Einschränkungen: 0 ≤ N ≤ 10000.
    Ausgabe:
        eine Zeichenkette mit Binärzahlen
    ""


def add(lst):
    """Gegeben sei eine nicht leere Liste von Ganzzahlen lst. Addieren Sie die geraden Elemente, die sich an ungeraden Indizes befinden.

    Beispiele:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Gegeben eine nicht-leere Liste von ganzen Zahlen lst, summiere die geraden Elemente, die an ungeraden Indizes stehen.

    Beispiele:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Bei einer nicht leeren Liste ganzer Zahlen lst. addiert man die geraden Elemente, die sich auf ungeraden Indizes befinden.

    Beispiele:
        add([4, 2, 6, 7]) ==> 2
    """