def anti_shuffle(s):
    """
    Schreiben Sie eine Funktion, die eine Zeichenkette annimmt und eine geordnete Version davon zurückgibt.
    Die geordnete Version einer Zeichenkette ist eine Zeichenkette, bei der alle Wörter (durch Leerzeichen getrennt)
    durch ein neues Wort ersetzt werden, in dem alle Zeichen in aufsteigender
    aufsteigender Reihenfolge, basierend auf dem Ascii-Wert, angeordnet sind.
    Hinweis: Sie sollten die Reihenfolge der Wörter und Leerzeichen im Satz beibehalten.

    Zum Beispiel:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Schreiben Sie eine Funktion, die einen String annimmt und eine geordnete Version davon zurückgibt.
    Die geordnete Version des Strings ist ein String, in dem alle Wörter (durch Leerzeichen getrennt)
    durch ein neues Wort ersetzt werden, in dem alle Zeichen
    aufsteigend nach ASCII-Werten angeordnet sind.
    Hinweis: Sie sollten die Reihenfolge der Wörter und Leerzeichen im Satz beibehalten.

    Beispiel:
    anti_shuffle('Hi') gibt 'Hi' zurück
    anti_shuffle('hello') gibt 'ehllo' zurück
    anti_shuffle('Hello World!!!') gibt 'Hello !!!Wdlor' zurück
    ""

def anti_shuffle(s):
    """
    Schreiben Sie eine Funktion, die eine String akzeptiert und eine geordnete Version davon zurückgibt.
    Die geordnete Version des Strings ist ein String, bei dem alle Wörter (durch Leerzeichen getrennt)
    werden durch ein neues Wort ersetzt, wobei alle Zeichen, die in
    in aufsteigender Reihenfolge nach ihrem ASCII-Wert.
    Hinweis: Sie sollten die Reihenfolge der Wörter und Leerzeichen im Satz beibehalten.

    Zum Beispiel:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Sie erhalten eine zweidimensionale Datenstruktur, wie verschachtelte Listen,
    die einer Matrix ähnelt, jedoch im Gegensatz zu Matrizen kann jede Zeile
    eine unterschiedliche Anzahl von Spalten enthalten.
    Gegeben lst und eine ganze Zahl x, finden Sie die ganzen Zahlen x in der Liste,
    und geben Sie eine Liste von Tupeln zurück, [(x1, y1), (x2, y2) ...], sodass
    jedes Tupel eine Koordinate ist - (Zeile, Spalte), beginnend bei 0.
    Sortieren Sie die Koordinaten zunächst nach Zeilen in aufsteigender Reihenfolge.
    Außerdem sortieren Sie die Koordinaten der Zeile nach Spalten in absteigender Reihenfolge.

    Beispiele:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Sie erhalten 2-dimensionale Daten in Form von verschachtelten Listen,
    die einer Matrix ähnlich ist, aber im Gegensatz zu Matrizen,
    kann jede Zeile eine unterschiedliche Anzahl von Spalten enthalten.
    Gegeben lst und die ganze Zahl x, finden Sie die ganzen Zahlen x in der Liste,
    und gebe eine Liste von Tupeln zurück, [(x1, y1), (x2, y2) ...], so dass
    jedes Tupel eine Koordinate ist - (Zeile, Spalten), beginnend mit 0.
    Sortieren Sie die Koordinaten zunächst nach Zeilen in aufsteigender Reihenfolge.
    Sortiere außerdem die Koordinaten der Zeilen nach den Spalten in absteigender Reihenfolge.

    Beispiele:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Sie erhalten 2-dimensionale Daten in Form einer verschachtelten Liste,
    die einer Matrix ähnelt, aber im Gegensatz zu Matrizen,
    Jede Zeile kann eine unterschiedliche Anzahl von Spalten haben.
    Bei gegebener lst und ganzzahliger Zahl x finden Sie die ganzen Zahlen x in der Liste,
    und gibt eine Liste von Tupeln zurück, [(x1, y1), (x2, y2) ...], wobei
    Jedes Tupel stellt eine Koordinate dar - (Zeile, Spalte), wobei die Indizierung bei 0 beginnt.
    Sortieren Sie die Koordinaten zunächst nach Zeilen in aufsteigender Reihenfolge.
    Sortieren Sie außerdem die Koordinaten der Zeile nach Spalte in absteigender Reihenfolge.

    Beispiele:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Gegeben ist ein Array von nicht-negativen ganzen Zahlen, gibt eine Kopie des Arrays zurück, nachdem es sortiert wurde,
    das Array wird in aufsteigender Reihenfolge sortiert, wenn die Summe der Werte des ersten und letzten Index ungerade ist,
    oder es wird in absteigender Reihenfolge sortiert, wenn die Summe der Werte des ersten und letzten Index gerade ist.

    Hinweis:
    * Ändere das gegebene Array nicht.

    Beispiele:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """
    ``

def sort_array(array):
    """
    Wenn Sie eine Reihe nicht negativer Ganzzahlen erhalten, geben Sie eine Kopie der gegebenen Reihe nach dem Sortieren zurück.
    Sie sortieren die gegebene Reihe in aufsteigender Reihenfolge, wenn die Summe (erster Indexwert, letzter Indexwert) ungerade ist,
    oder sortieren sie in absteigender Reihenfolge, wenn die Summe (erster Indexwert, letzter Indexwert) gerade ist.

    Hinweis:
    * Änder das angegebene Array nicht.

    Beispiele:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Geben Sie bei einem Array nicht negativer Ganzzahlen eine Kopie des angegebenen Arrays nach dem Sortieren zurück.
    Sie sortieren das angegebene Array in aufsteigender Reihenfolge, wenn die Summe (erster Indexwert, letzter Indexwert) ungerade ist,
    oder in absteigender Reihenfolge, wenn die Summe (erster Indexwert, letzter Indexwert) gerade ist.

    Hinweis:
    * Ändern Sie das angegebene Array nicht.

    Beispiele:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """Erstellen Sie eine Funktion encrypt, die eine Zeichenkette als Argument nimmt und
    eine verschlüsselte Zeichenkette mit dem rotierten Alphabet zurückgibt.
    Das Alphabet sollte so rotiert werden, dass die Buchstaben
    um zwei mal zwei Stellen nach unten verschoben werden.
    Zum Beispiel:
    encrypt('hi') gibt 'lm' zurück
    encrypt('asdfghjkl') gibt 'ewhjklnop' zurück
    encrypt('gf') gibt 'kj' zurück
    encrypt('et') gibt 'ix' zurück
    """

def encrypt(s):
    ""Erstellen Sie eine Funktion encrypt, die eine Zeichenfolge als Argument verwendet und
    eine Zeichenfolge zurückgibt, die mit dem rotierten Alphabet verschlüsselt ist.
    Das Alphabet sollte so rotiert werden, dass die Buchstaben
    um zwei multipliziert mit zwei Stellen nach unten verschoben werden.
    Beispiel:
    encrypt('hi') gibt 'lm' zurück
    encrypt('asdfghjkl') gibt 'ewhjklnop' zurück
    encrypt('gf') gibt 'kj' zurück
    encrypt('et') gibt 'ix' zurück
    ""

def encrypt(s):
    """Erstellen Sie eine Funktion encrypt, die einen String als Argument annimmt und
    Gibt eine Zeichenfolge zurück, die durch das Verschieben des Alphabets um vier Stellen verschlüsselt ist.
    Das Alphabet sollte so gedreht werden, dass die Buchstaben
    Verschiebung um vier Stellen.
    Zum Beispiel:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """


def next_smallest(lst):
    """
    Sie erhalten eine Liste von ganzen Zahlen.
    Schreiben Sie eine Funktion next_smallest(), die das zweitkleinste Element der Liste zurückgibt.
    Gibt None zurück, wenn es ein solches Element nicht gibt.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Sie erhalten eine Liste von ganzen Zahlen.
    Schreiben Sie eine Funktion next_smallest(), die das zweitkleinste Element der Liste zurückgibt.
    Gibt None zurück, wenn kein solches Element vorhanden ist.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Sie erhalten eine Liste von ganzen Zahlen.
    Schreiben Sie eine Funktion next_smallest(), die das zweitkleinste Element der Liste zurückgibt.
    Geben Sie None zurück, wenn es kein solches Element gibt.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    Sie erhalten eine Reihe von Wörtern und Ihre Aufgabe ist es, die Anzahl der Langeweilsätze zu zählen. Eine Langeweilsätze ist ein Satz, der mit dem Wort „Ich“ beginnt.
    Sätze werden durch ‚.‘, ‚?‘ oder ‚!‘ abgegrenzt.

    Beispiel:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Sie erhalten eine Zeichenkette von Wörtern, und Ihre Aufgabe ist es, die Anzahl
    der Langeweilen zu zählen. Eine Langeweile ist ein Satz, der mit dem Wort "I" beginnt.
    Die Sätze werden durch '.', '?' oder '!' begrenzt.

    Zum Beispiel:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Sie erhalten eine Reihe von Wörtern und Ihre Aufgabe ist es, die Anzahl der
    Langeweilsätze zu zählen. Eine Langeweilsatz ist ein Satz, der mit dem Wort „ich“ beginnt.
    Sätze werden durch „.“, „?“ oder „!“ begrenzt.

    Zum Beispiel:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    Erstellen Sie eine Funktion, die 3 Zahlen nimmt.
    Gibt True zurück, wenn eine der Zahlen gleich der Summe der beiden anderen ist und alle Zahlen ganze Zahlen sind.
    Gibt Falsch in jedem anderen Fall zurück.

    Beispiele
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False
    '''

def any_int(x, y, z):
    '''
    Erstellen Sie eine Funktion, die 3 Zahlen annimmt.
    Gibt „true“ zurück, wenn eine der Zahlen gleich der Summe der beiden anderen ist und alle Zahlen Ganzzahlen sind.
    Gibt in allen anderen Fällen „false“ zurück.

    Beispiele
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Erstellen Sie eine Funktion, die 3 Zahlen akzeptiert.
    Gibt true zurück, wenn eine der Zahlen gleich der Summe der beiden anderen ist und alle Zahlen ganze Zahlen sind.
    Gibt in allen anderen Fällen false zurück.

    Beispiele
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Schreiben Sie eine Funktion, die eine Nachricht entgegennimmt und sie so kodiert, dass sie die Groß- und Kleinschreibung aller Buchstaben vertauscht und alle Vokale in der Nachricht durch den Buchstaben ersetzt, der im englischen Alphabet zwei Stellen nach diesem Vokal erscheint.
    Angenommen, es gibt nur Buchstaben.

    Beispiele:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Schreiben Sie eine Funktion, die eine Nachricht entgegennimmt und sie so verschlüsselt,
    dass sie die Groß- und Kleinschreibung aller Buchstaben vertauscht und alle Vokale in der
    Nachricht durch den Buchstaben ersetzt, der im englischen Alphabet zwei Stellen vor diesem
    Vokal steht.
    Es werden nur Buchstaben angenommen.

    Beispiele:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Schreiben Sie eine Funktion, die eine Nachricht entgegennimmt und so kodiert, dass sie die Groß-/Kleinschreibung aller Buchstaben vertauscht und alle Vokale in der Nachricht durch den Buchstaben ersetzt, der im englischen Alphabet zwei Stellen nach diesem Vokal steht. Nehmen wir an, es sind nur Buchstaben.

    Beispiele:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Sie erhalten eine Liste von ganzen Zahlen.
    Sie müssen den größten Primwert finden und die Summe seiner Ziffern zurückgeben.

    Beispiele:
    Für lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] sollte die Ausgabe 10 sein
    Für lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] sollte die Ausgabe 25 sein
    Für lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] sollte die Ausgabe 13 sein
    Für lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] sollte die Ausgabe 11 sein
    Für lst = [0,81,12,3,1,21] sollte die Ausgabe 3 sein
    Für lst = [0,8,1,2,1,7] sollte die Ausgabe 7 sein
    """

def skjkasdkd(lst):
    ""Sie erhalten eine Liste mit ganzen Zahlen.
    Sie müssen den größten Primwert finden und die Summe seiner Ziffern zurückgeben.

    Beispiele:
    Für lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] sollte die Ausgabe 10 sein
    Für lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] sollte die Ausgabe 25 sein
    Für lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] sollte die Ausgabe 13 sein
    Für lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] sollte die Ausgabe 11 sein
    Für lst = [0,81,12,3,1,21] sollte die Ausgabe 3 sein
    Für lst = [0,8,1,2,1,7] sollte die Ausgabe 7 sein
    """

def skjkasdkd(lst):
    """Sie erhalten eine Liste mit ganzen Zahlen.
    Sie müssen den größten Primzahlwert finden und die Summe seiner Ziffern zurückgeben.

    Beispiele:
    For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
    For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
    For lst = [0,81,12,3,1,21] the output should be 3
    For lst = [0,8,1,2,1,7] the output should be 7

    """


def check_dict_case(dict):
    """
    Bei einem Wörterbuch wird „True“ zurückgegeben, wenn alle Schlüssel Zeichenfolgen in Kleinbuchstaben
    oder alle Schlüssel Zeichenfolgen in Großbuchstaben sind, andernfalls wird „False“ zurückgegeben.
    Die Funktion sollte „False“ zurückgeben, wenn das angegebene Wörterbuch leer ist.
    Beispiele:
    check_dict_case({"a":"apple", "b":"banana"}) sollte True zurückgeben.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) sollte False zurückgeben.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) sollte False zurückgeben.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) sollte False zurückgeben.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) sollte True zurückgeben.
    """

def check_dict_case(dict):
    """
    Bei einem gegebenen Wörterbuch wird True zurückgegeben, wenn alle Schlüssel Zeichenfolgen in Kleinbuchstaben oder alle Schlüssel Zeichenfolgen in Großbuchstaben sind,
    andernfalls wird False zurückgegeben.
    Die Funktion sollte False zurückgeben, wenn das gegebene Wörterbuch leer ist.
    Beispiele:
    check_dict_case({"a":"apple", "b":"banana"}) sollte True zurückgeben.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) sollte False zurückgeben.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) sollte False zurückgeben.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) sollte False zurückgeben.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) sollte True zurückgeben.
    """

def check_dict_case(dict):
    """
    Gegeben ein Wörterbuch, gibt True zurück, wenn alle Schlüssel Zeichenketten im
    Kleinbuchstaben oder alle Schlüssel Zeichenketten im Großbuchstaben sind,
    andernfalls gibt es False zurück.
    Die Funktion sollte False zurückgeben, wenn das gegebene Wörterbuch leer ist.
    Beispiele:
    check_dict_case({"a":"apple", "b":"banana"}) sollte True zurückgeben.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) sollte False zurückgeben.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) sollte False zurückgeben.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) sollte False zurückgeben.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) sollte True zurückgeben.
    """


def count_up_to(n):
    """Implementieren Sie eine Funktion, die eine nicht-negative ganze Zahl entgegennimmt und ein Array der ersten n
    Primzahlen zurückgibt, die kleiner als n sind.
    zum Beispiel:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    ""Implementieren Sie eine Funktion, die eine nicht negative Ganzzahl annimmt und ein Array der ersten n
    Ganzzahlen zurückgibt, die Primzahlen sind und kleiner als n sind.
    Beispiel:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Implementieren Sie eine Funktion, die eine nicht negative ganze Zahl entgegennimmt und ein Array der ersten n
    ganzen Zahlen zurückgibt, die Primzahlen sind und kleiner als n.
    Zum Beispiel:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """Vervollständigen Sie die Funktion, die zwei Ganzzahlen annimmt und das Produkt ihrer Einerziffern zurückgibt.
    Gehen Sie davon aus, dass die Eingabe immer gültig ist.
    Beispiele:
    multiply(148, 412) sollte 16 zurückgeben.
    multiply(19, 28) sollte 72 zurückgeben.
    multiply(2020, 1851) sollte 0 zurückgeben.
    multiply(14,-15) sollte 20 zurückgeben.
    """

def multiply(a, b):
    """Vervollständigen Sie die Funktion, die zwei ganze Zahlen akzeptiert und
    das Produkt ihrer Einheitsziffern zurückgibt.
    Gehen Sie davon aus, dass die Eingabe immer gültig ist.
    Beispiele:
    multiply(148, 412) sollte 16 zurückgeben.
    multiply(19, 28) sollte 72 zurückgeben.
    multiply(2020, 1851) sollte 0 zurückgeben.
    multiply(14, -15) sollte 20 zurückgeben.
    """

def multiply(a, b):
    """Vervollständigen Sie die Funktion, die zwei ganze Zahlen annimmt und folgendes zurückgibt
    das Produkt ihrer Einheitsziffern zurückgibt.
    Gehen Sie davon aus, dass die Eingabe immer gültig ist.
    Beispiele:
    multiply(148, 412) sollte 16 zurückgeben.
    multiply(19, 28) sollte 72 zurückgeben.
    multiply(2020, 1851) sollte 0 zurückgeben.
    multiply(14,-15) sollte 20 zurückgeben.
    """


def count_upper(s):
    """
    Gegeben eine Zeichenkette s, zählt die Anzahl der Großbuchstaben-Vokale an geraden Indizes.

    Zum Beispiel:
    count_upper('aBCdEf') gibt 1 zurück
    count_upper('abcdefg') gibt 0 zurück
    count_upper('dBBE') gibt 0 zurück
    """

def count_upper(s):
    """
    Bei einer gegebenen Zeichenfolge s wird die Anzahl der Großbuchstaben-Vokale in geraden Indizes gezählt.

    Zum Beispiel:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    Gegeben eine Zeichenkette s, zählt die Anzahl der Großbuchstaben-Vokale an geraden Indizes.

    Zum Beispiel:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


def closest_integer(value):
    '''
    Erstellen Sie eine Funktion, die einen Wert (String) annimmt, der eine Zahl darstellt,
    und die nächstliegende Ganzzahl zurückgibt. Wenn die Zahl gleich weit von
    zwei Ganzzahlen entfernt ist, runden Sie sie von Null weg.

    Beispiele
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Hinweis:
    Das Runden von Null weg bedeutet, dass, wenn die angegebene Zahl gleich weit von
    zwei Ganzzahlen entfernt ist, diejenige zurückgegeben werden soll, die am
    weitesten von Null entfernt ist. Beispielsweise sollte closest_integer("14.5")
    15 zurückgeben und closest_integer("-14.5") sollte -15 zurückgeben.
    '''

def closest_integer(value):
    '''
    Erstellen Sie eine Funktion, die einen Wert (Zeichenkette) nimmt, der eine Zahl darstellt,
    und die nächste ganze Zahl zurückgibt. Wenn die Zahl gleich weit von zwei ganzen Zahlen entfernt ist,
    runden Sie von Null weg.
    Beispiele
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Hinweis:
    Von Null weg runden bedeutet, dass, wenn die gegebene Zahl gleich weit von zwei ganzen Zahlen entfernt ist,
    diejenige, die Sie zurückgeben sollten, diejenige ist, die weiter von Null entfernt ist. Zum Beispiel,
    closest_integer("14.5") sollte 15 zurückgeben und closest_integer("-14.5") sollte -15 zurückgeben.
    '''

def closest_integer(value):
    '''
    Erstelle eine Funktion, die einen Wert (String), der eine Zahl darstellt
    repräsentiert, und die nächstgelegene Ganzzahl dazu zurückgibt. Wenn die Zahl gleich weit entfernt ist
    von zwei Ganzzahlen, wird sie von Null abgerundet.

    Beispiele
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Hinweis:
    Abrunden von Null bedeutet, dass, wenn die angegebene Zahl gleich weit von zwei ganzen Zahlen entfernt ist, sollte diejenige zurückgegeben werden, die
    am weitesten von Null entfernt ist. Zum Beispiel sollte closest_integer(„14.5“)
    15 zurückgeben und closest_integer(„-14.5“) sollte -15 zurückgeben.
    '''


def make_a_pile(n):
    """
    Bei einer positiven ganzen Zahl n müssen Sie einen Steinhaufen mit n Ebenen bauen.
    Die erste Ebene besteht aus n Steinen.
    Die Anzahl der Steine in der nächsten Ebene beträgt:
        - die nächste ungerade Zahl, wenn n ungerade ist.
        - die nächste gerade Zahl, wenn n gerade ist.
    Geben Sie die Anzahl der Steine in jeder Ebene in einer Liste zurück, wobei das Element am Index
    i die Anzahl der Steine in der Ebene (i+1) darstellt.

    Beispiele:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Bei einer positiven Ganzzahl n müssen Sie einen Haufen mit n Steinebenen bilden.
    Die erste Ebene hat n Steine.
    Die Anzahl der Steine im nächsten Ebene beträgt:
        - die nächste ungerade Zahl, wenn n ungerade ist.
        - die nächste gerade Zahl, wenn n gerade ist.
    Gibt die Anzahl der Steine in jeder Ebene in einer Liste zurück, wobei das Element am Index
    i die Anzahl der Steine in der Ebene (i+1) repräsentiert.

    Beispiele:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    ""
    Bei einer positiven Ganzzahl n müssen Sie einen Stapel aus n Ebenen von Steinen bilden.
    Die erste Ebene hat n Steine.
    Die Anzahl der Steine in der nächsten Ebene ist:
       - die nächste ungerade Zahl, wenn n ungerade ist.
       - die nächste gerade Zahl, wenn n gerade ist.
    Gibt die Anzahl der Steine in jeder Ebene in einer Liste zurück, wobei das Element am Index
    i die Anzahl der Steine in der Ebene (i+1) darstellt.

    Beispiele:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Sie erhalten eine Zeichenkette von Wörtern, die durch Kommas oder Leerzeichen getrennt sind. Ihre Aufgabe ist es,
    die Zeichenkette in Wörter zu teilen und ein Array der Wörter zurückzugeben.

    Zum Beispiel:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

Du bekommst einen String aus Wörtern, die durch Kommas oder Leerzeichen getrennt sind. Deine Aufgabe ist es, den String in Wörter zu teilen und ein Array mit den Wörtern zurückzugeben.

Zum Beispiel:
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]

def words_string(s):
    """
    Sie erhalten eine Zeichenkette von Wörtern, die durch Kommas oder Leerzeichen getrennt sind. Ihre Aufgabe ist es,
    die Zeichenkette in Wörter zu teilen und ein Array der Wörter zurückzugeben.

    Beispiel:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """Diese Funktion nimmt zwei positive Zahlen x und y und gibt die
    größte gerade ganze Zahl zurück, die im Bereich [x, y] liegt, einschließlich. Wenn
    es keine solche Zahl gibt, sollte die Funktion -1 zurückgeben.

    Zum Beispiel:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Diese Funktion nimmt zwei positive Zahlen x und y und gibt die
    größte gerade Ganzzahl zurück, die im Bereich [x, y] einschließlich liegt. Wenn
    es keine solche Zahl gibt, sollte die Funktion -1 zurückgeben.

    Beispiel:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Diese Funktion nimmt zwei positive Zahlen x und y und gibt die
    größte gerade ganze Zahl, die im Bereich [x, y] liegt. Wenn
    Wenn es keine solche Zahl gibt, sollte die Funktion -1 zurückgeben.

    Zum Beispiel:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Sie erhalten zwei positive ganze Zahlen n und m, und Ihre Aufgabe ist es, den
    Durchschnitt der ganzen Zahlen von n bis m (einschließlich n und m) zu berechnen.
    Runden Sie das Ergebnis auf die nächste ganze Zahl und konvertieren Sie es in Binär.
    Wenn n größer als m ist, geben Sie -1 zurück.
    Beispiel:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    ""Sie erhalten zwei positive Ganzzahlen n und m und Ihre Aufgabe ist es, den
    Durchschnitt der Ganzzahlen von n bis m (einschließlich n und m) zu berechnen.
    Runden Sie die Antwort auf die nächste Ganzzahl und konvertieren Sie diese in eine Binärzahl.
    Wenn n größer als m ist, geben Sie -1 zurück.
    Beispiel:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Sie erhalten zwei positive ganze Zahlen n und m und Ihre Aufgabe besteht darin, den
    Durchschnitt der ganzen Zahlen von n bis m (einschließlich n und m) zu berechnen.
    Runden Sie das Ergebnis auf die nächste ganze Zahl und wandeln Sie es in eine Binärzahl um.
    Wenn n größer als m ist, geben Sie -1 zurück.
    Beispiel:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Gegeben sei eine Liste positiver Ganzzahlen x. Gib eine sortierte Liste aller
    Elemente zurück, die keine gerade Ziffer haben.

    Hinweis: Die zurückgegebene Liste sollte in aufsteigender Reihenfolge sortiert sein.

    Beispiel:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Gegeben ist eine Liste von positiven ganzen Zahlen x, diese gibt eine sortierte Liste von allen
    Elementen zurück, die keine gerade Ziffer haben.

    Hinweis: Die zurückgegebene Liste muss in aufsteigender Reihenfolge sortiert sein.

    Zum Beispiel:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Gegeben ist eine Liste positiver ganzer Zahlen x. gibt eine sortierte Liste aller zurück
    Elemente, die keine gerade Ziffer haben.

    Hinweis: Die zurückgegebene Liste sollte in aufsteigender Reihenfolge sortiert werden.

    Zum Beispiel:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Sortieren Sie die Zahlen zwischen 1 und 9 (einschließlich) in einem Array von ganzen Zahlen.
    Kehren Sie das resultierende Array um, und ersetzen Sie jede Ziffer durch den entsprechenden Namen von
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Zum Beispiel:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sortiere arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> kehre arr um -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Wenn das Array leer ist, gibt ein leeres Array zurück:
      arr = []
      return []

      Wenn das Array eine seltsame Zahl enthält, ignorieren Sie sie:
      arr = [1, -1 , 55]
            -> sortiere arr -> [-1, 1, 55]
            -> kehre arr um -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Gegeben ein Array von ganzen Zahlen, sortieren Sie die ganzen Zahlen, die zwischen 1 und 9 inklusive sind,
    kehren Sie das resultierende Array um, und ersetzen Sie jede Ziffer durch ihren entsprechenden Namen von
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Zum Beispiel:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sortiere arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> kehre arr um -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Wenn das Array leer ist, gibt ein leeres Array zurück:
      arr = []
      return []

      Wenn das Array eine seltsame Zahl enthält, ignorieren Sie sie:
      arr = [1, -1 , 55]
            -> sortiere arr -> [-1, 1, 55]
            -> kehre arr um -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Bei einem Array von ganzen Zahlen sortieren Sie die ganzen Zahlen, die zwischen 1 und 9 liegen.
    Kehren Sie das resultierende Array um, und ersetzen Sie dann jede Ziffer durch den entsprechenden Namen von
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

      Zum Beispiel:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Wenn das Array leer ist, wird ein leeres Array zurückgegeben:
      arr = []
      return []

      Wenn das Array eine seltsame Nummer hat, ignorieren Sie sie:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Implementieren Sie die Funktion f, die n als Parameter annimmt,
    und eine Liste der Größe n zurückgibt, so dass der Wert des Elements bei Index i die Fakultät von i ist, wenn i gerade ist
    oder andernfalls die Summe der Zahlen von 1 bis i.
    i beginnt bei 1.
    Die Fakultät von i ist die Multiplikation der Zahlen von 1 bis i (1 * 2 * ... * i).
    Beispiel:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implementieren Sie die Funktion f, die n als Parameter annimmt,
    und gibt eine Liste der Größe n zurück, so dass der Wert des Elements am Index i die Fakultät von i ist, wenn i gerade ist
    Oder sonst die Summe der Zahlen von 1 bis i.
    I beginnt bei 1.
    Die Fakultät von i ist die Multiplikation der Zahlen von 1 bis i (1 * 2 * ... * i).
    Beispiel:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implementieren Sie die Funktion f, die n als Parameter nimmt
    und eine Liste der Größe n zurückgibt, so dass der Wert des Elements an Index i das Fakultät von i ist, wenn i gerade ist,
    oder die Summe der Zahlen von 1 bis i andernfalls.
    i beginnt bei 1.
    Das Fakultät von i ist das Produkt der Zahlen von 1 bis i (1 * 2 * ... * i).
    Beispiel:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Gegeben ist eine positive ganze Zahl n, gibt ein Tupel zurück, das die Anzahl der geraden
    und ungeraden ganzzahligen Palindrome im Bereich von 1 bis n (einschließlich) enthält.

    Beispiel 1:

        Eingabe: 3
        Ausgabe: (1, 2)
        Erklärung:
        Die ganzzahligen Palindrome sind 1, 2, 3. Eines davon ist gerade, und zwei davon sind ungerade.

    Beispiel 2:

        Eingabe: 12
        Ausgabe: (4, 6)
        Erklärung:
        Die ganzzahligen Palindrome sind 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Vier davon sind gerade, und 6 davon sind ungerade.

    Hinweis:
        1. 1 <= n <= 10^3
        2. Das zurückgegebene Tupel enthält die Anzahl der geraden und ungeraden ganzzahligen Palindrome in dieser Reihenfolge.
    """

def even_odd_palindrome(n):
    """
    Gibt bei einer positiven ganzen Zahl n ein Tupel zurück, das die Anzahl der geraden und ungeraden
    ganzer Palindrome enthält, die in den Bereich(1, n) fallen, einschließlich.

    Beispiel 1:

        Eingabe: 3
        Ausgabe: (1, 2)
        Erklärung:
        Ganzzahlige Palindrome sind 1, 2, 3. Einer von ihnen ist gerade, und zwei von ihnen sind ungerade.

    Beispiel 2:

        Eingabe: 12
        Ausgabe: (4, 6)
        Erklärung:
        Ganzzahlige Palindrome sind 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Vier von ihnen sind gerade, und 6 von ihnen sind ungerade.

    Hinweis:
        1. 1 <= n <= 10^3
        2. Das zurückgegebene Tupel enthält die Anzahl der geraden bzw. ungeraden ganzzahligen Palindrome.
    """

def even_odd_palindrome(n):
    """
    Gegeben eine positive ganze Zahl n, gibt ein Tupel zurück, das die Anzahl der geraden
    und ungeraden ganzzahligen Palindrome im Intervall (1, n) einschließlich enthält.

    Beispiel 1:

        Eingabe: 3
        Ausgabe: (1, 2)
        Erklärung:
        Die ganzzahligen Palindrome sind 1, 2, 3. Eines davon ist gerade, und zwei davon sind ungerade.

    Beispiel 2:

        Eingabe: 12
        Ausgabe: (4, 6)
        Erklärung:
        Die ganzzahligen Palindrome sind 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Vier davon sind gerade, und 6 davon sind ungerade.

    Hinweis:
        1. 1 <= n <= 10^3
        2. Das zurückgegebene Tupel enthält die Anzahl der geraden und ungeraden ganzzahligen Palindrome in dieser Reihenfolge.
    """


def count_nums(arr):
    """
    Schreibe eine Funktion count_nums, die ein Array von Ganzzahlen entgegennimmt und
    die Anzahl der Elemente zurückgibt, deren Ziffernsumme > 0 ist.
    Wenn eine Zahl negativ ist, ist ihre erste Ziffer mit Vorzeichen negativ:
    z. B. hat -123 die Ziffern mit Vorzeichen -1, 2 und 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Schreiben Sie eine Funktion count_nums, die ein Array von Ganzzahlen annimmt und
    die Anzahl der Elemente zurückgibt, deren Summe der Ziffern > 0 ist.
    Wenn eine Zahl negativ ist, dann ist auch ihre erste vorzeichenbehaftete Ziffer negativ:
    Beispiel: -123 hat die vorzeichenbehafteten Ziffern -1, 2 und 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Schreiben Sie eine Funktion count_nums die ein Array von ganzen Zahlen annimmt und
    Die Anzahl der Elemente, deren Ziffernsumme größer als 0 ist, zurückgibt.
    Wenn eine Zahl negativ ist, dann ist ihre erste vorzeichenbehaftete Ziffern negativ:
    z.B. hat -123 die vorzeichenbehaftete Zahlen -1, 2 und 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Wir haben ein Array 'arr' von N ganzen Zahlen arr[1], arr[2], ..., arr[N]. Die
    Zahlen im Array werden zufällig angeordnet sein. Ihre Aufgabe ist es zu bestimmen, ob es
    möglich ist, ein nicht absteigend geordnetes Array zu erhalten, indem Sie die folgende
    Operation auf das gegebene Array ausführen:
        Sie dürfen die Rechtsverschiebungsoperation beliebig oft ausführen.

    Eine Rechtsverschiebungsoperation bedeutet, alle Elemente des Arrays um eine Position
    nach rechts zu verschieben. Das letzte Element des Arrays wird an die
    Anfangsposition im Array verschoben, das heißt an den Index 0.

    Wenn es möglich ist, das geordnete Array durch die vorherige Operation zu erhalten,
    dann geben Sie True zurück, andernfalls geben Sie False zurück.
    Wenn das gegebene Array leer ist, geben Sie True zurück.

    Hinweis: Es ist garantiert, dass die gegebene Liste eindeutige Elemente hat.

    Beispiel:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Erklärung: Durch 2 Rechtsverschiebungsoperationen ist es möglich,
                 eine nicht absteigende Ordnung für das gegebene Array zu erhalten.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Erklärung: Es ist nicht möglich, eine nicht absteigende Ordnung für das
                gegebene Array durch eine beliebige Anzahl von Rechtsverschiebungsoperationen zu erhalten.

    """

def move_one_ball(arr):
    """Wir haben ein Array 'arr' mit N ganzen Zahlen arr[1], arr[2], ..., arr[N].
    Die Zahlen im Array sind zufällig angeordnet. Ihre Aufgabe ist es zu bestimmen, ob
    ob es möglich ist, ein Array in nicht abnehmender Reihenfolge zu sortieren,
    indem Sie die folgende Operation mit der gegebenen Matrix durchführen:
        Sie können die Rechtsverschiebungsoperation beliebig oft durchführen.

    Eine Rechtsverschiebungsoperation bedeutet, dass alle Elemente des Arrays um eine
    Position nach recht verschoben werden. Das letzte Element des Arrays wird an die
    die Anfangsposition im Array, d.h. den 0ten Index.

    Wenn es möglich ist, das sortierte Array durch Ausführen der oben genannten Operation zu erhalten
    dann wird True zurückgegeben, sonst False.
    Wenn das gegebene Array leer ist, wird True zurückgegeben.

    Hinweis: Die angegebene Liste hat garantiert eindeutige Elemente.

    Zum Beispiel:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Erläuterung: Durch die Durchführung von zwei Rechtsschiebeoperationen kann eine nicht abnehmende Reihenfolge
                 für das gegebene Array erreicht werden.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Erläuterung: Es ist nicht möglich, eine nicht-absteigende Reihenfolge für das gegebene
                Array durch eine beliebige Anzahl von Rechtsschiebeoperationen zu erhalten.

    """

def move_one_ball(arr):
    """Wir haben ein Array 'arr' von N ganzen Zahlen arr[1], arr[2], ..., arr[N].
    Die Zahlen im Array sind in zufälliger Reihenfolge. Ihre Aufgabe ist es, festzustellen, ob es möglich ist, ein Array in nicht abnehmender Reihenfolge zu sortieren, indem Sie die folgende Operation durchführen:
    Es ist möglich, ein Array in nicht abnehmender Reihenfolge zu sortieren, indem Sie
    Die folgende Operation für das angegebene Array:
        Sie können die Rechtsverschiebung beliebig oft durchführen.

    Eine Rechtsverschiebung bedeutet, dass alle Elemente des Arrays um eins verschoben werden
    Position in die richtige Richtung. Das letzte Element des Arrays wird nach
    die Startposition im Array, d.h. der 0. Index.

    Wenn es möglich ist, das sortierte Array durch Ausführen des obigen Vorgangs zu erhalten,
    geben Sie True zurück, andernfalls False.
    Wenn das angegebene Array leer ist, geben Sie True zurück.

    Hinweis: Die angegebene Liste enthält garantiert eindeutige Elemente.

    Zum Beispiel:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Erklärung: Durch das Ausführen von 2 Rechtsverschiebungen kann eine nicht abnehmende Reihenfolge
                 für das gegebene Array erreicht werden.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Erklärung:Es ist nicht möglich, eine nicht abnehmende Reihenfolge für die gegebene
                Array durch das Ausführen einer beliebigen Anzahl von Rechtsverschiebungsoperationen.

    """


def exchange(lst1, lst2):
    """In dieser Aufgabe implementieren Sie eine Funktion, die zwei Listen mit Zahlen entgegennimmt
    und bestimmt, ob es möglich ist, einen Austausch von Elementen
    zwischen ihnen durchzuführen, um lst1 zu einer Liste mit nur geraden Zahlen zu machen.
    Es gibt keine Begrenzung für die Anzahl der ausgetauschten Elemente zwischen lst1 und lst2.
    Wenn es möglich ist, Elemente zwischen lst1 und lst2 auszutauschen, um
    alle Elemente von lst1 gerade zu machen, geben Sie „JA“ zurück.
    Andernfalls geben Sie „NEIN“ zurück.
    Beispiel:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => „YES“
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => “NO“
    Es wird davon ausgegangen, dass die Eingabelisten nicht leer sind.
    """

def exchange(lst1, lst2):
    """In diesem Problem implementieren Sie eine Funktion, die zwei Listen von Zahlen akzeptiert,
    und legt fest, ob es möglich ist, einen Austausch von Elementen durchzuführen
    dazwischen, um lst1 zu einer Liste von nur geraden Zahlen zu machen.
    Es gibt keine Begrenzung für die Anzahl der ausgetauschten Elemente zwischen lst1 und lst2.
    Wenn es möglich ist, Elemente zwischen lst1 und lst2 auszutauschen,
    sodass alle Elemente von lst1 gerade sind, wird 'YES' zurückgegeben.
    Andernfalls geben Sie "NO" zurück.
    Zum Beispiel:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Es wird davon ausgegangen, dass die Eingabelisten nicht leer sind.
    """

def exchange(lst1, lst2):
    """In diesem Problem implementieren Sie eine Funktion, die zwei Listen von Zahlen nimmt
    und bestimmt, ob es möglich ist, einen Austausch von Elementen
    zwischen ihnen durchzuführen, sodass lst1 eine Liste von nur geraden Zahlen ist.
    Es gibt keine Begrenzung für die Anzahl der ausgetauschten Elemente zwischen lst1 und lst2.
    Wenn es möglich ist, Elemente zwischen lst1 und lst2 auszutauschen, sodass
    alle Elemente von lst1 gerade sind, gibt "YES" zurück.
    Andernfalls gibt "NO" zurück.
    Zum Beispiel:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Es wird angenommen, dass die Eingabelisten nicht leer sind.
    """


def histogram(test):
    """Gegeben ist eine Zeichenkette, die Kleinbuchstaben enthält, getrennt durch Leerzeichen. Die Funktion gibt ein Wörterbuch
    zurück, das die Buchstaben mit den meisten Wiederholungen und die entsprechende Häufigkeit enthält.
    Wenn mehrere Buchstaben die gleiche Häufigkeit haben, gibt die Funktion alle zurück.

    Beispiel:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Bei einer Zeichenkette, die durch Leerzeichen getrennte Kleinbuchstaben darstellt, soll ein Wörterbuch
    des Buchstabens mit der häufigsten Wiederholung zurückgegeben werden, dass die entsprechende Anzahl enthält.
    Wenn mehrere Buchstaben gleich häufig vorkommen, sollen alle zurückgegeben werden.

    Beispiel:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    ""Geben Sie bei einer Zeichenfolge, die durch Leerzeichen getrennte Kleinbuchstaben darstellt, ein Wörterbuch zurück,
    das den Buchstaben mit der größten Wiederholung enthält und die entsprechende Anzahl enthält.
    Wenn mehrere Buchstaben gleich vorkommen, geben Sie alle zurück.

    Beispiel:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Aufgabe
    Gegeben sind zwei Zeichenketten s und c. Es sollen alle Zeichen in s gelöscht werden, die gleich einem Zeichen in c sind
    und dann prüfen, ob die resultierende Zeichenkette palindromisch ist.
    Eine Zeichenkette wird als palindrom bezeichnet, wenn sie vorwärts und rückwärts gelesen gleich ist.
    Sie sollten ein Tupel zurückgeben, das die Ergebniszeichenkette und True/False für die Prüfung enthält.
    Beispiel
    For s = "abcde", c = "ae", sollte das Ergebnis ('bcd',False) sein.
    For s = "abcdef", c = "b" sollte das Ergebnis ('acdef',False) sein.
    For s = "abcdedcba", c = "ab", sollte das Ergebnis ('cdedc',True) sein.
    """

def reverse_delete(s,c):
    """Aufgabe
    Wir erhalten zwei Zeichenketten s und c, Sie müssen alle Zeichen in s löschen, die gleich einem beliebigen Zeichen in c sind
    Überprüfen Sie dann, ob die Ergebniszeichenfolge Palindrom ist.
    Ein String wird als Palindrom bezeichnet, wenn er rückwärts wie vorwärts gelesen wird.
    Sie sollten ein Tupel zurückgeben, das die Ergebniszeichenfolge und True/False für die Prüfung enthält.
    Beispiel
    Für s = "abcde", c = "ae", sollte das Ergebnis ('bcd',False) sein.
    Für s = "abcdef", c = "b" sollte das Ergebnis ('acdef',False) sein.
    Für s = "abcdedcba", c = "ab", sollte das Ergebnis ('cdedc',True) sein.
    """

def reverse_delete(s,c):
    ""Aufgabe
    Wir erhalten zwei Zeichenfolgen s und c. Sie müssen alle Zeichen in s löschen, die einem beliebigen Zeichen in c entsprechen.
    Dann prüfen Sie, ob die resultierende Zeichenfolge ein Palindrom ist.
    Eine Zeichenfolge wird als Palindrom bezeichnet, wenn sie rückwärts und vorwärts gleich gelesen wird.
    Sie sollten ein Tupel zurückgeben, das die Ergebniszeichenfolge und True/False für die Prüfung enthält.
    Beispiel
    Für s = "abcde", c = "ae" sollte das Ergebnis ('bcd',False) sein.
    Für s = "abcdef", c = "b" sollte das Ergebnis ('acdef',False) sein.
    Für s = "abcdedcba", c = "ab" sollte das Ergebnis ('cdedc',True) sein.
    ""


def odd_count(lst):
    ""Bei einer Liste von Zeichenfolgen, bei denen jede Zeichenfolge nur aus Ziffern besteht, eine Liste zurückgeben.
    Jedes Element i der Ausgabe sollte "die Anzahl der ungeraden Elemente in der
    Zeichenfolge i der Eingabe" sein, wobei alle i's durch die Anzahl
    der ungeraden Ziffern in der i-ten Zeichenfolge der Eingabe ersetzt werden sollten.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Geben Sie eine Liste von Zeichenketten zurück, wobei jede Zeichenkette nur aus Ziffern besteht.
    Jedes Element i der Ausgabe sollte „sein, wobei alle i durch die Anzahl der ungeraden Ziffern in der i-ten Zeichenkette der Eingabe ersetzt werden.“ sein. Dabei sollten alle i durch die Anzahl
    der ungeraden Ziffern in der i-ten Zeichenkette der Eingabe

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Gegeben ist eine Liste von Zeichenfolgen, wobei jede Zeichenfolge nur aus Ziffern besteht, gibt eine Liste zurück.
    Jedes Element i der Ausgabe sollte "die Anzahl der ungeraden Elemente in der
    Zeichenfolge i des Eingangszeichenfolge." sein, wobei alle i durch die Anzahl
    der ungeraden Ziffern in der i-ten Zeichenfolge des Eingangs ersetzt werden.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """


def minSubArraySum(nums):
    """
    Gegeben ist ein Array von ganzen Zahlen nums, finde die minimale Summe eines beliebigen
    nicht-leeren Teilarrays von nums.
    Beispiel
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Gegeben sei ein Array von Ganzzahlen nums. Finde die Mindestsumme aller nicht leeren Unterarrays
    von nums.
    Beispiel
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Sie erhalten ein rechteckiges Raster von Brunnen. Jede Zeile repräsentiert einen einzelnen Brunnen,
    und jede 1 in einer Zeile stellt eine einzelne Einheit Wasser dar.
    Jeder Brunnen hat einen entsprechenden Eimer, der verwendet werden kann, um Wasser daraus zu entnehmen,
    und alle Eimer haben die gleiche Kapazität.
    Ihre Aufgabe ist es, die Eimer zu verwenden, um die Brunnen zu entleeren.
    Geben Sie die Anzahl der Male an, die Sie die Eimer absenken müssen.

    Beispiel 1:
        Eingabe:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Ausgabe: 6

    Beispiel 2:
        Eingabe:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Ausgabe: 5

    Beispiel 3:
        Eingabe:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Ausgabe: 0

    Einschränkungen:
        * Alle Brunnen haben die gleiche Länge.
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Sie erhalten ein rechteckiges Raster aus Brunnen. Jede Reihe stellt einen einzelnen Brunnen dar,
    und jede 1 in einer Reihe stellt eine einzelne Wassereinheit dar.
    Jeder Brunnen hat einen entsprechenden Eimer, mit dem Wasser entnommen werden kann,
    und alle Eimer haben dieselbe Kapazität.
    Ihre Aufgabe ist es, die Brunnen mit den Eimern zu leeren.
    Geben Sie die Anzahl der Male aus, die Sie die Eimer absenken müssen.

    Beispiel 1:
        Eingabe:
          grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
          bucket_capacity : 1
        Ausgabe: 6

    Beispiel 2:
      Eingabe:
        grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
        bucket_capacity : 2
      Ausgabe: 5

    Beispiel 3:
       Eingabe:
        grid : [[0,0,0], [0,0,0]]
        bucket_capacity : 5
      Ausgabe: 0

    Einschränkungen:
        * alle Brunnen haben die gleiche Länge
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Sie erhalten ein rechteckiges Raster von Vertiefungen. Jede Zeile stellt einen einzelnen Brunnen dar,
    und jede 1 in einer Reihe steht für eine einzelne Einheit Wasser.
    Jeder Brunnen verfügt über einen entsprechenden Eimer, aus dem Wasser entnommen werden kann,
    und alle Eimer haben das gleiche Fassungsvermögen.
    Ihre Aufgabe ist es, die Eimer zu verwenden, um die Brunnen zu entleeren.
    Geben Sie an, wie oft Sie die Eimer absenken müssen.

    Beispiel 1:
        Eingabe:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Ausgabe: 6

    Beispiel 2:
        Eingabe:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Ausgabe: 5

    Beispiel 3:
        Eingabe:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Ausgabe: 0

    Einschränkungen:
        * alle Brunnen haben die gleiche Länge
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    In diesem Kata müssen Sie ein Array von nicht-negativen ganzen Zahlen sortieren,
    basierend auf der Anzahl der Einsen in ihrer binären Darstellung in aufsteigender Reihenfolge.
    Bei einer ähnlichen Anzahl von Einsen sortieren Sie basierend auf dem Dezimalwert.

    Muss so implementiert werden:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    In dieser Kata musst Sie ein Array von nicht-negativen ganzen Zahlen sortieren nach
    Anzahl der Einsen in ihrer binären Darstellung in aufsteigender Reihenfolge.
    Sortieren Sie bei ähnlicher Anzahl von Einsen nach dem Dezimalwert.

    Es muss wie folgt implementiert werden:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4])  == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Kata müssen Sie ein Array nicht-negativer Ganzzahlen nach
    der Anzahl der Einsen in ihrer binären Darstellung in aufsteigender Reihenfolge sortieren.
    Bei ähnlicher Anzahl von Einsen sortieren Sie basierend auf dem Dezimalwert.

    Dies muss folgendermaßen implementiert werden:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Gegeben sei ein String s und eine natürliche Zahl n. Sie sollen eine Funktion implementieren, die eine Liste aller Wörter aus dem String s zurückgibt, die genau
    n Konsonanten enthalten, und zwar in der Reihenfolge, in der diese Wörter im String s vorkommen.
    Wenn der String s leer ist, sollte die Funktion eine leere Liste zurückgeben.
    Hinweis: Sie können davon ausgehen, dass der Eingabestring nur Buchstaben und Leerzeichen enthält.
    Beispiele:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    ""

def select_words(s, n):
    """Bei einer gegebenen Zeichenkette s und einer natürlichen Zahl n haben Sie die Aufgabe,
    Eine Funktion, die eine Liste aller Wörter aus der Zeichenkette s zurückgibt, die genau n Konsonanten enthalten, in der Reihenfolge, in der diese Wörter in der Zeichenkette s erscheinen.
    Wenn die Zeichenkette s leer ist, sollte die Funktion eine leere Liste zurückgeben.
    Hinweis: Sie können davon ausgehen, dass die Eingabezeichenfolge nur Buchstaben und Leerzeichen enthält.
    Beispiele:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Bei einer Zeichenkette s und einer natürlichen Zahl n haben Sie die Aufgabe, eine Funktion zu implementieren
    eine Funktion zu implementieren, die eine Liste aller Wörter der Zeichenkette s zurückgibt, die genau
    n Konsonanten enthalten, in der Reihenfolge, in der diese Wörter in der Zeichenkette s vorkommen.
    Wenn die Zeichenkette s leer ist, soll die Funktion eine leere Liste zurückgeben.
    Hinweis: Sie können davon ausgehen, dass die Eingabezeichenfolge nur Buchstaben und Leerzeichen enthält.
    Beispiele:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Sie erhalten ein Wort. Ihre Aufgabe ist es, den nächsten Vokal zu finden, der sich zwischen
    zwei Konsonanten auf der rechten Seite des Wortes befindet (Groß- und Kleinschreibung beachten).

    Vokale am Anfang und Ende zählen nicht. Gibt eine leere Zeichenkette zurück, wenn Sie keinen
    Vokal finden, der die vorherige Bedingung erfüllt.

    Sie können davon ausgehen, dass die gegebene Zeichenkette nur englische Buchstaben enthält.

    Beispiel:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    ""Sie erhalten ein Wort. Ihre Aufgabe ist es, den nächsten Vokal zu finden, der zwischen
    zwei Konsonanten auf der rechten Seite des Wortes steht (Groß-/Kleinschreibung beachten).

    Vokale am Anfang und Ende zählen nicht. Geben Sie eine leere Zeichenfolge zurück, wenn Sie
    keinen Vokal gefunden haben, der die obige Bedingung erfüllt.

    Sie können davon ausgehen, dass die angegebene Zeichenfolge nur englische Buchstaben enthält.

    Beispiel:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Sie erhalten ein Wort. Ihre Aufgabe besteht darin, den nächsten Vokal zu finden, der zwischen
    zwei Konsonanten auf der rechten Seite des Wortes steht (Groß-/Kleinschreibung beachten).

    Vokale am Anfang und Ende zählen nicht. Wenn Sie keinen Vokal finden, der die oben genannte Bedingung erfüllt, geben Sie eine leere Zeichenfolge zurück.

    Sie können davon ausgehen, dass die angegebene Zeichenfolge nur englische Buchstaben enthält.

    Beispiel:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Sie erhalten eine Liste mit zwei Zeichenketten, die beide nur aus öffnenden
    Klammern '(' oder schließenden Klammern ')' bestehen.
    Ihre Aufgabe besteht darin, zu überprüfen, ob es möglich ist, die beiden Zeichenketten in einer bestimmten Reihenfolge zu verketten,
    sodass die resultierende Zeichenkette gültig ist.
    Eine Zeichenkette S wird genau dann als gültig angesehen, wenn alle Klammern in S
    ausgeglichen sind. Beispiel: Die Zeichenkette '(())()' ist gültig, während die Zeichenkette
    '())' nicht gültig ist.
    Geben Sie „Yes“ zurück, wenn es eine Möglichkeit gibt, eine gute Zeichenkette zu erstellen, und geben Sie andernfalls „No“ zurück.

    Beispiele:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Sie erhalten eine Liste von zwei Zeichenfolgen, die beiden Zeichenfolgen bestehen nur aus
    öffnenden Klammern '(' oder schließenden Klammern ')'.
    Ihre Aufgabe ist es zu überprüfen, ob es möglich ist, die beiden Zeichenfolgen in
    einer bestimmten Reihenfolge zu verketten, so dass die resultierende Zeichenfolge gut ist.
    Eine Zeichenfolge S wird als gut betrachtet, wenn und nur wenn alle Klammern in S
    ausgeglichen sind. Zum Beispiel: die Zeichenfolge '(())()' ist gut, während die Zeichenfolge
    '())' es nicht ist.
    Gibt 'Yes' zurück, wenn es einen Weg gibt, eine gute Zeichenfolge zu erstellen, und gibt 'No' zurück, andernfalls.

    Beispiele:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Sie erhalten eine Liste mit zwei Zeichenfolgen, die jeweils nur aus
    öffnenden Klammern '(' oder schließenden Klammern ')' bestehen.
    Ihre Aufgabe ist es, zu überprüfen, ob es möglich ist, die beiden Zeichenfolgen in
    einer bestimmten Reihenfolge zu verketten, so dass die resultierende Zeichenfolge gut ist.
    Eine Zeichenfolge S wird als gut betrachtet, wenn und nur wenn alle Klammern in S
    ausgeglichen sind. Zum Beispiel: die Zeichenfolge '(())()' ist gut, während die Zeichenfolge
    '())' es nicht ist.
    Gibt 'Yes' zurück, wenn es möglich ist, eine gute Zeichenfolge zu erstellen, und 'No' andernfalls.

    Beispiele:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Gegeben ein Array arr von ganzen Zahlen und eine positive ganze Zahl k, gibt eine sortierte Liste
    der Länge k mit den k größten Zahlen in arr zurück.

    Beispiel 1:

        Eingabe: arr = [-3, -4, 5], k = 3
        Ausgabe: [-4, -3, 5]

    Beispiel 2:

        Eingabe: arr = [4, -4, 4], k = 2
        Ausgabe: [4, 4]

    Beispiel 3:

        Eingabe: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Ausgabe: [2]

    Hinweis:
        1. Die Länge des Arrays wird im Bereich von [1, 1000] liegen.
        2. Die Elemente im Array werden im Bereich von [-1000, 1000] liegen.
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Bei einem Array arr aus ganzen Zahlen und einer positiven Ganzzahl k wird eine sortierte Liste zurückgegeben
    der Länge k mit den maximalen k Zahlen in arr.

    Beispiel 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    Beispiel 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    Beispiel 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Anmerkung:
        1. Die Länge des Arrays liegt im Bereich von [1, 1000].
        2. Die Elemente im Array liegen im Bereich von [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Bei einem Array arr von ganzen Zahlen und einer positiven ganzen Zahl k, gib eine sortierte Liste
    der Länge k mit den maximalen k Zahlen in arr zurück.

    Beispiel 1:

        Eingabe: arr = [-3, -4, 5], k = 3
        Ausgabe: [-4, -3, 5]

    Beispiel 2:

        Eingabe: arr = [4, -4, 4], k = 2
        Ausgabe: [4, 4]

    Beispiel 3:

        Eingabe: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Ausgabe: [2]

    Hinweis:
        1. Die Länge des Arrays liegt im Bereich von [1, 1000].
        2. Die Elemente des Arrays liegen im Bereich von [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Bei einer nicht leeren Liste von ganzen Zahlen wird die Summe aller ungeraden Elemente zurückgegeben, die sich in geraden Positionen befinden.

    Beispiele
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Geben Sie bei einer nicht leeren Liste von Ganzzahlen die Summe aller ungeraden Elemente zurück, die sich an geraden Positionen befinden.

    Beispiele
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Bei einer nicht leeren Liste von ganzen Zahlen wird die Summe aller ungeraden Elemente zurückgegeben, die sich an geraden Positionen befinden.

    Beispiele
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Gegeben ein nicht-leeres Array von ganzen Zahlen arr und eine ganze Zahl k, gibt
    die Summe der Elemente mit maximal zwei Ziffern unter den ersten k Elementen von arr zurück.

    Beispiel:

        Eingabe: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Ausgabe: 24 # Summe von 21 + 3

    Einschränkungen:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Gegeben ist ein nicht-leeres Array von ganzen Zahlen arr und eine ganze Zahl k. Gibt die
    Summe der Elemente mit höchstens zwei Ziffern aus den ersten k Elementen von arr zurück.

    Beispiel:

        Eingabe: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Ausgabe: 24 # summe von 21 + 3

    Einschränkungen:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Bei einer nicht leeren Reihe von Ganzzahlen arr und einer Ganzzahl k wird
    die Summe der Elemente mit höchstens zwei Ziffern aus den ersten k Elementen von arr zurückgegeben.

    Beispiel:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

    Einschränkungen:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Gegeben eine positive ganze Zahl n, gibt eine sortierte Liste zurück, die die ungeraden Zahlen in der Collatz-Folge enthält.

    Die Collatz-Vermutung ist eine Vermutung in der Mathematik, die sich auf eine Sequenz bezieht,
    die wie folgt definiert ist: Beginnen Sie mit einer beliebigen positiven ganzen Zahl n. Dann wird jeder Term aus dem
    vorherigen Term wie folgt abgeleitet: Wenn der vorherige Term gerade ist, ist der nächste Term die Hälfte des
    vorherigen Terms. Wenn der vorherige Term ungerade ist, ist der nächste Term das 3-fache des vorherigen Terms
    plus 1. Die Vermutung besagt, dass unabhängig vom Wert von n die Sequenz immer 1 erreichen wird.

    Hinweis:
        1. Collatz(1) ist [1].
        2. Die zurückgegebene Liste ist aufsteigend sortiert.

    Zum Beispiel:
    get_odd_collatz(5) gibt [1, 5] zurück # Die Collatz-Sequenz für 5 ist [5, 16, 8, 4, 2, 1], daher sind die ungeraden Zahlen nur 1 und 5.
    """

def get_odd_collatz(n):
    """
    Geben Sie bei einer positiven ganzen Zahl n eine sortierte Liste zurück, die die ungeraden Zahlen in Kollatz-Reihenfolge enthält.

    Die Collatz-Vermutung ist eine Vermutung in der Mathematik, die eine Folge betrifft, die wie folgt definiert ist
    wie folgt definiert ist: Man beginnt mit einer beliebigen positiven ganzen Zahl n. Dann erhält man jeden Term aus dem
    aus dem vorhergehenden Term wie folgt: Wenn der vorhergehende Term gerade ist, ist der nächste Term die Hälfte des
    des vorhergehenden Terms. Wenn der vorhergehende Term ungerade ist, ist der nächste Term das 3fache des vorhergehenden
    Term plus 1. Die Vermutung ist, dass die Folge unabhängig vom Wert von n immer 1 erreichen wird.

    Hinweis:
        1. Collatz(1) ist [1].
        2. zurückgegebene Liste in aufsteigender Reihenfolge sortiert.

    Zum Beispiel:
    get_odd_collatz(5) gibt [1, 5] zurück # Die Collatz-Sequenz für 5 ist [5, 16, 8, 4, 2, 1], daher sind die ungeraden Zahlen nur 1 und 5.
    """


def valid_date(date):
    """Sie müssen eine Funktion schreiben, die eine gegebene Datumszeichenkette validiert und
    True zurückgibt, wenn das Datum gültig ist, andernfalls False.
    Das Datum ist gültig, wenn alle folgenden Regeln eingehalten werden:
    1. Die Datumszeichenkette ist nicht leer.
    2. Die Anzahl der Tage ist nicht kleiner als 1 und nicht größer als 31 Tage für die Monate 1,3,5,7,8,10,12. Und die Anzahl der Tage ist nicht kleiner als 1 und nicht größer als 30 Tage für die Monate 4,6,9,11. Und die Anzahl der Tage ist nicht kleiner als 1 und nicht größer als 29 für den Monat 2.
    3. Die Monate dürfen nicht kleiner als 1 und nicht größer als 12 sein.
    4. Das Datum muss im Format sein: mm-dd-yyyy

    zum Beispiel:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Sie müssen eine Funktion schreiben, die einen gegebenen Datumsstring validiert und
    Gibt True zurück, wenn das Datum gültig ist, andernfalls False.
    Das Datum ist gültig, wenn alle folgenden Regeln erfüllt sind:
    1. Die Datumszeichenfolge ist nicht leer.
    2. Die Anzahl der Tage beträgt nicht weniger als 1 oder mehr als 31 Tage für die Monate 1, 3, 5, 7, 8, 10, 12. Und die Anzahl der Tage beträgt nicht weniger als 1 oder mehr als 30 Tage für die Monate 4,6,9,11. Und die Anzahl der Tage ist nicht weniger als 1 oder höher als 29 für den Monat 2.
    3. Die Monate sollten nicht kleiner als 1 und nicht höher als 12 sein.
    4. Das Datum sollte folgendes Format haben: MM-TT-JJJJ

    Zum Beispiel:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Du musst eine Funktion schreiben, die eine bestimmte Datumszeichenfolge validiert und
    „True“ zurückgibt, wenn das Datum gültig ist, andernfalls ‚False‘.
    Das Datum ist gültig, wenn alle folgenden Regeln erfüllt sind:
    1. Die Datumszeichenfolge ist nicht leer.
    2. Die Anzahl der Tage ist nicht kleiner als 1 oder größer als 31 Tage für die Monate 1, 3, 5, 7, 8, 10, 12. Und die Anzahl der Tage ist nicht kleiner als 1 oder größer als 30 für die Monate 4, 6, 9, 11. Und die Anzahl der                     Tage ist nicht kleiner als 1 oder größer als 29 für den Monat 2.
    3. Die Monate sollten nicht kleiner als 1 oder größer als 12 sein.
    4. Das Datum sollte im Format mm-dd-yyyy angegeben werden,

     zum Beispiel:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Gegeben ist ein String aus Wörtern. Geben Sie eine Liste der Wörter zurück, die anhand von Leerzeichen getrennt sind. Falls der Text keine Leerzeichen enthält, sollten Sie die Wörter anhand von Kommata ',' trennen. Falls auch keine Kommata vorhanden sind, geben Sie die Anzahl der Kleinbuchstaben mit ungeradem Platz im Alphabet zurück, wobei ord('a') = 0, ord('b') = 1, ... ord('z') = 25.
    Beispiele
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Geben Sie bei einer Zeichenfolge von Wörtern eine Liste zurück, die nach Leerzeichen getrennt sind. Wenn der Text keine Leerzeichen enthält,
    sollten Sie an Kommas trennen, ',' wenn keine Kommas vorhanden sind, sollten Sie die Anzahl der Kleinbuchstaben mit ungerader Position im
    Alphabet zurückgeben, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Beispiele
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Bei einer Zeichenkette von Wörtern soll eine Liste von Wörtern zurückgegeben werden, die durch Leerzeichen getrennt sind; wenn keine Leerzeichen im Text vorhanden sind,
    sollten Sie die Wörter an Kommas aufteilen. ',' wenn keine Kommas vorhanden sind, sollten Sie die Anzahl der Kleinbuchstaben mit ungerader Position im Alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Beispiele
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Bei einer Liste mit Zahlen wird zurückgegeben, ob sie
    in aufsteigender Reihenfolge sortiert sind. Wenn die Liste mehr als ein Duplikat derselben Zahl enthält, wird False zurückgegeben. Es wird angenommen, dass es keine negativen Zahlen und nur ganze Zahlen gibt.

    Beispiele
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Geben Sie bei einer Liste von Zahlen zurück, ob diese in aufsteigender Reihenfolge sortiert sind oder nicht. Wenn die Liste mehr als 1 Duplikat derselben Zahl enthält, geben Sie
    False zurück. Nehmen Sie an, dass keine negativen Zahlen und nur Ganzzahlen vorhanden sind.

    Beispiele
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Gegeben sei eine Liste von Zahlen. Gibt an, ob sie in aufsteigender Reihenfolge sortiert ist oder nicht.
    Wenn die Liste mehr als 1 Duplikat derselben Zahl enthält, gibt sie False zurück.
    Es wird davon ausgegangen, dass keine negativen Zahlen vorhanden sind und nur ganze Zahlen verwendet werden.

    Beispiele:
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Du hast zwei Intervalle,
    Dabei ist jedes Intervall ein Paar ganzer Zahlen. Beispiel: interval = (Start, Ende) = (1, 2).
    Die angegebenen Intervalle werden geschlossen, d.h. das Intervall (Start, Ende)
    Enthält sowohl Start als auch Ende.
    Für jedes gegebene Intervall wird davon ausgegangen, dass sein Anfang kleiner oder gleich seinem Ende ist.
    Ihre Aufgabe besteht darin, zu bestimmen, ob die Länge des Schnitts dieser beiden
    Intervalle eine Primzahl ist.
    Beispiel: Der Schnittpunkt der Intervalle (1, 3), (2, 4) ist (2, 3)
    deren Länge 1 ist, was keine Primzahl ist.
    Wenn die Länge des Schnittpunkts eine Primzahl ist, geben Sie "YES" zurück.
    Andernfalls geben Sie "NO" zurück.
    Wenn sich die beiden Intervalle nicht schneiden, geben Sie "NO" zurück.

    [Eingabe/Ausgabe] Beispiele:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Sie erhalten zwei Intervalle,
    wobei jedes Intervall ein Paar von ganzen Zahlen ist. Zum Beispiel, Intervall = (Anfang, Ende) = (1, 2).
    Die gegebenen Intervalle sind geschlossen, was bedeutet, dass das Intervall (Anfang, Ende)
    sowohl den Anfang als auch das Ende einschließt.
    Für jedes gegebene Intervall wird angenommen, dass sein Anfang kleiner oder gleich seinem Ende ist.
    Es wird angenommen, dass bei jedem Intervall der Anfang kleiner oder gleich dem Ende ist.

    Ihre Aufgabe ist es zu bestimmen, ob die Länge des Schnittpunkts dieser beiden
    Intervalle eine Primzahl ist.
    Zum Beispiel ist der Schnittpunkt der Intervalle (1, 3) und (2, 4)
    das Intervall (2, 3), dessen Länge 1 beträgt und somit keine Primzahl ist.
    Wenn die Länge des Schnittpunkts eine Primzahl ist, geben Sie "YES" zurück,
    andernfalls geben Sie "NO" zurück.
    Wenn sich die beiden Intervalle nicht schneiden, geben Sie "NO" zurück.

    [Beispiele für Eingabe/Ausgabe]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Sie erhalten zwei Intervalle,
    wobei jedes Intervall ein Paar von ganzen Zahlen ist. Zum Beispiel, Intervall = (Anfang, Ende) = (1, 2).
    Die gegebenen Intervalle sind geschlossen, was bedeutet, dass das Intervall (Anfang, Ende)
    sowohl den Anfang als auch das Ende einschließt.
    Für jedes gegebene Intervall wird angenommen, dass sein Anfang kleiner oder gleich seinem Ende ist.
    Ihre Aufgabe ist es zu bestimmen, ob die Länge des Schnittpunkts dieser beiden
    Intervalle eine Primzahl ist.
    Zum Beispiel ist der Schnittpunkt der Intervalle (1, 3), (2, 4) (2, 3),
    dessen Länge 1 ist, was keine Primzahl ist.
    Wenn die Länge des Schnittpunkts eine Primzahl ist, geben Sie "YES" zurück,
    andernfalls geben Sie "NO" zurück.
    Wenn sich die beiden Intervalle nicht schneiden, geben Sie "NO" zurück.

    [Beispiele für Eingabe/Ausgabe]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Sie erhalten ein Array arr mit ganzen Zahlen und müssen Folgendes zurückgeben
    Summe der Beträge der ganzen Zahlen multipliziert mit dem Produkt aller Vorzeichen
    jeder Zahl im Array, dargestellt durch 1, -1 oder 0.
    Hinweis: Bei leerem Array wird None zurückgegeben.

    Beispiel:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Sie erhalten ein Array arr von ganzen Zahlen und müssen
    die Summe der Beträge der ganzen Zahlen multipliziert mit dem Produkt aller Vorzeichen
    der Zahlen im Array, dargestellt durch 1, -1 oder 0.
    Hinweis: Gibt None zurück, wenn arr leer ist.

    Beispiel:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Sie erhalten ein Array arr mit Ganzzahlen und müssen die
    Summe der Beträge der Ganzzahlen multipliziert mit dem Produkt aller Vorzeichen
    jeder Zahl im Array zurückgeben, dargestellt durch 1, -1 oder 0.
    Hinweis: Bei leerem Arr geben Sie None zurück.

    Beispiel:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Gegeben ist ein Gitter mit N Zeilen und N Spalten (N >= 2) und eine positive ganze Zahl k,
    jede Zelle des Gitters enthält einen Wert. Jede ganze Zahl im Intervall [1, N * N]
    erscheint genau einmal in den Zellen des Gitters.

    Sie müssen den minimalen Pfad der Länge k im Gitter finden. Sie können von
    einer beliebigen Zelle aus starten, und in jedem Schritt können Sie sich zu einer der benachbarten Zellen bewegen,
    mit anderen Worten, Sie können zu Zellen gehen, die eine Kante mit Ihrer aktuellen Zelle teilen.
    Beachten Sie, dass ein Pfad der Länge k bedeutet, genau k Zellen zu besuchen (nicht
    notwendigerweise unterschiedliche).
    Sie DÜRFEN das Gitter nicht verlassen.
    Ein Pfad A (der Länge k) wird als kleiner als ein Pfad B (der Länge k) betrachtet, wenn
    nach dem Erstellen der sortierten Listen der Werte in den Zellen, durch die A und B verlaufen
    (nennen wir sie lst_A und lst_B), lst_A lexikographisch kleiner ist als lst_B, mit anderen Worten,
    es existiert ein ganzzahliger Index i (1 <= i <= k) so dass lst_A[i] < lst_B[i] und für alle j (1 <= j < i) haben wir
    lst_A[j] = lst_B[j].
    Es ist garantiert, dass die Antwort eindeutig ist.
    Geben Sie eine sortierte Liste der Werte in den Zellen zurück, durch die der minimale Pfad verläuft.

    Beispiele:

        Eingabe: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Ausgabe: [1, 2, 1]

        Eingabe: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Ausgabe: [1]
    """

def minPath(grid, k):
    """
    Gegeben ist ein Gitter mit N Zeilen und N Spalten (N >= 2) und einer positiven ganzen Zahl k,
    enthält jede Zelle des Gitters einen Wert. Jede ganze Zahl aus dem Bereich [1, N * N]
    einschließlich kommt genau einmal in den Zellen des Gitters vor.

    Du musst den kleinsten Weg der Länge k im Gitter finden. Du kannst von
    von einer beliebigen Zelle aus starten und in jedem Schritt zu einer beliebigen Nachbarzelle gehen,
    mit anderen Worten, du kannst zu Zellen gehen, die eine Kante mit deiner aktuellen
    Zelle teilen.
    Bitte beachten Sie, dass ein Pfad der Länge k bedeutet, dass genau k Zellen besucht werden (nicht
    notwendigerweise verschieden).
    Du kannst NICHT über das Raster hinausgehen.
    Ein Pfad A (der Länge k) wird als weniger lang angesehen als ein Pfad B (der Länge k), wenn
    nach Erstellung der geordneten Listen der Werte auf den Zellen, durch die A und B gehen
    durchlaufen (nennen wir sie lst_A und lst_B), lst_A lexikografisch kleiner ist
    als lst_B, mit anderen Worten, es gibt einen ganzzahligen Index i (1 <= i <= k)
    so dass lst_A[i] < lst_B[i] und für jedes j (1 <= j < i) gilt
    lst_A[j] = lst_B[j].
    Es ist garantiert, dass die Antwort eindeutig ist.
    Gibt eine geordnete Liste der Werte auf den Zellen zurück, durch die der minimale Pfad verläuft.

    Beispiele:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    Gegeben ist ein Gitter mit N Zeilen und N Spalten (N >= 2) und eine positive ganze Zahl k.
    Jede Zelle des Gitters enthält einen Wert. Jede ganze Zahl im Intervall [1, N * N]
    erscheint genau einmal in den Zellen des Gitters.

    Sie müssen den minimalen Pfad der Länge k im Gitter finden. Sie können bei jeder beliebigen Zelle starten,
    und in jedem Schritt können Sie sich zu einer der benachbarten Zellen bewegen, das heißt, zu Zellen,
    die eine Kante mit Ihrer aktuellen Zelle teilen.
    Beachten Sie, dass ein Pfad der Länge k bedeutet, genau k Zellen zu besuchen
    (nicht notwendigerweise unterschiedliche Zellen).
    Sie DÜRFEN das Gitter nicht verlassen.

    Ein Pfad A (der Länge k) wird als kleiner als ein Pfad B (der Länge k) betrachtet, wenn
    nach dem Erstellen der sortierten Listen der Werte in den Zellen,
    durch die A und B verlaufen (nennen wir sie lst_A und lst_B), lst_A lexikographisch kleiner ist als lst_B.
    Mit anderen Worten, es existiert ein ganzzahliger Index i (1 <= i <= k),
    so dass lst_A[i] < lst_B[i] und für alle j (1 <= j < i)
    gilt: lst_A[j] = lst_B[j].

    Es ist garantiert, dass die Antwort eindeutig ist.
    Geben Sie eine sortierte Liste der Werte in den Zellen zurück, durch die der minimale Pfad verläuft.

    Beispiele:

        Eingabe: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Ausgabe: [1, 2, 1]

        Eingabe: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Ausgabe: [1]
    """


def tri(n):
    """Jeder kennt die Fibonacci-Folge, sie wurde von Mathematikern
    im Laufe der letzten Jahrhunderte eingehend untersucht. Was die Leute jedoch nicht wissen, ist die Tribonacci-Folge.
    Die Tribonacci-Folge ist durch die Rekurrenz definiert:
    tri(1) = 3
    tri(n) = 1 + n / 2, wenn n gerade ist.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), wenn n ungerade ist.
    Zum Beispiel:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Sie erhalten eine nicht negative ganze Zahl n und müssen eine Liste der
    n + 1 ersten Zahlen der Tribonacci-Folge zurückgeben.
    Beispiele:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Jeder kennt die Fibonacci-Folge, sie wurde von Mathematikern in den letzten
    den letzten Jahrhunderten intensiv untersucht. Was die Leute jedoch nicht wissen, ist die Tribonacci-Folge.
    Die Tribonacci-Folge ist durch die Rekursion definiert:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n is even.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
    Zum Beispiel:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Sie erhalten eine nichtnegative ganze Zahl n und müssen eine Liste mit den
    ersten n + 1 Zahlen der Tribonacci-Folge zurückgeben.
    Beispiele:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Jeder kennt die Fibonacci-Folge, sie wurde von Mathematikern im Laufe der letzten Jahrhunderte studiert.
    Was die Leute jedoch nicht wissen, ist die Tribonacci-Folge.
    Die Tribonacci-Folge wird durch die Wiederholung definiert:
    tri(1) = 3
    tri(n) = 1 + n / 2, wenn n gerade ist.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), wenn n ungerade ist.
    Zum Beispiel:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Wenn Sie eine nicht-negative Ganzzahl n erhalten, geben Sie eine Liste der ersten n + 1 Zahlen der Tribonacci-Folge zurück.
    Beispiele:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Bei einer positiven ganzen Zahl n wird das Produkt der ungeraden Ziffern zurückgegeben.
    Gibt 0 zurück, wenn alle Ziffern gerade sind.
    Zum Beispiel:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Bei einer positiven Ganzzahl n wird das Produkt der ungeraden Ziffern zurückgegeben.
    Gibt 0 zurück, wenn alle Ziffern gerade sind.
    Zum Beispiel:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Bei einer positiven Ganzzahl n wird das Produkt der ungeraden Ziffern zurückgegeben.
    Gibt 0 zurück, wenn alle Ziffern gerade sind.
    Beispiel:
    digits(1) == 1
    digits(4) == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Erstellen Sie eine Funktion, die eine Zeichenfolge als Eingabe akzeptiert, die nur eckige Klammern enthält.
    Die Funktion sollte True nur dann zurückgeben, wenn eine gültige Teilsequenz von eckigen Klammern vorhanden ist
    wobei mindestens eine eckige Klammer in der Teilsequenz verschachtelt ist.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Erstellen Sie eine Funktion, die eine Zeichenkette als Eingabe annimmt, die nur eckige Klammern enthält.
    Die Funktion soll nur dann True zurückgeben, wenn es eine gültige Teilsequenz von Klammern gibt
    gibt, bei der mindestens eine Klammer in der Unterfolge verschachtelt ist.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Erstellen Sie eine Funktion, die als Eingabe eine Zeichenfolge verwendet, die nur eckige Klammern enthält.
    Die Funktion sollte genau dann True zurückgeben, wenn es eine gültige Teilfolge von Klammern gibt,
    wobei mindestens eine Klammer in der Teilfolge verschachtelt ist.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """Sie erhalten eine Liste mit Zahlen.
    Sie müssen die Summe der Quadratzahlen in der angegebenen Liste zurückgeben und
    jedes Element in der Liste zuerst auf den oberen int(Ceiling) runden.
    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 14 sein
    Für lst = [1,4,9] sollte die Ausgabe 98 sein
    Für lst = [1,3,5,7] sollte die Ausgabe 84 sein
    Für lst = [1.4,4.2,0] sollte die Ausgabe 29 sein
    Für lst = [-2.4,1,1] sollte die Ausgabe 6 sein

    """

def sum_squares(lst):
    """Du bekommst eine Liste mit Nummern.
    Sie müssen die Summe der quadrierten Zahlen in der angegebenen Liste zurückgeben,
    wobei jedes Element in der Liste zuerst auf das nächsthöhere ganze Zahl (Ceiling) gerundet wird.
    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 14 sein
    Für lst = [1,4,9] sollte die Ausgabe 98 sein
    Für lst = [1,3,5,7] sollte die Ausgabe 84 sein
    Für lst = [1.4,4.2,0] sollte die Ausgabe 29 sein
    Für lst = [-2.4,1,1] sollte die Ausgabe 6 sein

    """

def sum_squares(lst):
    """Sie erhalten eine Liste mit Zahlen.
    Sie müssen die Summe der quadrierten Zahlen in der angegebenen Liste zurückgeben,
    und jedes Element in der Liste zuerst auf die obere int(Ceiling)-Grenze runden.
    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 14 sein
    Für lst = [1,4,9] sollte die Ausgabe 98 sein
    Für lst = [1,3,5,7] sollte die Ausgabe 84 sein
    Für lst = [1.4,4.2,0] sollte die Ausgabe 29 sein
    Für lst = [-2.4,1,1] sollte die Ausgabe 6 sein

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Erstellen Sie eine Funktion, die True zurückgibt, wenn das letzte Zeichen
    einer gegebenen Zeichenkette ein alphabetisches Zeichen ist und nicht
    Teil eines Wortes ist, und andernfalls False.
    Hinweis: „Wort“ ist eine Gruppe von Zeichen, die durch ein Leerzeichen getrennt sind.

    Beispiele:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Erstellen Sie eine Funktion, die True zurückgibt, wenn das letzte Zeichen
    einer gegebenen Zeichenfolge ein alphabetisches Zeichen ist und nicht
    Teil eines Wortes ist, und andernfalls False.
    Hinweis: „Wort“ ist eine Gruppe von Zeichen, die durch Leerzeichen getrennt sind.

    Beispiele:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Erstellen Sie eine Funktion, die True zurückgibt, wenn das letzte Zeichen
    ein alphabetisches Zeichen ist und kein
    Teil eines Wortes und andernfalls False zurückgibt.
    Hinweis: "Wort" ist eine Gruppe von Zeichen, die durch Leerzeichen getrennt sind.

    Beispiele:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Erstellen Sie eine Funktion, die den größten Index eines Elements zurückgibt, der
    nicht größer oder gleich dem unmittelbar vorhergehenden Element ist. Wenn
    ein solches Element nicht existiert, geben Sie -1 zurück. Das angegebene Array enthält keine
    doppelten Werte.

    Beispiele:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Erstellen Sie eine Funktion, die den größten Index eines Elements zurückgibt, das
    nicht größer oder gleich dem unmittelbar vorhergehenden Element ist. Wenn
    Da kein solches Element vorhanden ist, wird -1 zurückgegeben. Das angegebene Array enthält nicht
    Doppelte Werte.

    Beispiele:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    ""Erstellen Sie eine Funktion, die den größten Index eines Elements zurückgibt, das
    nicht größer oder gleich dem unmittelbar vorhergehenden Element ist. Wenn
    kein solches Element existiert, geben Sie -1 zurück. Das angegebene Array enthält keine
    doppelten Werte.

    Beispiele:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    ""


def largest_smallest_integers(lst):
    '''
    Erstellen Sie eine Funktion, die ein Tupel (a, b) zurückgibt, wobei „a“
    die größte der negativen Ganzzahlen und „b“ die kleinste
    der positiven Ganzzahlen in einer Liste ist.
    Wenn es keine negativen oder positiven Ganzzahlen gibt, geben Sie sie als None zurück.

    Beispiele:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Erstellen Sie eine Funktion, die ein Tupel (a, b) zurückgibt, wobei „a“
    die größte negative ganze Zahl und ‚b‘ die kleinste
    positive ganze Zahl in einer Liste ist.
    Wenn es keine negativen oder positiven ganzen Zahlen gibt, geben Sie sie als ‚None‘ zurück.

    Beispiele:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Erstellen Sie eine Funktion, die ein Tupel (a, b) zurückgibt, wobei 'a'
    die größte negative ganze Zahl ist, und 'b' ist die kleinste
    positive ganze Zahl in einer Liste.
    Wenn keine negativen oder positiven ganzen Zahlen vorhanden sind, geben Sie sie als None zurück.

    Beispiele:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Erstellen Sie eine Funktion, die ganze Zahlen, Gleitkommazahlen oder Zeichenfolgen verwendet, die
    reelle Zahlen darstellt und gibt die größere Variable in ihrem ursprünglichen Datentyp zurück.
    Gibt None zurück, wenn die Werte gleich sind.
    Hinweis: Wenn eine reelle Zahl als Zeichenfolge dargestellt wird, kann das Dezimaltrennzeichen . oder , sein

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    ""
    Erstellen Sie eine Funktion, die Ganzzahlen, Gleitkommazahlen oder Zeichenfolgen verwendet, die
    reelle Zahlen darstellen, und die größere Variable in ihrem angegebenen Variablentyp zurückgibt.
    Gibt None zurück, wenn die Werte gleich sind.
    Hinweis: Wenn eine reelle Zahl als Zeichenfolge dargestellt wird, kann die Gleitkommazahl . oder , sein.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Erstellen Sie eine Funktion, die Ganzzahlen, Gleitkommazahlen oder Zeichenketten als
    reelle Zahlen darstellen, und die größere Variable des angegebenen Variablentyps zurückgibt.
    Geben Sie None zurück, wenn die Werte gleich sind.
    Hinweis: Wenn eine reelle Zahl als String dargestellt wird, kann die Fließkommazahl . oder ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Bewerten Sie, ob die gegebene Zahl n als Summe von genau 4 positiven geraden Zahlen geschrieben werden kann.
    Beispiel
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Berechne, ob die gegebene Zahl n als Summe von genau 4 positiven geraden Zahlen geschrieben werden kann
    Beispiel
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Bewerten Sie, ob die gegebene Zahl n als Summe von genau 4 positiven geraden Zahlen geschrieben werden kann
    Beispiel
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Die brasilianische Fakultät ist definiert als:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    wobei n > 0

    Zum Beispiel:
    >>> special_factorial(4)
    288

    Die Funktion erhält eine ganze Zahl als Eingabe und muss die spezielle
    Fakultät dieser Zahl zurückgeben.
    """

def special_factorial(n):
    """Das brasilianische Fakultät ist definiert als:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    wobei n > 0

    Zum Beispiel:
    >>> special_factorial(4)
    288

    Die Funktion erhält eine ganze Zahl als Eingabe und muss die spezielle
    Fakultät dieser Zahl zurückgeben.
    """


def fix_spaces(text):
    """
    Ersetzen Sie bei einem gegebenen String-Text alle Leerzeichen darin durch Unterstriche,
    und wenn ein String mehr als 2 aufeinanderfolgende Leerzeichen hat,
    ersetzen Sie alle aufeinanderfolgenden Leerzeichen durch -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Gegeben ist ein Textstring, ersetze alle Leerzeichen durch Unterstriche,
    und wenn ein String mehr als 2 aufeinanderfolgende Leerzeichen hat,
    dann ersetze alle aufeinanderfolgenden Leerzeichen durch -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Ersetzen Sie bei einem gegebenen String alle Leerzeichen durch Unterstriche,
    und wenn eine String mehr als 2 aufeinanderfolgende Leerzeichen hat,
    Ersetzen Sie dann alle aufeinanderfolgenden Leerzeichen durch -
    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """