def intersection(interval1, interval2):
    """与えられた2つの区間について、
    各区間は整数のペアです。例えば、interval = (start, end) = (1, 2)のような形式です。
    与えられた区間は閉区間であり、区間(start, end)は
    startとendの両方を含みます。
    各区間について、startはendより小さいか等しいと仮定されます。
    あなたの課題は、これら2つの区間の交差部分の長さが
    素数であるかどうかを判定することです。
    例えば、区間(1, 3)と(2, 4)の交差部分は(2, 3)で
    その長さは1であり、素数ではありません。
    交差部分の長さが素数の場合は"YES"を、
    そうでない場合は"NO"を返してください。
    2つの区間が交差しない場合は"NO"を返してください。

    [input/output] samples:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """各区間は整数のペアとして与えられます。
    例えば、interval = (start, end) = (1, 2) のような形式です。
    与えられた区間は閉区間であり、区間 (start, end) は
    start と end の両方を含みます。
    各区間において、start は end 以下であることが前提となっています。
    あなたの課題は、これら2つの区間の交差部分の長さが
    素数であるかどうかを判定することです。
    例えば、区間 (1, 3) と (2, 4) の交差部分は (2, 3) で
    その長さは1であり、素数ではありません。
    交差部分の長さが素数の場合は "YES" を、
    そうでない場合は "NO" を返してください。
    2つの区間が交差しない場合は "NO" を返してください。

    [input/output] samples:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """2つの区間が与えられます。
    各区間は整数のペアで表されます。例えば、interval = (start, end) = (1, 2) のような形式です。
    与えられる区間は閉区間であり、区間(start, end)は開始点startと終了点endの両方を含みます。
    各区間について、開始点は終了点以下であると仮定されます。
    あなたのタスクは、これら2つの区間の共通部分の長さが素数であるかどうかを判定することです。
    例えば、区間(1, 3)と(2, 4)の共通部分は(2, 3)であり、その長さは1です。
    1は素数ではありません。
    共通部分の長さが素数である場合は"YES"を、
    そうでない場合は"NO"を返してください。
    2つの区間に共通部分がない場合も"NO"を返してください。

    [input/output] 例：
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    整数の配列arrが与えられ、各数値の絶対値の合計に
    配列内の各数値の符号（1、-1、または0で表される）の積を
    掛けた値を返す必要があります。
    注意：空の配列の場合はNoneを返します。

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

def prod_signs(arr):
    """
    整数の配列arrが与えられ、配列内の各数値の符号（1、-1、または0で表される）の積に
    すべての整数の絶対値の合計を掛けた値を返す必要があります。
    注意：空の配列arrの場合はNoneを返します。

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

def prod_signs(arr):
    """
    整数の配列arrが与えられます。各数値の絶対値の合計に、
    すべての数値の符号（1、-1、または0で表される）の積を
    掛け合わせた結果を返す必要があります。
    注意：空の配列の場合はNoneを返します。

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


def minPath(grid, k):
    """
    N行N列(N >= 2)のグリッドと正の整数kが与えられ、グリッドの各セルには値が含まれています。
    [1, N * N]の範囲の各整数は、グリッドのセルに正確に1回だけ出現します。

    グリッド内の長さkの最小パスを見つける必要があります。任意のセルから開始でき、
    各ステップで隣接するセルに移動できます。つまり、現在のセルと辺を共有する
    セルに移動できます。
    長さkのパスは、正確にk個のセル(必ずしも異なるとは限りません)を訪問することを
    意味することに注意してください。
    グリッドの外には出られません。
    パスA(長さk)は、AとBが通過するセルの値の順序付きリストを作成した後
    (lst_Aとlst_Bと呼びましょう)、lst_Aがlst_Bより辞書的に小さい場合、
    パスB(長さk)より小さいと見なされます。つまり、整数インデックスi(1 <= i <= k)が
    存在し、lst_A[i] < lst_B[i]であり、任意のj(1 <= j < i)に対して
    lst_A[j] = lst_B[j]となります。
    答えは一意であることが保証されています。
    最小パスが通過するセルの値の順序付きリストを返します。

    例：

        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):
    """
    N行N列（N >= 2）のグリッドと正の整数kが与えられ、グリッドの各セルには値が
    含まれています。[1, N * N]の範囲の整数が、グリッド内のセルにそれぞれ1回ずつ
    正確に出現します。

    グリッド内で長さkの最小経路を見つける必要があります。任意のセルから開始でき、
    各ステップで隣接するセル（現在のセルと辺を共有するセル）に移動できます。
    なお、長さkの経路とは、正確にk個のセル（必ずしも異なるセルである必要はない）
    を訪れることを意味します。
    グリッドの外には出られません。
    長さkの経路Aは、経路A、Bが通過するセルの値を順序付きリストにした場合
    （lst_A、lst_Bとする）、lst_Aが辞書順でlst_Bより小さい場合、経路Bより小さい
    とみなされます。つまり、ある整数インデックスi（1 <= i <= k）が存在し、
    lst_A[i] < lst_B[i]であり、かつj（1 <= j < i）についてlst_A[j] = lst_B[j]
    となります。
    答えは一意であることが保証されています。
    最小経路が通過するセルの値を順序付きリストとして返してください。

    例：

        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):
    """
    N行N列（N >= 2）のグリッドと正の整数kが与えられ、
    グリッドの各セルには値が含まれています。
    範囲[1, N * N]の各整数は、グリッドのセルに正確に1回だけ出現します。

    グリッド内の長さkの最小パスを見つける必要があります。
    任意のセルから開始でき、各ステップで隣接するセルに移動できます。
    つまり、現在のセルと辺を共有するセルに移動できます。
    長さkのパスは、正確にk個のセル（必ずしも異なるとは限りません）を
    訪問することを意味します。
    グリッドの外には出られません。
    長さkのパスAは、AとBが通過するセルの値の順序付きリスト
    （lst_AとlstBと呼ぶ）を作成した後、lst_Aが辞書順でlst_Bより
    小さい場合、パスB（長さk）より小さいと見なされます。
    つまり、整数インデックスi（1 <= i <= k）が存在し、
    lst_A[i] < lst_B[i]であり、任意のj（1 <= j < i）に対して
    lst_A[j] = lst_B[j]となります。
    答えは一意であることが保証されています。
    最小パスが通過するセルの値の順序付きリストを返します。

    例：

        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 tri(n):
    """フィボナッチ数列は誰もが知っており、過去数世紀にわたって数学者によって深く研究されてきました。
    しかし、トリボナッチ数列についてはあまり知られていません。
    トリボナッチ数列は以下の漸化式で定義されます：
    tri(1) = 3
    tri(n) = 1 + n / 2（nが偶数の場合）
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)（nが奇数の場合）
    例：
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    非負整数nが与えられたとき、トリボナッチ数列の最初のn + 1個の数をリストとして返します。
    例：
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """フィボナッチ数列は誰もが知っており、過去数世紀にわたって数学者によって深く研究されてきました。
    しかし、トリボナッチ数列についてはあまり知られていません。
    トリボナッチ数列は以下の漸化式で定義されます：
    tri(1) = 3
    tri(n) = 1 + n / 2（nが偶数の場合）
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)（nが奇数の場合）
    例えば：
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    非負の整数nが与えられた場合、トリボナッチ数列の最初のn + 1個の数値のリストを返す必要があります。
    例：
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """正の整数nが与えられたとき、奇数の桁の積を返します。
    すべての桁が偶数の場合は0を返します。
    例：
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """正の整数nが与えられた場合、奇数の桁の積を返します。
    すべての桁が偶数の場合は0を返します。
    例：
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    角括弧のみを含む文字列を入力として受け取る関数を作成します。
    この関数は、括弧の有効な部分列において、少なくとも1つの括弧が他の括弧の中にネストされている場合にのみTrueを返します。

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

def is_nested(string):
    '''
    入力として角括弧のみを含む文字列を受け取る関数を作成します。
    関数は、部分列の中に少なくとも1つの角括弧がネストされている
    有効な角括弧の部分列が存在する場合にのみTrueを返します。

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


def sum_squares(lst):
    """数値のリストが与えられます。
    リスト内の各要素を切り上げ整数（天井）に丸めた後、
    それぞれの数値を二乗し、その合計を返す必要があります。
    例：
    lst = [1,2,3] の場合、出力は 14 となります
    lst = [1,4,9] の場合、出力は 98 となります
    lst = [1,3,5,7] の場合、出力は 84 となります
    lst = [1.4,4.2,0] の場合、出力は 29 となります
    lst = [-2.4,1,1] の場合、出力は 6 となります

    """

def sum_squares(lst):
    """与えられた数値のリストに対して、
    各要素を切り上げ整数に丸めた後、
    二乗した値の合計を返す必要があります。
    例：
    lst = [1,2,3] の場合、出力は 14
    lst = [1,4,9] の場合、出力は 98
    lst = [1,3,5,7] の場合、出力は 84
    lst = [1.4,4.2,0] の場合、出力は 29
    lst = [-2.4,1,1] の場合、出力は 6

    """

def sum_squares(lst):
    """数値のリストが与えられます。
    与えられたリストの二乗された数値の合計を返す必要があります。
    まず、リストの各要素を上の整数（切り上げ）に丸めます。
    例：
    lst = [1,2,3] の場合、出力は14になります
    lst = [1,4,9] の場合、出力は98になります
    lst = [1,3,5,7] の場合、出力は84になります
    lst = [1.4,4.2,0] の場合、出力は29になります
    lst = [-2.4,1,1] の場合、出力は6になります

    """


def check_if_last_char_is_a_letter(txt):
    '''
    与えられた文字列の最後の文字がアルファベットであり、
    かつそれが単語の一部でない場合はTrueを返し、
    それ以外の場合はFalseを返す関数を作成してください。
    注意：「単語」とは、スペースで区切られた文字の集まりを指します。

    例：
    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):
    '''
    与えられた文字列の最後の文字がアルファベット文字であり、
    単語の一部でない場合はTrueを返し、それ以外の場合はFalseを返す関数を作成します。
    注意: "単語"はスペースで区切られた文字のグループです。

    例:
    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):
    '''
    与えられた文字列の最後の文字がアルファベットであり、
    かつ単語の一部でない場合はTrueを返し、
    それ以外の場合はFalseを返す関数を作成します。
    注意：「単語」とは空白で区切られた文字のグループです。

    例：
    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):
    """配列内で、直前の要素以下である要素の中で最大のインデックスを返す関数を
    作成します。そのような要素が存在しない場合は-1を返します。
    与えられる配列には重複する値は含まれません。

    例：
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """要素が直前の要素以上でない最大のインデックスを返す関数を作成します。
    そのような要素が存在しない場合は -1 を返します。与えられた配列には重複する値は含まれません。

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

def can_arrange(arr):
    """前の要素以下の値を持つ要素の中で、最大のインデックスを返す関数を作成します。
    そのような要素が存在しない場合は-1を返します。与えられる配列には重複する値は
    含まれません。

    例：
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    リスト内の負の整数の中で最大のものを'a'、正の整数の中で最小のものを'b'とする
    タプル(a, b)を返す関数を作成します。
    負の整数や正の整数が存在しない場合は、それぞれNoneを返します。

    例：
    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):
    '''
    リスト内の負の整数の中で最大のものを 'a' とし、
    正の整数の中で最小のものを 'b' とするタプル (a, b) を返す関数を作成します。
    負または正の整数がない場合、それらを None として返します。

    例:
    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):
    '''
    負の整数の中で最大のものを'a'とし、正の整数の中で最小のものを'b'とする
    タプル(a, b)を返す関数を作成します。
    負の整数または正の整数が存在しない場合は、Noneを返します。

    例:
    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):
    """
    整数、浮動小数点数、または実数を表す文字列を受け取り、
    より大きい値を元の変数型のまま返す関数を作成します。
    値が等しい場合はNoneを返します。
    注意：実数が文字列として表現される場合、小数点は.または,の場合があります。

    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):
    """
    整数、浮動小数点数、または実数を表す文字列を受け取り、
    与えられた変数型のまま、より大きい変数を返す関数を作成します。
    値が等しい場合はNoneを返します。
    注意：実数が文字列として表現される場合、小数点は.または,で表されることがあります。

    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):
    """与えられた数値nが、ちょうど4つの正の偶数の和として表現できるかどうかを評価する
    例
    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):
    """与えられた数値nが、ちょうど4つの正の偶数の和として表現できるかどうかを判定します。
    例
    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):
    """ブラジル階乗は以下のように定義されます：
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ただし n > 0

    例：
    >>> special_factorial(4)
    288

    この関数は整数を入力として受け取り、その整数の特別階乗を返します。
    """

def special_factorial(n):
    """ブラジル階乗は次のように定義されます：
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ただし、n > 0

    例：
    >>> special_factorial(4)
    288

    この関数は整数を入力として受け取り、その整数のブラジル階乗を返します。
    """


def fix_spaces(text):
    """
    文字列textが与えられたとき、その中のすべての空白をアンダースコアに置き換え、
    文字列に2つ以上の連続した空白がある場合、
    すべての連続した空白を- に置き換えます

    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):
    """
    与えられた文字列のテキストについて、すべての空白をアンダースコアに置き換え、
    2つ以上の連続した空白がある場合は、
    すべての連続した空白をハイフンに置き換えます

    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):
    """
    与えられた文字列のテキストについて、すべての空白をアンダースコアに置き換え、
    2つ以上の連続した空白がある場合は、
    その連続した空白をすべてハイフンに置き換えます

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


def file_name_check(file_name):
    """文字列としてファイル名を受け取り、そのファイル名が有効な場合は'Yes'を返し、
    それ以外の場合は'No'を返す関数を作成します。
    ファイル名が有効とされるのは、以下のすべての条件を満たす場合のみです：
    - ファイル名に含まれる数字（'0'-'9'）は3個以下であること
    - ファイル名にはドット'.'が1つだけ含まれること
    - ドットの前の部分文字列は空でない、かつ英字（'a'-'z'および'A'-'Z'）で始まること
    - ドットの後の部分文字列は['txt', 'exe', 'dll']のいずれかであること

    例：
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' （ファイル名は英字で始まる必要があります）
    """

def file_name_check(file_name):
    """ファイル名を表す文字列を受け取り、ファイル名が有効な場合は'Yes'を返し、
    そうでない場合は'No'を返す関数を作成します。
    ファイル名は以下の条件をすべて満たす場合にのみ有効とみなされます：
    - ファイル名に含まれる数字（'0'-'9'）は3つまでとする。
    - ファイル名にはドット'.'が1つだけ含まれる。
    - ドットの前の部分は空であってはならず、ラテンアルファベット（'a'-'z'および'A'-'Z'）で
    始まる必要がある。
    - ドットの後の部分は以下のいずれかでなければならない：['txt', 'exe', 'dll']
    例：
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (名前はラテンアルファベットの文字で始まる必要がある)
    """

def file_name_check(file_name):
    """ファイル名を表す文字列を受け取り、そのファイル名が有効な場合は'Yes'を返し、
    そうでない場合は'No'を返す関数を作成します。
    ファイル名が有効とみなされるのは、以下の条件をすべて満たす場合のみです：
    - ファイル名に含まれる数字（'0'-'9'）は3つまでとする。
    - ファイル名にはドット'.'が1つだけ含まれる。
    - ドットの前の部分文字列は空であってはならず、ラテンアルファベット（'a'-'z'および'A'-'Z'）で
    始まる必要がある。
    - ドットの後の部分文字列は以下のいずれかでなければならない：['txt', 'exe', 'dll']
    例：
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (名前はラテンアルファベットの文字で始まる必要がある)
    """


def sum_squares(lst):
    """"
    この関数は整数のリストを受け取ります。リスト内のすべてのエントリに対して、インデックスが3の倍数の場合は整数エントリを2乗し、
    インデックスが4の倍数で3の倍数でない場合は整数エントリを3乗します。インデックスが3または4の倍数でないエントリは
    変更されません。その後、すべてのエントリの合計を返します。

    例：
    lst = [1,2,3] の場合、出力は 6
    lst = [] の場合、出力は 0
    lst = [-1,-5,2,-1,-5] の場合、出力は -126
    """

def sum_squares(lst):
    """"
    この関数は整数のリストを受け取ります。リスト内のすべての要素について、インデックスが3の倍数である場合は
    その整数を2乗し、インデックスが4の倍数（ただし3の倍数ではない）である場合はその整数を3乗します。
    インデックスが3の倍数でも4の倍数でもない要素は変更せずそのままにします。最後に、すべての要素の合計を返します。

    例：
    lst = [1,2,3] の場合、出力は 6
    lst = [] の場合、出力は 0
    lst = [-1,-5,2,-1,-5] の場合、出力は -126
    """


def words_in_sentence(sentence):
    """
    スペースで区切られた単語からなる文字列（文）が与えられます。
    元の文から単語の長さが素数である単語のみを抽出し、
    元の順序を保持したまま新しい文字列として返してください。

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

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

    制約:
        * 1 <= len(sentence) <= 100
        * 文はアルファベットのみを含む
    """

def words_in_sentence(sentence):
    """
    文を表す文字列が与えられます。
    文にはスペースで区切られたいくつかの単語が含まれています。
    そして、元の文の単語のうち、長さが素数である単語を含む文字列を返す必要があります。
    新しい文字列内の単語の順序は、元の文字列と同じである必要があります。

    例1:
        入力: sentence = "This is a test"
        出力: "is"

    例2:
        入力: sentence = "lets go for swimming"
        出力: "go for"

    制約：
        * 1 <= len(sentence) <= 100
        * 文は文字のみを含みます
    """

def words_in_sentence(sentence):
    """
    文章を表す文字列が与えられ、
    文章にはスペースで区切られた単語が含まれており、
    元の文章から単語の長さが素数である単語を含む文字列を返す必要があります。
    新しい文字列内の単語の順序は、元の順序と同じでなければなりません。

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

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

    制約:
        * 1 <= len(sentence) <= 100
        * 文章にはアルファベットのみが含まれます
    """


def simplify(x, n):
    """あなたの課題は、式 x * n を簡略化する関数を実装することです。
    この関数は、x * n が整数になる場合は True を、そうでない場合は False を返します。
    x と n はどちらも分数を表す文字列で、以下の形式を持ちます：
    <分子>/<分母> ここで分子と分母は正の整数です。

    x と n は有効な分数であり、分母がゼロではないと仮定できます。

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

def simplify(x, n):
    """あなたの課題は、式 x * n を簡略化する関数を実装することです。
    関数は x * n が整数になる場合は True を、そうでない場合は False を返します。
    x と n はどちらも分数を表す文字列で、以下の形式を持ちます：
    <分子>/<分母> ここで分子と分母は正の整数です。

    x と n は有効な分数であり、分母がゼロではないと仮定できます。

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

def simplify(x, n):
    """式 x * n を簡略化する関数を実装してください。
    この関数は、x * n が整数になる場合はTrue、そうでない場合はFalseを返します。
    x と n はどちらも分数の文字列表現で、<分子>/<分母>の形式です。
    分子と分母は両方とも正の整数です。

    x と n は有効な分数であり、分母が0ではないと仮定できます。

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


def order_by_points(nums):
    """
    与えられた整数リストを、各数字の桁の合計に基づいて昇順にソートする関数です。
    注意：桁の合計が同じ項目が複数ある場合は、
    元のリストでのインデックスに基づいて順序付けします。

    例えば：
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    与えられた整数リストを、各数字の合計に基づいて昇順にソートする関数です。
    注意：数字の合計が同じ項目が複数ある場合は、
    元のリストでのインデックスに基づいて順序付けします。

    例：
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    各整数の桁の合計値に基づいて、与えられた整数リストを昇順でソートする関数を作成してください。
    注意: 桁の合計値が同じアイテムが複数ある場合は、元のリストでのインデックス順に並べてください。

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


def specialFilter(nums):
    """配列を入力として受け取り、配列内の要素のうち、10より大きく、
    最初の桁と最後の桁の両方が奇数（1、3、5、7、9）である数値の個数を返す関数。
    例：
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """数値の配列を入力として受け取り、10より大きく、数の最初の桁と最後の桁の両方が奇数（1, 3, 5, 7, 9）である条件を満たす要素の数を返す関数を作成してください。
    例：
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """配列の数値を入力として受け取り、配列内の要素のうち、10より大きく、
    かつ数値の最初と最後の桁が奇数（1、3、5、7、9）である要素の数を返す関数。
    例：
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    正の整数nが与えられます。長さnの整数配列aを作成する必要があります。
        各i（1 ≤ i ≤ n）について、a[i] = i * i - i + 1の値となります。
        i < j < kの条件で、a[i] + a[j] + a[k]が3の倍数となるような
    配列aの三つ組(a[i], a[j], a[k])の数を返します。

    例：
        Input: n = 5
        Output: 1
        説明：
        a = [1, 3, 7, 13, 21]
        有効な三つ組は(1, 7, 13)のみです。
    """

def get_max_triples(n):
    """
    正の整数 n が与えられます。長さ n の整数配列 a を作成する必要があります。
        各 i (1 ≤ i ≤ n) に対して、a[i] の値は i * i - i + 1 です。
        i < j < k のとき、a[i] + a[j] + a[k] が 3 の倍数である
    a の三つ組 (a[i], a[j], a[k]) の数を返します。

    例 :
        入力: n = 5
        出力: 1
        説明:
        a = [1, 3, 7, 13, 21]
        唯一の有効な三つ組は (1, 7, 13) です。
    """

def get_max_triples(n):
    """
    正の整数nが与えられます。長さnの整数配列aを作成する必要があります。
    各i (1 ≤ i ≤ n) について、a[i] = i * i - i + 1 となります。
    i < j < k を満たし、a[i] + a[j] + a[k] が3の倍数となる
    3つ組 (a[i], a[j], a[k]) の個数を返してください。

    例：
        Input: n = 5
        Output: 1
        説明：
        a = [1, 3, 7, 13, 21]
        有効な3つ組は (1, 7, 13) のみです。
    """


def bf(planet1, planet2):
    '''
    私たちの太陽系には8つの惑星があります：太陽に最も近い順に
    水星、金星、地球、火星、木星、土星、
    天王星、海王星です。
    2つの惑星名を文字列 planet1 と planet2 として受け取る関数を作成します。
    この関数は、planet1 の軌道と planet2 の軌道の間に位置する
    すべての惑星を、太陽からの距離順に並べたタプルを
    返す必要があります。
    planet1 または planet2 が正しい惑星名でない場合、
    空のタプルを返します。
    例
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    私たちの太陽系には8つの惑星があります：太陽に最も近い順に
    水星、金星、地球、火星、木星、土星、天王星、海王星です。
    2つの惑星名を文字列planet1とplanet2として受け取る関数を作成してください。
    この関数は、planet1の軌道とplanet2の軌道の間にある
    すべての惑星を、太陽からの近さでソートしたタプルとして返します。
    planet1またはplanet2が正しい惑星名でない場合は、
    空のタプルを返します。
    例
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    私たちの太陽系には8つの惑星があります：太陽に最も近い順に
    水星、金星、地球、火星、木星、土星、
    天王星、海王星です。
    2つの惑星名を文字列 planet1 と planet2 として受け取る関数を作成します。
    この関数は、planet1 の軌道と planet2 の軌道の間に位置する
    すべての惑星を、太陽からの距離順に並べたタプルを
    返す必要があります。
    planet1 または planet2 が正しい惑星名でない場合、
    空のタプルを返します。
    Examples
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """文字列のリストを引数として受け取り、
    長さが奇数の文字列を削除し、
    結果として得られるリストを長さ順にソートして返す関数を作成してください。
    リストは常に文字列のリストであり、数字の配列ではありません。
    重複が含まれている場合もあります。
    リストは各単語の長さで昇順にソートする必要があり、
    そのルールに従ってソートされたリストを返してください。
    もし2つの単語の長さが同じ場合は、アルファベット順にソートします。
    関数はソートされた順番で文字列のリストを返します。
    すべての単語が同じ長さであると仮定してもかまいません。
    例:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """文字列のリストをパラメータとして受け取り、
    奇数の長さを持つ文字列を削除し、
    ソートされた順序でリストを返す関数を作成します。
    このリストは常に文字列のリストであり、数値の配列ではありません。
    また、重複を含む可能性があります。
    リストの順序は各単語の長さで昇順にソートされ、
    そのルールに従ってソートされたリストを返す必要があります。
    2つの単語が同じ長さの場合は、アルファベット順でソートします。
    この関数はソートされた文字列のリストを返す必要があります。
    すべての単語は同じ長さであると仮定できます。
    例：
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """シンプルなプログラムで、nが素数の場合はxの値を返し、それ以外の場合はyの値を返します。

    例：
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """nが素数の場合はxの値を返し、
    そうでない場合はyの値を返すシンプルなプログラムです。

    例：
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    数値のリストが与えられた時、リスト内の奇数の2乗の合計を返します。
    負の数と整数でない数は無視します。

    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

    入力リストが空の場合は0を返します。
    '''

def double_the_difference(lst):
    '''
    数値のリストが与えられた場合、リスト内の奇数の二乗の合計を返します。
    負の数値や整数でない数値は無視します。

    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

    入力リストが空の場合は0を返します。
    '''


def compare(game,guess):
    """私たち全員が、長く待ち望んでいた出来事の結果が最終的に判明した時の感覚を覚えているでしょう。
    その瞬間に抱く感情や思考は、間違いなく記録して比較する価値があります。
    あなたの課題は、ある人が複数の試合の結果を正しく予想できたかどうかを判断することです。
    同じ長さのスコアと予想の2つの配列が与えられ、各インデックスは試合を示します。
    各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。正しく予想できた場合は値が0となり、
    そうでない場合は、予想とスコアの絶対差が値となります。

    例：

    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):
    """私たちは皆、長く待ち望んでいた出来事の結果がついに明らかになった時の気持ちを覚えているでしょう。
    その瞬間の感情や考えを記録し、比較することは間違いなく価値があります。
    あなたの課題は、ある人が複数の試合の結果を正しく予想できたかどうかを判定することです。
    同じ長さのスコアと予想の2つの配列が与えられ、各インデックスは1つの試合を表します。
    各予想がどれだけ外れていたかを示す、同じ長さの配列を返してください。正しく予想できた場合は
    値が0となり、そうでない場合は予想とスコアの絶対値の差が値となります。

    例：

    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):
    """私たち全員が、長く待ち望んでいた出来事の結果が最終的に判明した時の
    感覚を覚えているでしょう。その瞬間に抱く感情や思考は、
    間違いなく記録して比較する価値があります。
    あなたの課題は、ある人が複数の試合の結果を正しく予想できたかどうかを判断することです。
    同じ長さのスコアと予想の2つの配列が与えられ、各インデックスは1つの試合を示します。
    各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。正しく予想できた場合は
    値は0となり、そうでない場合は、予想とスコアの絶対差が値となります。

    例：

    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):
    """クラス名（文字列）と拡張機能のリストが与えられます。
    これらの拡張機能は、クラスに追加のクラスを読み込むために使用されます。拡張機能の
    強さは以下のように定義されます：CAPを拡張機能名の大文字の数とし、SMを拡張機能名の
    小文字の数とすると、強さはCAP - SMで表されます。
    最も強い拡張機能を見つけ、以下の形式で文字列を返す必要があります：
    ClassName.StrongestExtensionName
    同じ強さの拡張機能が2つ以上ある場合は、リストの中で最初に出現するものを
    選択する必要があります。
    例えば、クラスとして"Slices"が与えられ、拡張機能のリストとして
    ['SErviNGSliCes', 'Cheese', 'StuFfed']が与えられた場合、
    'Slices.SErviNGSliCes'を返す必要があります。なぜなら'SErviNGSliCes'が
    最も強い拡張機能（強さは-1）だからです。
    例：
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """クラス名（文字列）と拡張のリストが与えられます。
    これらの拡張は、クラスに追加のクラスを読み込むために使用されます。
    拡張の強度は以下のように計算されます：拡張名の大文字の数をCAP、
    小文字の数をSMとすると、強度はCAP - SMで与えられます。
    最も強い拡張を見つけ、次の形式で文字列を返してください：
    ClassName.StrongestExtensionName
    同じ強度の拡張が2つ以上ある場合は、リストの中で最初に現れる
    ものを選択してください。
    例えば、クラス名として"Slices"が与えられ、拡張のリストとして
    ['SErviNGSliCes', 'Cheese', 'StuFfed']が与えられた場合、
    'Slices.SErviNGSliCes'を返す必要があります。
    これは'SErviNGSliCes'が最も強い拡張（強度は-1）だからです。
    例：
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """クラス名（文字列）と拡張機能のリストが与えられます。
    これらの拡張機能は、クラスに追加のクラスを読み込むために使用されます。拡張機能の
    強さは以下のように定義されます：CAPを拡張機能名の大文字の数とし、SMを拡張機能名の
    小文字の数とすると、強さはCAP - SMで表されます。
    最も強い拡張機能を見つけ、以下の形式で文字列を返す必要があります：
    ClassName.StrongestExtensionName
    同じ強さの拡張機能が2つ以上ある場合は、リストの中で最初に出現するものを
    選択する必要があります。
    例えば、クラスとして"Slices"が与えられ、拡張機能のリストとして
    ['SErviNGSliCes', 'Cheese', 'StuFfed']が与えられた場合、
    'Slices.SErviNGSliCes'を返す必要があります。なぜなら'SErviNGSliCes'が
    最も強い拡張機能だからです（その強さは-1です）。
    例：
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """2つの単語が与えられます。2番目の単語、またはその回転のいずれかが1番目の単語の部分文字列である場合、Trueを返します。
    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):
    """2つの単語が与えられます。2番目の単語またはそのローテーションが1番目の単語の部分文字列である場合はTrueを返す必要があります
    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):
    """2つの単語があります。2番目の単語またはその回転のいずれかが最初の単語の部分文字列である場合は、Trueを返す必要があります。
    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):
    """整数が与えられたとき、その数の偶数の桁の数と奇数の桁の数をそれぞれ含むタプルを返します。

     例：
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """整数が与えられます。偶数桁と奇数桁の数がそれぞれあるタプルを返します。

    例：
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """整数が与えられた場合、偶数と奇数の桁数をそれぞれ含むタプルを返します。

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


def int_to_mini_roman(number):
    """
    正の整数を受け取り、それに相当するローマ数字を文字列として取得し、
    小文字で返します。
    制限：1 <= num <= 1000

    例：
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
     正整数が与えられた場合、そのローマ数字に相当する文字列を取得して、小文字で返します。
    制限: 1 <= num <= 1000

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

def int_to_mini_roman(number):
    """
    正の整数を与えられた場合、そのローマ数字の等価を文字列として取得し、
    小文字で返します。
    制限: 1 <= num <= 1000

    例:
    >>> 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):
    '''
    三角形の3辺の長さが与えられます。3辺が直角三角形を形成する場合はTrueを、
    そうでない場合はFalseを返します。
    直角三角形とは、1つの角が直角（90度）である三角形のことです。
    例：
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    三角形の三辺の長さが与えられたとき、それらが直角三角形を形成する場合はTrue、
    そうでない場合はFalseを返します。
    直角三角形とは、1つの角が直角（90度）である三角形のことです
    例：
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """文字列のリストを受け取る関数を作成してください。
    リストには異なる単語が含まれています。ユニークな文字の数が最大の単語を返してください。
    複数の文字列が最大数のユニークな文字を持つ場合は、辞書順で最初に来るものを返してください。

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

def find_max(words):
    """文字列のリストを受け取る関数を作成します。
    リストには異なる単語が含まれています。一意な文字数が最大の単語を返します。
    一意な文字数が最大の文字列が複数ある場合は、辞書順で最初に来るものを返します。

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

def find_max(words):
    """文字列のリストを受け取る関数を作成します。
    リストには異なる単語が含まれています。ユニークな文字の数が
    最大の単語を返します。複数の文字列が最大数のユニークな
    文字を持つ場合は、辞書順で最初に来るものを返します。

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


def eat(number, need, remaining):
    """
    あなたは空腹なウサギで、すでに一定数のニンジンを食べていますが、
    一日の食事を完了するためにさらにニンジンを食べる必要があります。
    配列を返す必要があります：[ 食事後の合計食べたニンジンの数,
                                食事後に残っているニンジンの数 ]
    残りのニンジンが足りない場合、残っているニンジンをすべて食べますが、まだ空腹のままです。

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

    変数：
    @number : integer
        すでに食べたニンジンの数
    @need : integer
        食べる必要があるニンジンの数
    @remaining : integer
        在庫に残っているニンジンの数

    制約：
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    楽しんでください :)
    """

def eat(number, need, remaining):
    """
    あなたは空腹なウサギで、すでに一定数のニンジンを食べていますが、
    一日の食事を完了するためにさらにニンジンを食べる必要があります。
    戻り値は以下の配列となります：[食事後の合計摂取ニンジン数、食事後の残りニンジン数]
    残りのニンジンが不足している場合、残っているニンジンをすべて食べますが、まだ空腹のままです。

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

    変数：
    @number : integer
        すでに食べたニンジンの数
    @need : integer
        食べる必要があるニンジンの数
    @remaining : integer
        在庫として残っているニンジンの数

    制約：
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    楽しんでください :)
    """

def eat(number, need, remaining):
    """
    あなたは空腹なウサギで、すでに一定数のにんじんを食べましたが、
    一日の食事を完了するにはさらににんじんを食べる必要があります。
    返り値は以下の2つの要素を含む配列です：
    [ 食事後の合計で食べたにんじんの数,
      食事後に残っているにんじんの数 ]
    残りのにんじんが足りない場合、残っているにんじんをすべて食べますが、まだ空腹のままです。

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

    変数：
    @number : 整数
        すでに食べたにんじんの数
    @need : 整数
        さらに食べる必要があるにんじんの数
    @remaining : 整数
        在庫として残っているにんじんの数

    制約条件：
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    楽しんでください :)
    """


def do_algebra(operator, operand):
    """
    演算子のリストとオペランドのリストが与えられます。最初のリストには基本的な代数演算が含まれており、
    2番目のリストは整数のリストです。この2つのリストを使用して代数式を構築し、
    その式の評価結果を返します。

    基本的な代数演算：
    加算 ( + )
    減算 ( - )
    乗算 ( * )
    切り捨て除算 ( // )
    べき乗 ( ** )

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

    注意：
        演算子リストの長さは、オペランドリストの長さから1を引いた値と等しくなります。
        オペランドは非負整数のリストです。
        演算子リストには少なくとも1つの演算子が、オペランドリストには少なくとも2つのオペランドが含まれています。

    """

def do_algebra(operator, operand):
    """
    2つのリスト、operatorとoperandが与えられます。最初のリストには基本的な代数演算が含まれ、
    2番目のリストは整数のリストです。与えられた2つのリストを使用して代数式を構築し、
    この式の評価を返します。

    基本的な代数演算:
    加算 ( + )
    減算 ( - )
    乗算 ( * )
    床除算 ( // )
    指数 ( ** )

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

    注意:
        operatorリストの長さはoperandリストの長さマイナス1に等しいです。
        operandは非負整数のリストです。
        operatorリストには少なくとも1つの演算子があり、operandリストには少なくとも2つのオペランドがあります。

    """

def do_algebra(operator, operand):
    """
    2つのリスト operator と operand が与えられます。1つ目のリストは基本的な代数演算子を含み、
    2つ目のリストは整数のリストです。この2つのリストを使って代数式を構築し、
    その式の評価結果を返します。

    基本的な代数演算:
    加算 ( + )
    減算 ( - )
    乗算 ( * )
    切り捨て除算 ( // )
    べき乗 ( ** )

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

    注意：
        演算子リストの長さは、被演算子リストの長さより1小さくなります。
        被演算子リストは非負整数のリストです。
        演算子リストは少なくとも1つの演算子を含み、被演算子リストは少なくとも2つの被演算子を含みます。

    """


def solve(s):
    """
    文字列 s が与えられます。
    s[i] が文字の場合、小文字なら大文字に、大文字なら小文字に変換します。
    それ以外の文字はそのまま残します。
    文字列に文字が含まれていない場合、文字列を逆順にします。
    関数は変換された文字列を返します。
    例:
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """与えられた文字列sについて、
    s[i]が文字の場合、大文字と小文字を反転させ、
    そうでない場合はそのままにします。
    文字列に文字が含まれていない場合は、文字列を反転させます。
    この関数は処理された文字列を返します。
    Examples
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    文字列 'text' が与えられた場合、その md5 ハッシュ相当の文字列を返します。
    'text' が空の文字列の場合は、None を返します。

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

def string_to_md5(text):
    """
    与えられた文字列'text'のMD5ハッシュ値に対応する文字列を返します。
    'text'が空文字列の場合はNoneを返します。

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

def string_to_md5(text):
    """
    文字列 'text' を与えると、その md5 ハッシュの等価な文字列を返します。
    'text' が空の文字列の場合、None を返します。

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


def generate_integers(a, b):
    """
    2つの正の整数aとbが与えられたとき、aとbの間の偶数の数字を昇順で返します。

    例:
    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):
    """
    2つの正の整数aとbが与えられた時、aとbの間にある
    偶数の数字を昇順で返します。

    例：
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """