def file_name_check(file_name):
    """Erstellen Sie eine Funktion, die eine Zeichenkette nimmt, die den Namen einer Datei darstellt, und
    'Yes' zurückgibt, wenn der Dateiname gültig ist, und 'No' zurückgibt, wenn nicht.
    Ein Dateiname gilt als gültig, wenn und nur wenn alle folgenden Bedingungen erfüllt sind:
    - Es dürfen nicht mehr als drei Ziffern ('0'-'9') im Dateinamen enthalten sein.
    - Der Dateiname enthält genau einen Punkt '.'
    - Die Teilzeichenkette vor dem Punkt darf nicht leer sein und muss mit einem Buchstaben des
    lateinischen Alphabets ('a'-'z' und 'A'-'Z') beginnen.
    - Die Teilzeichenkette nach dem Punkt muss eine der folgenden sein: ['txt', 'exe', 'dll']
    Beispiele:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (der Name muss mit einem Buchstaben des lateinischen Alphabets beginnen)
    """

def file_name_check(file_name):
    """Erstellen Sie eine Funktion, die eine Zeichenkette, die den Namen einer Datei darstellt, annimmt und
    'Ja' zurückgibt, wenn der Dateiname gültig ist, und andernfalls 'Nein' zurückgibt.
    Der Name einer Datei wird nur dann als gültig angesehen, wenn alle folgenden Bedingungen erfüllt sind
    erfüllt sind:
    - Der Dateiname sollte nicht mehr als drei Ziffern ('0'-'9') enthalten.
    - Der Name der Datei enthält genau einen Punkt '.'.
    - Die Teilzeichenkette vor dem Punkt darf nicht leer sein und beginnt mit einem Buchstaben aus
    des lateinischen Alphabets ('a'-'z' und 'A'-'Z').
    - Die Teilzeichenkette nach dem Punkt sollte eine der folgenden sein: ['txt', 'exe', 'dll']
    Beispiele:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (the name should start with a latin alphapet letter)
    """

def file_name_check(file_name):
    """Erstellen Sie eine Funktion, die einen String verwendet, der den Namen einer Datei darstellt, und
    'Yes', wenn der Name der Datei gültig ist, andernfalls 'No'.
    Der Name einer Datei gilt nur dann als gültig, wenn alle folgenden Bedingungen
    erfüllt sind:
    - Der Dateiname sollte nicht mehr als drei Ziffern ('0'-'9') enthalten.
    - Der Dateiname enthält genau einen Punkt '.'
    - Die Teilzeichenfolge vor dem Punkt sollte nicht leer sein und beginnt mit einem Buchstaben des
    dem lateinischen Alphabet ('a'-'z' und 'A'-'Z').
    - Die Teilzeichenfolge nach dem Punkt sollte eine der folgenden sein: ['txt', 'exe', 'dll']
    Beispiele:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (der Name sollte mit einem lateinischen Alphabetsbuchstaben beginnen)
    """


def sum_squares(lst):
    """"
    Diese Funktion nimmt eine Liste von Ganzzahlen. Für alle Einträge in der Liste quadriert die Funktion den Eintrag, wenn sein Index ein Vielfaches von 3 ist, und kubiert den Eintrag, wenn sein Index ein Vielfaches von 4, aber kein Vielfaches von 3 ist. Die Funktion ändert die Einträge in der Liste nicht, deren Indizes weder ein Vielfaches von 3 noch von 4 sind. Die Funktion gibt dann die Summe aller Einträge zurück.

    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 6 sein
    Für lst = [] sollte die Ausgabe 0 sein
    Für lst = [-1,-5,2,-1,-5] sollte die Ausgabe -126 sein
    """

def sum_squares(lst):
    """
    Diese Funktion nimmt eine Liste von ganzen Zahlen. Für alle Einträge in der Liste wird die Funktion den ganzzahligen Eintrag quadriert,
    wenn sein Index ein Vielfaches von 3 ist, und den ganzzahligen Eintrag kubiert, wenn sein Index ein Vielfaches von 4 und kein Vielfaches von 3 ist.
    Die Funktion wird die Einträge in der Liste nicht ändern, deren Indizes keine Vielfachen von 3 oder 4 sind.
    Die Funktion gibt dann die Summe aller Einträge zurück.

    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 6 sein
    Für lst = [] sollte die Ausgabe 0 sein
    Für lst = [-1,-5,2,-1,-5] sollte die Ausgabe -126 sein
    """

def sum_squares(lst):
    """"
    Diese Funktion akzeptiert eine Liste von ganzen Zahlen. Für alle Einträge in der Liste quadriert die Funktion den ganzzahligen Eintrag, wenn sein Index ein
    Vielfaches von 3 und den ganzzahligen Eintrag hoch drei, wenn sein Index ein Vielfaches von 4 und nicht ein Vielfaches von 3 ist. Die Funktion wird nicht ändern
    die Einträge in der Liste, deren Indizes nicht ein Vielfaches von 3 oder 4 sind. Die Funktion gibt dann die Summe aller Einträge zurück.

    Beispiele:
    Für lst = [1,2,3] sollte die Ausgabe 6 sein
    Für lst = [] sollte die Ausgabe 0 sein
    Für lst = [-1,-5,2,-1,-5] sollte die Ausgabe -126 sein
    """


def words_in_sentence(sentence):
    """
    Sie erhalten eine Zeichenkette, die einen Satz darstellt,
    der Satz enthält einige Wörter, die durch ein Leerzeichen getrennt sind,
    und Sie müssen eine Zeichenkette zurückgeben, die die Wörter des ursprünglichen Satzes enthält,
    deren Längen Primzahlen sind,
    die Reihenfolge der Wörter in der neuen Zeichenkette muss die gleiche sein wie im Original.

    Beispiel 1:
        Eingabe: sentence = "This is a test"
        Ausgabe: "is"

    Beispiel 2:
        Eingabe: sentence = "lets go for swimming"
        Ausgabe: "go for"

    Einschränkungen:
        * 1 <= len(sentence) <= 100
        * der Satz enthält nur Buchstaben
    """

def words_in_sentence(sentence):
    """
    Sie erhalten eine Zeichenfolge, die einen Satz darstellt,
    Der Satz enthält einige Wörter, die durch ein Leerzeichen getrennt sind,
    und Sie müssen eine Zeichenkette zurückgeben, die die Wörter aus dem ursprünglichen Satz enthält,
    deren Längen Primzahlen sind,
    Die Reihenfolge der Wörter in der neuen Zeichenfolge sollte mit der ursprünglichen übereinstimmen.

    Beispiel 1:
        Input: sentence = "This is a test"
        Output: "is"

    Beispiel 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    Einschränkungen:
        * 1 <= len(sentence) <= 100
        * Der Satz enthält nur Buchstaben
    """

def words_in_sentence(sentence):
    """
    Sie erhalten eine Zeichenkette, die einen Satz darstellt,
    der Satz enthält einige durch ein Leerzeichen getrennte Wörter,
    und man muss eine Zeichenkette zurückgeben, die die Wörter des ursprünglichen Satzes enthält,
    deren Längen Primzahlen sind,
    die Reihenfolge der Wörter in der neuen Zeichenkette muss mit der ursprünglichen Zeichenkette übereinstimmen.

    Beispiel 1:
        Eingabe: sentence = "This is a test"
        Ausgabe: "is"

    Beispiel 2:
        Eingabe: sentence = "lets go for swimming"
        Ausgabe: "go for"

    Einschränkungen:
        * 1 <= len(sentence) <= 100
        * der Satz enthält nur Buchstaben
    """


def simplify(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu implementieren, die den Ausdruck
    x * n vereinfacht. Die Funktion gibt True zurück, wenn x * n zu einer ganzen Zahl ausgewertet wird, und False
    andernfalls. Sowohl x als auch n sind Zeichenkettenrepräsentationen eines Bruchs und haben das folgende Format,
    <Zähler>/<Nenner>, wobei sowohl der Zähler als auch der Nenner positive ganze Zahlen sind.

    Sie können davon ausgehen, dass x und n gültige Brüche sind und keinen Nenner von null haben.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu implementieren, die den Ausdruck vereinfacht
    x * n. Die Funktion gibt True zurück, wenn x * n zu einer ganzen Zahl ausgewertet wird und False
    sonst. Sowohl x als auch n sind Zeichenfolgendarstellungen eines Bruchs und haben das folgende Format:
    <numerator>/<denominator>, wobei sowohl Zähler als auch Nenner positive ganze Zahlen sind.

    Sie können davon ausgehen, dass x und n gültige Brüche sind und keine Null als Nenner haben.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Ihre Aufgabe ist es, eine Funktion zu implementieren, die den Ausdruck x * n vereinfacht.
    x * n. Die Funktion gibt True zurück, wenn x * n eine ganze Zahl ergibt, und False
    andernfalls. Sowohl x als auch n sind String-Darstellungen eines Bruchs und haben das folgende Format,
    <Zähler>/<Nenner>, wobei sowohl Zähler als auch Nenner positive ganze Zahlen sind.

    Sie können davon ausgehen, dass x und n gültige Brüche sind und keine Null im Nenner haben.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    Schreiben Sie eine Funktion, die die angegebene Liste von Ganzzahlen
    in aufsteigender Reihenfolge nach der Summe ihrer Ziffern sortiert.
    Hinweis: Wenn es mehrere Elemente mit ähnlicher Summe ihrer Ziffern gibt,
    sortieren Sie sie basierend auf ihrem Index in der ursprünglichen Liste.

    Beispiel:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Schreiben Sie eine Funktion, die die angegebene Liste von Ganzzahlen
    in aufsteigender Reihenfolge nach der Summe ihrer Ziffern sortiert.
    Hinweis: Wenn es mehrere Elemente mit ähnlicher Summe ihrer Ziffern gibt,
    ordnen Sie sie nach ihrem Index in der ursprünglichen Liste.

    Zum Beispiel:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Schreiben Sie eine Funktion, die die gegebene Liste von ganzen Zahlen
    in aufsteigender Reihenfolge nach der Summe ihrer Ziffern sortiert.
    Hinweis: Wenn es mehrere Elemente mit einer ähnlichen Summe ihrer Ziffern gibt,
    sortieren Sie sie nach ihrem Index in der ursprünglichen Liste.

    Zum Beispiel:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Schreiben Sie eine Funktion, die ein Array von Zahlen als Eingabe erhält und
    die Anzahl der Elemente im Array zurückgibt, die größer als 10 sind und
    deren erste sowie letzte Ziffer ungerade (1, 3, 5, 7, 9) sind.
    Zum Beispiel:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Schreiben Sie eine Funktion, die ein Array von Zahlen als Eingabe verwendet und
    die Anzahl der Elemente im Array zurückgibt, die größer als 10 sind und bei denen sowohl
    die erste als auch die letzte Ziffer einer Zahl ungerade sind (1, 3, 5, 7, 9).
    Zum Beispiel:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Schreiben Sie eine Funktion, die ein Array von Zahlen als Eingabe verwendet und die Anzahl der Elemente im Array zurückgibt, die größer als 10 sind und deren erste und letzte
    Ziffern ungerade sind (1, 3, 5, 7, 9).
    Beispiel:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Ihnen wird eine positive ganze Zahl n gegeben. Sie müssen ein Array von ganzen Zahlen a der Länge n erstellen.
        Für jedes i (1 ≤ i ≤ n) ist der Wert von a[i] = i * i - i + 1.
        Gibt die Anzahl der Tripel (a[i], a[j], a[k]) von a zurück, bei denen i < j < k,
    und a[i] + a[j] + a[k] ein Vielfaches von 3 ist.

    Beispiel:
        Eingabe: n = 5
        Ausgabe: 1
        Erklärung:
        a = [1, 3, 7, 13, 21]
        Das einzige gültige Tripel ist (1, 7, 13).
    """

def get_max_triples(n):
    """
    Sie erhalten eine positive ganze Zahl n. Sie müssen ein ganzzahliges Array a der Länge n erstellen.
        Für jedes i (1 ≤ i ≤ n) ist der Wert von a[i] = i * i - i + 1.
        Gibt die Anzahl der Tripel (a[i], a[j], a[k]) von a zurück, wobei i < j < k,
    und a[i] + a[j] + a[k] ein Vielfaches von 3 ist.

    Beispiel :
        Eingabe: n = 5
        Ausgabe: 1
        Erklärung:
        a = [1, 3, 7, 13, 21]
        Das einzige gültige Tripel ist (1, 7, 13).
    """

def get_max_triples(n):
    """
    Sie erhalten eine positive ganze Zahl n. Sie müssen ein Array von ganzen Zahlen a der Länge n erstellen.
        Für jedes i (1 ≤ i ≤ n) ist der Wert von a[i] = i * i - i + 1.
        Gibt die Anzahl der Tripel (a[i], a[j], a[k]) von a zurück, wobei i < j < k,
    und a[i] + a[j] + a[k] ein Vielfaches von 3 ist.

    Beispiel:
        Eingabe: n = 5
        Ausgabe: 1
        Erklärung:
        a = [1, 3, 7, 13, 21]
        Das einzige gültige Tripel ist (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Es gibt acht Planeten in unserem Sonnensystem: der sonnennächste ist Merkur,
    gefolgt von Venus, dann Erde, Mars, Jupiter, Saturn, Uranus, Neptun.
    Schreiben Sie eine Funktion, die zwei Planetennamen als Zeichenketten planet1 und planet2 entgegennimmt.
    Die Funktion soll ein Tupel zurückgeben, das alle Planeten enthält, deren Umlaufbahnen
    sich zwischen der Umlaufbahn von planet1 und der Umlaufbahn von planet2 befinden, geordnet nach
    Nähe zur Sonne.
    Die Funktion soll ein leeres Tupel zurückgeben, wenn planet1 oder planet2
    keine korrekten Planetennamen sind.
    Beispiele
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Es gibt acht Planeten in unserem Sonnensystem: der Sonne am Nächsten gelegene ist Merkur,
    der darauffolgende ist Venus, dann Erde, Mars, Jupiter, Saturn, Uranus, Neptun.
    Schreiben Sie eine Funktion, die zwei Planetennamen als strings planet1 und planet2 annimmt.
    Die Funktion soll ein Tupel zurückgeben, das alle Planeten enthält, deren Umlaufbahnen
    sich zwischen der Umlaufbahn von planet1 und der Umlaufbahn von planet2 befinden, geordnet nach
    dem Abstand zur Sonne.
    Die Funktion soll ein leeres Tupel zurückgeben, wenn planet1 oder planet2
    keine korrekten Planetennamen sind.
    Beispiele
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenfolgen als Parameter akzeptiert,
    die Zeichenfolgen mit ungeraden Längen daraus entfernt
    und die resultierende Liste in sortierter Reihenfolge zurückgibt.
    Die Liste ist immer eine Liste von Zeichenfolgen und niemals ein Zahlenarray
    und kann Duplikate enthalten.
    Die Reihenfolge der Liste sollte aufsteigend nach der Länge jedes Wortes sein, und
    Sie müssen die Liste nach dieser Regel sortiert zurückgeben.
    Wenn zwei Wörter die gleiche Länge haben, sortieren Sie die Liste alphabetisch.
    Die Funktion muss eine Liste von Zeichenfolgen in sortierter Reihenfolge zurückgeben.
    Sie können davon ausgehen, dass alle Wörter die gleiche Länge haben.
    Beispiel:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenketten als Parameter akzeptiert,
    löscht die Zeichenfolgen, die ungerade Längen haben,
    und gibt die Ergebnisliste mit einer sortierten Reihenfolge zurück,
    Die Liste ist immer eine Liste von Zeichenketten und niemals ein Array von Zahlen,
    und es kann Duplikate enthalten.
    Die Reihenfolge der Liste sollte aufsteigend nach der Länge jedes Wortes sein, und Sie
    sollte die nach dieser Regel sortierte Liste zurückgeben.
    Wenn zwei Wörter die gleiche Länge haben, sortieren Sie die Liste alphabetisch.
    Die Funktion sollte eine Liste von Zeichenfolgen in sortierter Reihenfolge zurückgeben.
    Sie können davon ausgehen, dass alle Wörter die gleiche Länge haben.
    Zum Beispiel:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenketten als Parameter annimmt,
    die Zeichenketten mit ungerader Länge aus der Liste löscht,
    und die resultierende Liste in sortierter Reihenfolge zurückgibt,
    Die Liste besteht immer aus Zeichenketten, niemals aus Zahlenfeldern,
    und sie kann Duplikate enthalten.
    Die Reihenfolge der Liste sollte aufsteigend nach der Länge der einzelnen Wörter sein, und Sie
    sollte die Liste nach dieser Regel sortiert zurückgeben.
    Wenn zwei Wörter die gleiche Länge haben, sortieren Sie die Liste alphabetisch.
    Die Funktion sollte eine Liste von Zeichenketten in sortierter Reihenfolge zurückgeben.
    Sie können davon ausgehen, dass Wörter in der Liste die gleiche Länge haben können.
    Zum Beispiel:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Ein einfaches Programm, das den Wert von x zurückgeben soll, wenn n
    eine Primzahl ist, und andernfalls den Wert von y.

    Beispiele:
    für x_or_y(7, 34, 12) == 34
    für x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Ein einfaches Programm, das den Wert von x zurückgeben soll, wenn n
    eine Primzahl ist und andernfalls den Wert von y zurückgibt.

    Beispiele:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Ein einfaches Programm, das den Wert von x zurückgeben sollte, wenn n
    eine Primzahl ist, und den Wert von y andernfalls.

    Beispiele:
    für x_or_y(7, 34, 12) == 34
    für x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Geben Sie bei einer Liste mit Zahlen die Summe der Quadrate der Zahlen
    in der Liste zurück, die ungerade sind. Ignorieren Sie Zahlen, die negativ oder keine ganzen Zahlen sind.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Wenn die Eingabeliste leer ist, geben Sie 0 zurück.
    '''

def double_the_difference(lst):
    '''
    Gegeben eine Liste von Zahlen, gibt die Summe der Quadrate der Zahlen
    in der Liste zurück, die ungerade sind. Ignoriert Zahlen, die negativ oder keine ganzen Zahlen sind.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Wenn die Eingabeliste leer ist, gibt 0 zurück.
    '''

def double_the_difference(lst):
    '''
    Gegeben eine Liste von Zahlen, gibt die Summe der Quadrate der Zahlen
    in der Liste zurück, die ungerade sind. Ignoriert Zahlen, die negativ oder keine Ganzzahlen sind.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Wenn die Eingabeliste leer ist, gibt 0 zurück.
    '''


def compare(game, guess):
    """Ich denke, wir alle erinnern uns an das Gefühl, wenn endlich das Ergebnis eines lang ersehnten Ereignisses bekannt wird.
    Die Gefühle und Gedanken, die Sie in diesem Moment haben, sind wirklich wert, notiert und verglichen zu werden.
    Ihre Aufgabe ist es, festzustellen, ob eine Person die Ergebnisse einer Reihe von Spielen korrekt erraten hat.
    Sie erhalten zwei Arrays mit Punktzahlen und Vermutungen gleicher Länge, wobei jeder Index ein Spiel anzeigt.
    Gibt ein Array der gleichen Länge zurück, das anzeigt, wie weit jede Vermutung entfernt war. Wenn sie richtig geraten haben,
    ist der Wert 0, und andernfalls ist der Wert der absolute Unterschied zwischen der Vermutung und dem Punktestand.

    Beispiel:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Ich denke, wir erinnern uns alle an dieses Gefühl, wenn wir endlich das Ergebnis eines lang erwarteten Ereignisses kennen.
    Die Gefühle und Gedanken, die Sie in diesem Moment haben, sind wirklich wert, notiert und verglichen zu werden.
    Ihre Aufgabe ist es, festzustellen, ob eine Person die Ergebnisse einer Reihe von Spielen korrekt erraten hat.
    Sie erhalten zwei Arrays mit Punktzahlen und Vermutungen gleicher Länge, wobei jeder Index ein Spiel anzeigt.
    Gibt ein Array der gleichen Länge zurück, das anzeigt, wie weit jede Vermutung entfernt war. Wenn sie richtig geraten haben,
    ist der Wert 0, und andernfalls ist der Wert der absolute Unterschied zwischen der Vermutung und dem Punktestand.

    Beispiel:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Ich denke, wir alle kennen das Gefühl, wenn das Ergebnis eines lang ersehnten
    Ereignisses endlich bekannt ist. Die Gefühle und Gedanken, die man in diesem Moment hat,
    sind es definitiv wert, notiert und verglichen zu werden.
    Ihre Aufgabe besteht darin, festzustellen, ob eine Person die Ergebnisse einer Arrays von Spiele richtig erraten hat.
    Sie erhalten zwei gleich lange Arrays von Ergebnissen und Vermutungen, wobei jeder Index eine Spiele anzeigt.
    Geben Sie eine Arrays gleicher Länge zurück, die angibt, wie weit die einzelnen Schätzungen voneinander entfernt waren. Wenn sie richtig geraten haben,
    ist der Wert 0, und wenn nicht, ist der Wert die absolute Differenz zwischen der Schätzung und dem Ergebnis.

    Beispiel:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """Sie erhalten den Namen einer Klasse (eine Zeichenkette) und eine Liste von Erweiterungen.
    Die Erweiterungen werden verwendet, um zusätzliche Klassen zur Klasse zu laden. Die
    Stärke der Erweiterung ist wie folgt: Sei CAP die Anzahl der Großbuchstaben
    im Namen der Erweiterung, und sei SM die Anzahl der Kleinbuchstaben
    im Namen der Erweiterung, die Stärke wird durch den Bruch CAP - SM gegeben.
    Sie müssen die stärkste Erweiterung finden und eine Zeichenkette in diesem
    Format zurückgeben: ClassName.StrongestExtensionName.
    Wenn es zwei oder mehr Erweiterungen mit der gleichen Stärke gibt, müssen Sie
    diejenige wählen, die zuerst in der Liste erscheint.
    Zum Beispiel, wenn Sie "Slices" als Klasse und eine Liste von
    Erweiterungen erhalten: ['SErviNGSliCes', 'Cheese', 'StuFfed'], dann sollten Sie
    'Slices.SErviNGSliCes' zurückgeben, da 'SErviNGSliCes' die stärkste Erweiterung ist
    (ihre Stärke ist -1).
    Beispiel:
    für Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    ""Sie erhalten den Namen einer Klasse (einen String) und eine Liste von Erweiterungen.
    Die Erweiterungen sollen verwendet werden, um zusätzliche Klassen in die Klasse zu laden. Die
    Stärke der Erweiterung ist wie folgt: Lassen Sie CAP die Anzahl der Großbuchstaben
    im Namen der Erweiterung sein und SM die Anzahl der Kleinbuchstaben
    im Namen der Erweiterung. Die Stärke ergibt sich aus dem Bruch CAP - SM.
    Sie sollten die stärkste Erweiterung finden und einen String in diesem
    Format zurückgeben: ClassName.StrongestExtensionName.
    Wenn es zwei oder mehr Erweiterungen mit der gleichen Stärke gibt, sollten Sie
    diejenige wählen, die in der Liste an erster Stelle steht.
    Wenn Sie beispielsweise „Slices“ als Klasse und eine Liste der
    Erweiterungen erhalten: ['SErviNGSliCes', 'Cheese', 'StuFfed'], dann sollten Sie
    'Slices.SErviNGSliCes' zurückgeben, da 'SErviNGSliCes' ist die stärkste Erweiterung
    (ihre Stärke ist -1).
    Beispiel:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Sie erhalten den Namen einer Klasse (eine Zeichenfolge) und eine Liste von Erweiterungen.
    Die Erweiterungen sollen verwendet werden, um zusätzliche Klassen in die Klasse zu laden. Das
    Stärke der Erweiterung ist wie folgt: Sei CAP die Zahl der Großbuchstaben
    Buchstaben im Namen der Erweiterung und SM sei die Anzahl der Kleinbuchstaben
    Im Namen der Erweiterung wird die Stärke durch den Bruch CAP - SM angegeben.
    Sie sollten die stärkste Erweiterung finden und eine Zeichenfolge in diesem
    format: ClassName.StrongestExtensionName.
    Wenn es zwei oder mehr Extensions mit der gleichen Stärke gibt, sollten Sie
    Wählen Sie diejenige aus, die in der Liste an erster Stelle steht.
    Wenn Sie z. B. "Slices" als Klasse und eine Liste der
    Erweiterungen: ['SErviNGSliCes', 'Cheese', 'StuFfed'] dann sollten Sie
    return 'Slices.SErviNGSliCes', da 'SErviNGSliCes' die stärkste Erweiterung ist
    (seine Stärke ist -1).
    Beispiel:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """Sie erhalten 2 Wörter. Sie müssen True zurückgeben, wenn das zweite Wort oder eine seiner Rotationen eine Teilzeichenfolge im ersten Wort ist.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Du hast 2 Wörter. Du musst True zurückgeben, wenn das zweite Wort oder eine seiner Rotationen eine Unterkette im ersten Wort ist
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Sie erhalten 2 Wörter. Sie müssen „Richtig“ auswählen, wenn das zweite Wort oder eine seiner Rotationen eine Teilzeichenfolge im ersten Wort ist.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Gegeben eine ganze Zahl, gibt ein Tupel zurück, das die Anzahl der geraden und ungeraden Ziffern enthält.

     Beispiel:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Angenommen, eine ganze Zahl wird gegeben, gibt ein Tupel zurück, das die Anzahl der geraden und ungeraden Ziffern enthält.

     Beispiel:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Bei einer Ganzzahl wird ein Tupel zurückgegeben, das die Anzahl der geraden und ungeraden Ziffern enthält.

     Example:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Gegeben ist eine positive ganze Zahl, erhalte ihre äquivalente Darstellung
    in römischen Ziffern als Zeichenkette und gib sie in Kleinbuchstaben zurück.
    Einschränkungen: 1 <= num <= 1000

    Beispiele:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Bei einer positiven Ganzzahl wird die entsprechende römische Zahl als Zeichenkette ermittelt
    und in Kleinbuchstaben zurückgegeben.
    Einschränkungen: 1 <= num <= 1000

    Beispiele:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(Zahl):
    """
    Erhalten Sie bei einer positiven Ganzzahl das römische Äquivalent als Zeichenfolge
    und geben Sie es in Kleinbuchstaben zurück.
    Einschränkungen: 1 <= num <= 1000

    Beispiele:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Gegeben sind die Längen der drei Seiten eines Dreiecks. Gibt True zurück, wenn die drei
    Seiten ein rechtwinkliges Dreieck bilden, andernfalls False.
    Ein rechtwinkliges Dreieck ist ein Dreieck, bei dem ein Winkel rechtwinklig ist oder
    90 Grad ist.
    Beispiel:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Gegeben die Längen der drei Seiten eines Dreiecks. Gibt True zurück, wenn die drei
    Seiten ein rechtwinkliges Dreieck bilden, False andernfalls.
    Ein rechtwinkliges Dreieck ist ein Dreieck, in dem ein Winkel rechtwinklig ist oder
    90 Grad beträgt.
    Beispiel:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Gegeben sind die Längen der drei Seiten eines Dreiecks. Gebe True aus, wenn die drei
    Seiten ein rechtwinkliges Dreieck bilden, andernfalls False.
    Ein rechtwinkliges Dreieck ist ein Dreieck, in dem ein Winkel rechtwinklig ist oder
    90 Grad beträgt.
    Beispiel:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenketten akzeptiert.
    Die Liste enthält verschiedene Wörter. Geben Sie das Wort mit der maximalen Anzahl
    einzigartiger Zeichen zurück. Wenn mehrere Zeichenketten die maximale Anzahl einzigartiger Zeichen aufweisen,
    geben Sie diejenige zurück, die in lexikografischer Reihenfolge an erster Stelle steht.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenfolgen akzeptiert.
    Die Liste enthält verschiedene Wörter. Geben Sie das Wort mit der maximalen Anzahl zurück
    von einzigartigen Charakteren. Wenn mehrere Zeichenfolgen die maximale Anzahl von eindeutigen
    Zeichen, geben Sie dasjenige zurück, das in der lexikographischen Reihenfolge an erster Stelle steht.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """Schreiben Sie eine Funktion, die eine Liste von Zeichenfolgen akzeptiert.
    Die Liste enthält verschiedene Wörter. Geben Sie das Wort mit der maximalen Anzahl
    eindeutiger Zeichen zurück. Wenn mehrere Zeichenfolgen die maximale Anzahl eindeutiger
    Zeichen haben, geben Sie das Wort zurück, das in der lexikografischen Reihenfolge zuerst kommt.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    Du bist ein hungriges Kaninchen und hast bereits eine bestimmte Anzahl an Karotten gegessen,
    aber jetzt musst du mehr Karotten essen, um die Mahlzeiten des Tages zu vervollständigen.
    Du solltest ein Array zurückgeben mit [ der gesamten Anzahl der nach deinen Mahlzeiten gegessenen Karotten,
                                            der Anzahl der nach deinen Mahlzeiten verbleibenden Karotten ].
    Wenn nicht genug Karotten übrig sind, isst du alle verbleibenden Karotten, bist aber weiterhin hungrig.

    Beispiel:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variablen:
    @number : Ganzzahl
        Die Anzahl der Karotten, die du bereits gegessen hast.
    @need : Ganzzahl
        Die Anzahl der Karotten, die du essen musst.
    @remaining : Ganzzahl
        Die Anzahl der verbleibenden Karotten, die auf Lager sind.

    Einschränkungen:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Viel Spaß :)
    """

def eat(number, need, remaining):
    """
    Sie sind ein hungriges Kaninchen und haben bereits eine bestimmte Anzahl von Karotten gegessen,
    aber jetzt müssen Sie mehr Karotten essen, um die Mahlzeiten des Tages zu vervollständigen.
    Sie müssen ein Array zurückgeben von [ Gesamtzahl der nach Ihren Mahlzeiten gegessenen Karotten,
                                           die Anzahl der nach Ihren Mahlzeiten verbleibenden Karotten ]
    wenn nicht genug Karotten übrig sind, essen Sie alle verbleibenden Karotten, aber Sie werden noch hungrig sein.

    Beispiel:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variablen:
    @number : ganzzahlig
        die Anzahl der Karotten, die Sie gegessen haben.
    @need : ganzzahlig
        die Anzahl der Karotten, die Sie essen müssen.
    @remaining : ganzzahlig
        die Anzahl der verbleibenden Karotten, die auf Lager sind

    Einschränkung:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Viel Spaß :)
    """

def eat(number, need, remaining):
    """
    Du bist ein hungriges Kaninchen und hast bereits eine bestimmte Anzahl Karotten gegessen,
    aber jetzt müssen du mehr Karotten essen, um die Mahlzeiten des Tages zu vervollständigen.
    du sollten ein Array von [ Gesamtzahl der gegessenen Karotten nach Ihren Mahlzeiten zurückgeben,
                                    die Anzahl der Karotten, die nach den Mahlzeiten übrig bleiben ]
    Wenn nicht genug Karotten übrig sind, isst du alle restlichen Karotten, hast aber trotzdem Hunger.

    Beispiel:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variablen:
    @number : Ganzzahl
        Die Anzahl der Karotten, die du gegessen hast.
    @need : Ganzzahl
        Die Anzahl der Karotten, die du essen müssen.
    @remaining : Ganzzahl
        die Anzahl der verbleibenden Karotten auf Lager

    Einschränkungen:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Viel Spaß :)
    """


def do_algebra(operator, operand):
    """
    Gegeben sind zwei Listen: operator und operand. Die erste Liste enthält grundlegende algebraische Operationen,
    und die zweite Liste ist eine Liste von ganzen Zahlen. Verwenden Sie die beiden gegebenen Listen, um den
    algebraischen Ausdruck zu erstellen und geben Sie die Auswertung dieses Ausdrucks zurück.

    Die grundlegenden algebraischen Operationen:
    Addition ( + )
    Subtraktion ( - )
    Multiplikation ( * )
    Ganzzahlige Division ( // )
    Exponentiation ( ** )

    Beispiel:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Hinweis:
        Die Länge der Liste operator ist gleich der Länge der Liste operand minus eins.
        Operand ist eine Liste von nicht-negativen ganzen Zahlen.
        Die Liste operator hat mindestens einen Operator, und die Liste operand hat mindestens zwei Operanden.

    """

def do_algebra(operator, operand):
    """
    Gegeben sind zwei Listen Operator und Operand. Die erste Liste enthält grundlegende Algebra-Operationen, und
    die zweite Liste ist eine Liste von ganzen Zahlen. Verwenden Sie die beiden gegebenen Listen, um den algebraischen
    Ausdruck zu bilden und die Auswertung dieses Ausdrucks zurückzugeben.

    Die grundlegenden algebraischen Operationen:
    Addition ( + )
    Subtraktion ( - )
    Multiplikation ( * )
    Bodenteilung ( // )
    Potenzierung ( ** )

    Beispiel:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Anmerkung:
        Die Länge der Operatorliste ist gleich der Länge der Operandenliste minus eins.
        Operand ist eine Liste von nichtnegativen ganzen Zahlen.
        Die Operatorenliste hat mindestens einen Operator und die Operandenliste hat mindestens zwei Operanden.

    """


def solve(s):
    """Sie erhalten eine Zeichenkette s.
    Wenn s[i] ein Buchstabe ist, ändern Sie die Groß-/Kleinschreibung von Klein- zu Großbuchstaben oder umgekehrt,
    andernfalls behalten Sie sie bei.
    Wenn die Zeichenkette keine Buchstaben enthält, kehren Sie die Zeichenkette um.
    Die Funktion sollte die resultierende Zeichenkette zurückgeben.
    Beispiele
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Sie bekommst eine Zeichenkette s.
    wenn s[i] ein Buchstabe ist, kehre die Groß- und Kleinschreibung um,
    Ansonsten lassen Sie es unverändert.
    Wenn die Zeichenfolge keine Buchstaben enthält, kehren Sie die Zeichenfolge um.
    Die Funktion sollte die resultierende Zeichenkette zurückgeben.
    Beispiele
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Sie erhalten eine Zeichenkette s.
    Wenn s[i] ein Buchstabe ist, kehren Sie den Fall von Kleinbuchstaben zu Großbuchstaben oder umgekehrt um,
    andernfalls lassen Sie es unverändert.
    Wenn die Zeichenkette keine Buchstaben enthält, kehren Sie die Zeichenkette um.
    Die Funktion muss die resultierende Zeichenkette zurückgeben.
    Beispiele
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Geben Sie bei einem String 'text' dessen MD5-Hash-Äquivalent zurück.
    Wenn 'text' ein leerer String ist, geben Sie None zurück.

    >>> string_to_md5('Hello world')  == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Gegeben sei eine Zeichenkette 'text', gibt deren md5-Hash-Wert zurück.
    Wenn 'text' eine leere Zeichenkette ist, gibt es None zurück.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Bei einer Zeichenkette „text“ wird die entsprechende md5-Hash-Zeichenkette zurückgegeben.
    Wenn „text“ eine leere Zeichenkette ist, geben Sie „None“ zurück.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    Gegeben zwei positive ganze Zahlen a und b, gibt die geraden Zahlen zwischen a
    und b in aufsteigender Reihenfolge zurück.

    Zum Beispiel:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Bei zwei positiven ganzen Zahlen a und b werden die geraden Ziffern zwischen a
    und b in aufsteigender Reihenfolge zurückgegeben.

    Zum Beispiel:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Geben Sie bei zwei positiven ganzen Zahlen a und b die gerade Ziffern zwischen a
    und b aufsteigend zurück.

    Beispiel:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """