from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 与えられた数値のリストの中に、互いの差が指定された閾値より小さい2つの数値が存在するかどうかを判定します。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 与えられた数のリストにおいて、任意の2つの数が指定された閾値よりも近いかどうかをチェックします。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 与えられた数値リストの中で、指定されたしきい値よりも近い距離にある2つの数値が存在するかどうかをチェックします。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ この関数への入力は、複数のグループの入れ子になった括弧を含む文字列です。
    目標は、それらのグループを個別の文字列に分離し、そのリストを返すことです。
    分離されたグループは、バランスが取れており（各開き括弧が適切に閉じられている）、
    互いに入れ子になっていません。
    入力文字列の空白は無視してください。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ この関数への入力は、複数のネストされた括弧のグループを含む文字列です。目標は、
    それらのグループを個別の文字列に分離し、そのリストを返すことです。
    分離されたグループはバランスが取れており（各開き括弧が適切に閉じられている）、互いにネストされていません
    入力文字列内のスペースは無視します。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ この関数への入力は、複数のネストされた括弧のグループを含む文字列です。目標は、
    それらのグループを個別の文字列に分離し、そのリストを返すことです。
    分離されたグループはバランスが取れており（各開き括弧が適切に閉じられている）、互いにネストされていません
    入力文字列内のスペースは無視してください。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ 与えられた正の浮動小数点数は、整数部分（与えられた数より小さい最大の整数）と
    小数部分（常に1より小さい残りの部分）に分解することができます。

    数値の小数部分を返します。
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ 与えられた正の浮動小数点数は、整数部分（与えられた数より小さい最大の整数）と
    小数部分（常に1より小さい余りの部分）に分解することができます。

    数値の小数部分を返します。
    >>> truncate_number(3.5)
    0.5

def truncate_number(number: float) -> float:
    """ 正の浮動小数点数が与えられたとき、その数は整数部分（与えられた数より小さい
    最大の整数）と小数部分（常に1より小さい残りの部分）に分解できます。

    数の小数部分を返します。
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 残高が0から始まる銀行口座に対する入金と出金の取引リストが与えられます。
    あなたの課題は、いずれかの時点で口座残高が0を下回るかどうかを検出することです。
    残高が0を下回った場合はTrueを返し、そうでない場合はFalseを返してください。
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 残高ゼロから始まる銀行口座の入金と出金操作のリストが与えられます。
    口座の残高が任意の時点でゼロを下回った場合はTrueを返し、
    そうでない場合はFalseを返す必要があります。
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 与えられた入力数値のリストに対して、このデータセットの平均値周りの
    平均絶対偏差を計算します。
    平均絶対偏差は、各要素と中心点（この場合は平均値）との間の
    絶対差の平均値です：
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 入力リスト `numbers` の連続する2つの要素の間に数値 'delimeter' を挿入する
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 入力リスト `numbers` の連続する要素の間に数値 'delimeter' を挿入します
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 入力リスト`numbers`の連続する2つの要素の間に、数値'delimeter'を挿入します
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ この関数への入力は、スペースで区切られた入れ子になった括弧の複数のグループを表す文字列です。
    各グループについて、括弧の入れ子の最も深いレベルを出力します。
    例えば、(()()) は最大2レベルの入れ子になっているのに対し、((())) は3レベルです。

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ この関数への入力は、空白で区切られた複数の入れ子になった括弧のグループを表す文字列です。
    各グループに対して、括弧のネストの最も深いレベルを出力します。
    例えば、(()()) は最大2レベルのネストですが、((())) は3レベルです。

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 与えられた部分文字列を含む文字列のみを入力文字列リストからフィルタリングする
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 与えられた部分文字列を含む文字列のみを入力文字列リストからフィルターします
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 与えられた整数のリストに対して、すべての整数の和と積からなるタプルを返します。
    空リストの場合、和は0、積は1とします。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 与えられた整数リストに対して、リスト内のすべての整数の合計と積からなるタプルを返します。
    空の合計は0、空の積は1とします。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 与えられた整数のリストに対して、リスト内のすべての整数の合計と積からなるタプルを返します。
    空の合計は0、空の積は1とします。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 与えられた整数のリストから、数列の各時点までに見つかった移動最大値のリストを生成します。
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 与えられた整数のリストから、シーケンス内の特定の時点までに見つかった
    ローリング最大要素のリストを生成します。
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ 与えられた文字列が回文かどうかをテストする """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 与えられた文字列で始まる最短の回文を見つける。
    アルゴリズムの考え方はシンプル：
    - 与えられた文字列の中で最長の回文である後置部分を見つける。
    - 回文の接尾辞の前にある文字列の接頭辞を反転させて末尾に追加する。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 与えられた文字列が回文かどうかをテストします """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 与えられた文字列で始まる最短の回文を見つけます。
    アルゴリズムの考え方は単純です：
    - 与えられた文字列の中で、回文となっている最長の後置部分を見つけます。
    - 回文となる後置部分の前にある文字列を反転させて、元の文字列の末尾に追加します。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 与えられた文字列が回文かどうかをテストする """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 与えられた文字列で始まる最短の回文を見つける。
    アルゴリズムのアイデアは簡単です：
    - 与えられた文字列の中で回文である最長の後置を見つける。
    - 回文の接尾辞の前にある文字列の接頭辞を逆にして文字列の末尾に追加する。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ 入力は1と0のみで構成される2つの文字列aとbです。
    これらの入力にバイナリXORを実行し、結果も文字列として返します。
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ 入力は1と0のみで構成される2つの文字列aとbです。
    これらの入力に対して二進数のXOR演算を実行し、結果を文字列として返します。
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """文字列のリストから最も長い文字列を返します。同じ長さの文字列が複数ある場合は最初の文字列を返します。
    入力リストが空の場合はNoneを返します。
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 文字列のリストから最も長い文字列を返します。同じ長さの文字列が複数ある場合は最初のものを返します。
    入力リストが空の場合はNoneを返します。
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 文字列のリストから、最も長い文字列を返します。同じ長さの文字列が複数ある場合は最初のものを返します。
    入力リストが空の場合はNoneを返します。
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ 2つの整数aとbの最大公約数を返します。
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ 2つの整数aとbの最大公約数を返す
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ 2つの整数aとbの最大公約数を返します
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 入力文字列の最短から最長までのすべての接頭辞をリストとして返します
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 入力文字列の最短から最長までのすべての接頭辞のリストを返す
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ 0からnまで（nを含む）の数字を空白区切りで含む文字列を返します。
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 0からnまでの数値を含むスペース区切りの文字列を返します。
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 0 から n までのスペースで区切られた数字を含む文字列を返します。
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ 与えられた文字列に含まれる異なる文字の数を返します（大文字小文字を区別しません）
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ 与えられた文字列に含まれる異なる文字の数を調べます（大文字小文字は区別しない）
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ この関数への入力は、特殊なASCII形式で表現された音符を表す文字列です。
    あなたの課題は、この文字列を解析し、各音符が何拍続くかを示す整数のリストを返すことです。

    以下が記号の説明です：
    'o' - 全音符、4拍続きます
    'o|' - 二分音符、2拍続きます
    '.|' - 四分音符、1拍続きます

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ この関数への入力は、特別なASCII形式で表現された音符を表す文字列です。
    この文字列を解析し、各音符が何拍続くかに対応する整数のリストを返すのがあなたの課題です。

    伝説は次のとおりです:
    'o' - 全音符、4拍続く
    'o|' - 二分音符、2拍続く
    '.|' - 四分音符、1拍続く

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ この関数への入力は、特別なASCII形式で表された音符を表す文字列です。
    あなたの課題は、この文字列を解析し、各音符が何拍続くかを示す整数のリストを返すことです。

    以下は凡例です：
    'o' - 全音符、4拍続く
    'o|' - 二分音符、2拍続く
    '.|' - 四分音符、1拍続く

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


def how_many_times(string: str, substring: str) -> int:
    """元の文字列の中で指定された部分文字列が何回出現するかを見つけます。重複するケースも数えます。
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ 与えられた部分文字列が元の文字列に何回含まれているかを検索します。重複するケースもカウントします。
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ 入力は'zero'から'nine'までの数字を表す単語を空白区切りで並べた文字列です。
    有効な単語は'zero'、'one'、'two'、'three'、'four'、'five'、'six'、'seven'、'eight'、'nine'です。
    数字の大きさに基づいて小さい順に並べ替えた文字列を返します。
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ 入力は'zero'から'nine'までの数字を表す単語がスペースで区切られた文字列です。
    有効な選択肢は'zero'、'one'、'two'、'three'、'four'、'five'、'six'、'seven'、'eight'、'nine'です。
    数字を小さい順から大きい順に並べ替えた文字列を返します
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 与えられた数値のリスト（長さ2以上）から、互いに最も近い2つの数値を選択し、
    順序（小さい方の数、大きい方の数）で返します。
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 提供されたリスト（長さ2以上）から、最も近い値を持つ2つの数値を選択し、
    順序付けて（小さい数、大きい数）返します。
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 数値のリスト（少なくとも2つの要素を含む）が与えられた時、そのリストに線形変換を適用し、
    最小値が0に、最大値が1になるようにします。
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 数値のリスト（少なくとも2つの要素を含む）が与えられた場合、線形変換を適用し、
    最小値が0に、最大値が1になるように変換します
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 任意のPython値のリストから整数のみをフィルタリングする
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 与えられた任意のPython値のリストから整数のみをフィルタリングする
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 任意のPython値を含むリストから整数のみをフィルタリングします
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ 与えられた文字列の長さを返す
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """与えられた文字列の長さを返します。
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ 与えられた数nに対して、nより小さい数の中で、nを割り切れる最大の数を求めます。
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ 与えられた数値nに対して、nより小さくnを割り切ることができる最大の数を見つける
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ 与えられた整数の素因数を、小さい順にリストで返します。
    各因数は、因数分解において出現する回数だけリストに含める必要があります。
    入力された数は、すべての因数の積と等しくなければなりません。
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ 与えられた整数の素因数を最小から最大の順に並べたリストを返します。
    各因数は、因数分解で現れる回数に応じて、その回数分リストに含める必要があります。
    入力された数値は、全ての因数の積と等しくなければなりません。
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ 与えられた整数の素因数を最小から最大の順にリストとして返します。
    各素因数は、因数分解で現れる回数分だけリストに含める必要があります。
    入力された数は、すべての因数の積に等しくなければなりません。
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 整数のリストから、複数回出現する要素をすべて削除します。
    残った要素の順序は入力と同じように保持されます。
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 整数のリストから、複数回出現するすべての要素を削除します。
    残りの要素は入力と同じ順序を保持します。
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ 与えられた文字列に対して、小文字を大文字に、大文字を小文字に変換します。
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ 与えられた文字列に対して、小文字を大文字に、大文字を小文字に反転します。
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ 文字列のリストを単一の文字列に連結する
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """文字列のリストを連結して1つの文字列にします。
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 与えられた接頭辞で始まる文字列のみを入力文字列リストからフィルタリングします。
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """与えられた接頭辞で始まる文字列のみを入力文字列リストからフィルタリングします。
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """リスト内の正の数のみを返します。
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """リストから正の数のみを返します。
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """与えられた数が素数の場合はTrueを返し、そうでない場合はFalseを返します。
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """与えられた数が素数であればTrue、そうでなければFalseを返します。
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """与えられた数が素数の場合はtrueを返し、そうでない場合はfalseを返します。
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    点xにおける係数xsの多項式を評価します。
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xsは多項式の係数です。
    find_zeroは poly(x) = 0 となるxを見つけます。
    find_zeroは、複数の解が存在する場合でも1つの解のみを返します。
    さらに、find_zeroは偶数個の係数を持ち、最大の非ゼロ係数を持つxsのリストのみを
    受け取ります。これにより解の存在が保証されます。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    点xにおける係数xsの多項式を評価します。
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xsは多項式の係数です。
    find_zeroは poly(x) = 0 となるxを見つけます。
    複数の解が存在する場合でも、find_zeroは1つの零点のみを返します。
    さらに、find_zeroは偶数個の係数を持ち、最高次の係数が0でないリストxsのみを
    処理します。これにより解の存在が保証されます。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    点xにおける係数xsの多項式を評価します。
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xsは多項式の係数です。
    find_zeroは poly(x) = 0 となるxを見つけます。
    複数の解が存在する場合でも、find_zeroは1つの解のみを返します。
    さらに、find_zeroは解の存在を保証するため、偶数個の係数を持ち、
    最高次の係数が0でないリストxsのみを受け付けます。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """この関数はリストlを受け取り、以下のようなリストl'を返します：
    l'は3で割り切れないインデックスではlと同一であり、3で割り切れるインデックスでの値は
    lの対応するインデックスの値と等しく、ソートされています。
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """この関数はリストlを受け取り、新しいリストl'を返します。
    l'は3で割り切れないインデックスではlと同一であり、3で割り切れるインデックスでは
    対応するlのインデックスの値をソートした値となります。
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """リスト内のユニークな要素をソートして返す
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """リストから重複を除去し、ソート済みの要素を返します。
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """リスト内の最大要素を返します。
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """リストの中の最大要素を返します。
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """11または13で割り切れるn未満の整数の中で、数字の7が出現する回数を返します。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """11または13で割り切れる、n未満の整数において、数字7が出現する回数を返します。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """11または13で割り切れるn未満の整数の中で、数字7が出現する回数を返します。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """この関数はリストlを受け取り、新しいリストl'を返します。
    l'は奇数インデックスではlと同一であり、偶数インデックスでは
    lの偶数インデックスの値をソートした結果となります。
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """このリストlを受け取り、以下の条件を満たす新しいリストl'を返します
    l'は奇数インデックスの位置ではlと同じ値を保持し、偶数インデックスの位置では
    lの偶数インデックスの値をソートした結果を持ちます。
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    3文字のグループを循環させることで文字列をエンコードして返します。
    """
    # 文字列を3文字ずつのグループに分割します。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 各グループの要素を循環させます。ただし、グループの要素が3未満の場合を除きます。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic関数でエンコードされた文字列を入力として受け取り、デコードされた文字列を返します。
    """

def encode_cyclic(s: str):
    """
    文字列を 3 文字のグループごとに循環させてエンコードされた文字列を返します。
    """
    # 文字列をグループに分割します。それぞれの長さは 3。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 各グループ内の要素をサイクルします。グループの要素が 3 より少ない場合はそのままです。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic 関数でエンコードされた入力文字列を受け取り、デコードされた文字列を返します。
    """

def encode_cyclic(s: str):
    """
    3文字ずつのグループを循環させることで文字列を暗号化し、その結果を返します。
    """
    # 文字列を3文字ずつのグループに分割
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 3文字のグループの場合、要素を循環させる。3文字未満の場合はそのまま
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic関数で暗号化された文字列を入力として受け取り、復号化された文字列を返します。
    """


def prime_fib(n: int):
    """
    prime_fibは、フィボナッチ数であり、素数でもあるn番目の数を返します。
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    フィボナッチ数でありかつ素数である数のうち、n番目の数を返します。
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fibは、フィボナッチ数列でありかつ素数でもあるn番目の数を返します。
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero は整数のリストを入力として受け取ります。
    リスト内に合計がゼロになる3つの異なる要素が存在する場合は True を返し、
    存在しない場合は False を返します。

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zeroは整数のリストを入力として受け取ります。
    リスト内の3つの異なる要素の和が0になる場合はTrue、
    そうでない場合はFalseを返します。

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zeroは整数のリストを入力として受け取ります。
    リスト内の3つの異なる要素の和が0になる場合はTrueを返し、
    そうでない場合はFalseを返します。

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


def car_race_collision(n: int):
    """
    無限に長い完全な直線の道路を想像してください。
    n台の車が左から右へ走っており、同時に別のn台の車が右から左へ走っています。
    2つのグループの車は、最初はお互いにかなり離れた場所からスタートします。
    すべての車は同じ速度で移動します。衝突とは、左から右へ移動する車が
    右から左へ移動する車にぶつかることを指します。
    ただし、車は無限に頑丈で強いため、衝突しても
    まるで衝突しなかったかのように軌道を維持し続けます。

    この関数は、そのような衝突の回数を出力します。
    """

def car_race_collision(n: int):
    """
    道路は完全に直線の無限に長い線路だと想像してください。
    n台の車が左から右へ走っており、同時に別のn台の車が右から左へ走っています。
    2つのグループの車は最初、互いにかなり離れた位置にいます。
    すべての車は同じ速度で移動します。
    左から右へ移動する車が右から左へ移動する車にぶつかったとき、2台の車が衝突したとみなされます。
    ただし、車は無限に頑丈で強いため、衝突しなかったかのように軌道を維持して移動し続けます。

    この関数はそのような衝突の回数を出力します。
    """

def car_race_collision(n: int):
    """
    完全に直線の無限に長い道路を想像してください。
    n台の車が左から右へ走行しており、同時に別のn台の車が右から左へ走行しています。
    2つのグループの車は、最初は互いにとても遠い位置にいます。すべての車は同じ速度で
    移動します。左から右へ走行する車が右から左へ走行する車にぶつかったとき、
    それを衝突と呼びます。
    ただし、車は無限に頑丈で強いため、衝突後も衝突しなかったかのように
    元の進路をそのまま進み続けます。

    この関数は、そのような衝突の回数を出力します。
    """


def incr_list(l: list):
    """要素が1ずつ増加したリストを返します。
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """要素を1ずつ増加させたリストを返します。
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zeroは整数のリストを入力として受け取ります。
    リスト内に合計がゼロとなる2つの異なる要素が存在する場合はTrueを返し、
    そうでない場合はFalseを返します。
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zeroは整数のリストを入力として受け取ります。
    リスト内に合計がゼロになる2つの異なる要素がある場合はTrueを返し、
    そうでない場合はFalseを返します。
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zeroは整数のリストを入力として受け取ります。
    リスト内に和が0になる2つの異なる要素が存在する場合はTrue、
    そうでない場合はFalseを返します。
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """入力された数値xの基数を指定されたbaseに変換します。
    変換後の文字列表現を返します。
    基数は10未満とします。
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Change numerical base of input number x to base.
    return string representation after the conversion.
    base numbers are less than 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """入力された数値 x の基数を base に変更します。
    変換後の文字列表現を返します。
    基数は10未満の数字のみ使用可能です。
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """三角形の底辺と高さから面積を計算して返します。
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """三角形の底辺の長さと高さから面積を求めます。
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """三角形の辺の長さと高さが与えられたとき、三角形の面積を返します。
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Fib4数列はフィボナッチ数列に似た数列で、以下のように定義されます：
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)
    この数列のn番目の要素を効率的に計算する関数を作成してください。再帰は使用しないでください。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4数列は、次のように定義されるフィボナッチ数列に似た数列です:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    fib4数列のn番目の要素を効率的に計算する関数を書いてください。再帰を使用しないでください。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4数列はフィボナッチ数列に似た数列で、以下のように定義されます：
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Fib4数列のn番目の要素を効率的に計算する関数を作成してください。再帰は使用しないでください。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """リスト l の要素の中央値を返します。
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """リストlの要素の中央値を返します。
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    与えられた文字列が回文かどうかをチェックします
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    与えられた文字列が回文かどうかを確認します
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """2^n を p で割った余りを返します（数値に注意してください）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """2^n を p で割った余りを返します（数値計算に注意）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """2^n をpで割った余りを返します（数値計算に注意してください）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    アルファベットの各文字を5文字分シフトすることで文字列をエンコードして返します。
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift関数でエンコードされた文字列を入力として受け取り、デコードされた文字列を返します。
    """

def encode_shift(s: str):
    """
    アルファベットの各文字を5文字分シフトすることで暗号化された文字列を返します。
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift関数で暗号化された文字列を入力として受け取り、復号された文字列を返します。
    """


def remove_vowels(text):
    """
    remove_vowelsは文字列を受け取り、母音を除いた文字列を返す関数です。
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels は文字列を受け取り、母音を除いた文字列を返す関数です。
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """リスト l のすべての数値が閾値 t 未満の場合に True を返します。
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """リスト l 内のすべての数値が閾値 t を下回っている場合に True を返します。
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """リスト l のすべての数が閾値t未満であればTrueを返します。
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """2つの数値 x と y を加算する
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """2つの数値xとyを加算します
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    2つの単語が同じ文字で構成されているかどうかを確認します。
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    2つの単語が同じ文字を持っているか確認します。
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    2つの単語が同じ文字を持っているかチェックします。
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """n番目のフィボナッチ数を返す。
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """n番目のフィボナッチ数を返します。
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ bracketsは"<"と">"のみからなる文字列です。
    すべての開き括弧("<")に対応する閉じ括弧(">")が存在する場合はTrueを返します。

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

def correct_bracketing(brackets: str):
    """ bracketsは"<"と">"の文字列です。
    開き括弧それぞれに対応する閉じ括弧がある場合はTrueを返します。

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

def correct_bracketing(brackets: str):
    """ bracketsは"<"と">"の文字列です。
    開き括弧に対応する閉じ括弧が存在する場合はTrueを返します。

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


def monotonic(l: list):
    """リストの要素が単調増加または単調減少している場合にTrueを返します。
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """リストの要素が単調増加または単調減少している場合はTrueを返します。
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """2つのリストのソート済みの重複のない共通要素を返します。
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """2つのリストの共通要素をソートしてユニークな形で返します。
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """nの最大の素因数を返す。nは1より大きく、素数ではないと仮定する。
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """nの最大の素因数を返します。nは1より大きく、素数ではないと仮定します。
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n は1からnまでの数字を合計する関数です。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """1からnまでの数値を合計する関数です。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n は1からnまでの数の合計を出力する関数です。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ bracketsは"("と")"の文字列です。
    開き括弧に対応する閉じ括弧が存在する場合はTrueを返します。

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

def correct_bracketing(brackets: str):
    """与えられた文字列bracketsは"("と")"のみで構成されています。
    すべての開き括弧に対応する閉じ括弧が存在する場合はTrueを返します。

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


def derivative(xs: list):
    """ xsは多項式の係数を表します。
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    この多項式の導関数を同じ形式で返します。
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """FibFib数列はフィボナッチ数列に似た数列で、以下のように定義されます：
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)
    この関数は、FibFib数列のn番目の要素を効率的に計算します。
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib数列はフィボナッチ数列に似た数列で、以下のように定義されます：
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    FibFib数列のn番目の要素を効率的に計算する関数を作成してください。
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
テストケースをさらに追加してください。
"""

def vowels_count(s):
    """文字列として与えられた単語の母音の数を返す関数vowels_countを作成します。
    ここでの母音は'a'、'e'、'i'、'o'、'u'です。また、'y'は単語の最後にある
    場合のみ母音として扱われます。

    例：
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
テストケースを追加する。
"""

def vowels_count(s):
    """文字列として単語を受け取り、その文字列内の母音の数を返す関数vowels_countを作成します。
    この場合の母音は'a'、'e'、'i'、'o'、'u'です。また、'y'も母音として扱いますが、
    与えられた単語の最後にある場合のみです。

    例：
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """整数xの各数字を循環的に右へshiftだけシフトし、
    結果を文字列として返します。
    shiftが数字の桁数より大きい場合は、数字を反転して返します。
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """整数xの桁を循環的にシフトし、桁を右にシフト分移動させ、
    結果を文字列として返します。
    シフトが桁数より大きい場合は、桁を反転して返します。
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """タスク
    文字列を入力として受け取り、大文字のみのASCIIコードの合計を返す関数を作成してください。

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

def digitSum(s):
    """課題
    文字列を入力として受け取り、大文字のみのASCIIコードの合計を返す関数を作成してください。

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


def fruit_distribution(s,n):
    """
    このタスクでは、フルーツバスケットに配置されているリンゴとオレンジの数を表す文字列が与えられます。
    このバスケットには、リンゴ、オレンジ、マンゴーが入っています。リンゴとオレンジの合計数を表す
    文字列と、バスケット内のフルーツの総数を表す整数が与えられた場合、バスケット内のマンゴーの数を
    返してください。
    例えば：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    このタスクでは、フルーツバスケットに入っているリンゴとオレンジの数を表す文字列が与えられます。
    このバスケットには、リンゴ、オレンジ、マンゴーが入っています。リンゴとオレンジの合計数を表す
    文字列と、バスケット内のフルーツの総数を表す整数が与えられた時、バスケット内のマンゴーの数を
    返してください。
    例えば：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    この課題では、果物籠に入っているリンゴとオレンジの数を表す文字列が与えられます。
    この果物籠には、リンゴ、オレンジ、マンゴーが入っています。
    リンゴとオレンジの合計数を表す文字列と、籠の中の果物の総数を表す整数が与えられたとき、
    籠の中のマンゴーの数を返してください。
    例えば：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    非負整数のノードを持つツリーのブランチを表す配列が与えられた場合、
    ノードの1つを選んで返すのが課題です。
    選ばれるノードは最小の偶数値を持つノードでなければなりません。
    同じ最小偶数値を持つノードが複数ある場合は、最も小さいインデックスを持つノードを返します。

    選ばれたノードは配列 [最小値, そのインデックス] として返されます。
    偶数値が存在しない場合や配列が空の場合は、[] を返します。

    例1:
        Input: [4,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最小のインデックスを持っています。

    例2:
        Input: [1,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最小のインデックスを持っています。

    例3:
        Input: []
        Output: []

    例4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        説明: 0が最小値ですが、0が2つあるため、
              最小のインデックスを持つ最初の0を選びます。

    制約:
        * 1 <= ノードの長さ <= 10000
        * 0 <= ノードの値
    """

def pluck(arr):
    """
    非負整数のノードを持つ木の枝を表す配列が与えられたとき、
    ノードの1つを摘み取って返す必要があります。
    摘み取るノードは、最小の偶数値を持つノードである必要があります。
    同じ最小偶数値を持つノードが複数ある場合は、最も小さいインデックスを持つノードを返します。

    摘み取ったノードは[最小値, そのインデックス]というリストで返されます。
    偶数値が存在しない場合や、与えられた配列が空の場合は[]を返します。

    例1：
        Input: [4,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最も小さいインデックスを持ちます。

    例2：
        Input: [1,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最も小さいインデックスを持ちます。

    例3：
        Input: []
        Output: []

    例4：
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        説明: 0が最小値ですが、0が2つあるため、
              最も小さいインデックスを持つ最初の0を選びます。

    制約条件：
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    非負整数のノードを持つツリーのブランチを表す配列が与えられた場合、
    ノードの1つを選んで返すのが課題です。
    選ばれるノードは最小の偶数値を持つノードでなければなりません。
    同じ最小偶数値を持つノードが複数見つかった場合は、最も小さいインデックスを持つノードを返します。

    選ばれたノードは配列 [最小値, そのインデックス] として返される必要があります。
    偶数値が存在しない場合や、与えられた配列が空の場合は [] を返します。

    例 1:
        Input: [4,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最小のインデックスを持っています。

    例 2:
        Input: [1,2,3]
        Output: [2, 1]
        説明: 2が最小の偶数値で、2は最小のインデックスを持っています。

    例 3:
        Input: []
        Output: []

    例 4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        説明: 0が最小値ですが、0が2つあるため、
              最小のインデックスを持つ最初の0を選びます。

    制約:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    正の整数から成る空でないリストが与えられます。0より大きく、その整数自身の値以上の出現回数を持つ
    最も大きい整数を返します。
    出現回数とは、その整数がリスト内で出現する回数を指します。
    そのような値が存在しない場合は-1を返します。

    例：
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    正の整数からなる空でないリストが与えられます。0より大きく、
    その整数自体の値以上の出現頻度を持つ最大の整数を返してください。
    整数の出現頻度とは、リスト内でその数値が出現する回数のことです。
    そのような値が存在しない場合は、-1を返してください。
    例：
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    正の整数からなる空でないリストが与えられます。0より大きく、その整数自体の値以上の出現頻度を
    持つ最大の整数を返してください。
    整数の出現頻度とは、リスト内でその整数が出現する回数のことです。
    そのような値が存在しない場合は、-1を返します。
    Examples:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    整数のリストが与えられた場合、奇妙な順序でリストを返します。
    奇妙なソートとは、最小値から始まり、
    残りの整数の最大値、そして最小値というように続けていくことです。

    例：
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    整数のリストが与えられたとき、特殊な順序でソートしたリストを返します。
    この特殊なソートとは、まず最小値を選び、次に残りの整数の中から最大値を選び、
    その後また最小値というように交互に選んでいく方法です。

    例：
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    三角形の三辺の長さが与えられます。三辺が有効な三角形を形成する場合、
    三角形の面積を小数点以下2桁に四捨五入して返します。
    それ以外の場合は-1を返します。
    三辺が有効な三角形を形成するのは、任意の二辺の和が残りの辺より大きい場合です。
    例：
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    三角形の3辺の長さが与えられます。3辺が有効な三角形を形成する場合、
    三角形の面積を小数点以下2桁に四捨五入して返します。
    それ以外の場合は-1を返します。
    任意の2辺の和が第3辺より大きい場合、3辺は有効な三角形を形成します。
    例：
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    三角形の3辺の長さが与えられます。3辺が有効な三角形を形成する場合、
    三角形の面積を小数点以下2桁に四捨五入して返します。
    そうでない場合は-1を返します。
    3辺が有効な三角形を形成するのは、任意の2辺の和が残りの1辺より大きい場合です。
    Example:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    オブジェクトqが飛行可能かどうかを判断し、可能な場合はTrue、不可能な場合はFalseを返す関数を作成します。
    オブジェクトqは、バランスが取れている（回文リストである）場合、かつその要素の合計が最大可能重量w以下である場合に飛行可能となります。

    例：
    will_it_fly([1, 2], 5) ➞ False
    # 1+2は最大可能重量以下ですが、バランスが取れていません。

    will_it_fly([3, 2, 3], 1) ➞ False
    # バランスは取れていますが、3+2+3が最大可能重量を超えています。

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3は最大可能重量以下で、バランスも取れています。

    will_it_fly([3], 5) ➞ True
    # 3は最大可能重量以下で、バランスも取れています。
    '''

def will_it_fly(q,w):
    '''
    オブジェクトqが飛行可能かどうかを判定し、可能な場合はTrue、不可能な場合はFalseを返す関数を作成します。
    オブジェクトqは、バランスが取れている（回文リストである）かつ、その要素の合計が最大可能重量w以下である場合に飛行可能となります。

    例：
    will_it_fly([1, 2], 5) ➞ False
    # 1+2は最大可能重量以下ですが、バランスが取れていません。

    will_it_fly([3, 2, 3], 1) ➞ False
    # バランスは取れていますが、3+2+3が最大可能重量を超えています。

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3は最大可能重量以下で、バランスも取れています。

    will_it_fly([3], 5) ➞ True
    # 3は最大可能重量以下で、バランスも取れています。
    '''

def will_it_fly(q,w):
    '''
    オブジェクトqが飛行可能かどうかを判断し、飛行可能な場合はTrue、そうでない場合はFalseを返す関数を作成します。
    オブジェクトqは、バランスが取れている（回文リストである）かつ要素の合計が最大許容重量w以下である場合に飛行可能となります。

    例：
    will_it_fly([1, 2], 5) ➞ False
    # 1+2は最大許容重量以下ですが、バランスが取れていません。

    will_it_fly([3, 2, 3], 1) ➞ False
    # バランスは取れていますが、3+2+3が最大許容重量を超えています。

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3は最大許容重量以下で、バランスも取れています。

    will_it_fly([3], 5) ➞ True
    # 3は最大許容重量以下で、バランスも取れています。
    '''


def smallest_change(arr):
    """
    整数の配列 arr が与えられた場合、配列を回文にするために変更が必要な要素の最小数を見つけます。
    回文配列とは、前から読んでも後ろから読んでも同じ配列のことです。
    1回の変更で、1つの要素を他の任意の要素に変更できます。

    例えば：
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    整数の配列 arr が与えられた場合、配列を回文にするために変更が必要な要素の最小数を見つけます。
    回文配列とは、前から読んでも後ろから読んでも同じ配列のことです。1回の変更で、1つの要素を
    他の任意の要素に変更することができます。

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

def smallest_change(arr):
    """
    整数の配列arrが与えられたとき、配列を回文にするために変更が必要な要素の最小数を
    求めてください。回文配列とは、前から読んでも後ろから読んでも同じ配列のことです。
    1回の変更で、1つの要素を任意の他の要素に変更できます。

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


def total_match(lst1, lst2):
    '''
    2つの文字列リストを受け取り、すべての文字列の合計文字数が他方のリストより少ないリストを返す関数です。

    両方のリストの文字数が同じ場合は、最初のリストを返します。

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

def total_match(lst1, lst2):
    '''
    2つの文字列リストを受け取り、リスト内のすべての文字列の文字の総数が
    もう一方のリストより少ないリストを返す関数を作成します。

    両方のリストの文字の総数が同じ場合は、1つ目のリストを返します。

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

def total_match(lst1, lst2):
    '''
    2つの文字列リストを受け取り、リスト内のすべての文字列の合計文字数が
    もう一方のリストより少ない方のリストを返す関数を作成します。

    両方のリストの文字数が同じ場合は、最初のリストを返します。

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


def is_multiply_prime(a):
    """与えられた数値が3つの素数の積である場合はTrueを返し、
    そうでない場合はFalseを返す関数を作成します。
    ただし、(a)は100未満とします。
    例：
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """与えられた数が3つの素数の積である場合は真を返し、
    そうでない場合は偽を返す関数を作成します。
    ただし、(a)は100未満とします。
    例：
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """数値 x が n の単純なべき乗である場合に true を返し、それ以外の場合は false を返す関数を作成してください。
    x が n の単純なべき乗であるとは、n ** int = x が成り立つ場合を指します。
    例：
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """あなたの課題は、数値xがnの単純なべき乗である場合にtrueを返し、
    それ以外の場合にfalseを返す関数を作成することです。
    xがnの単純なべき乗とは、n**int=xとなる場合です。
    例えば：
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    整数aを受け取り、その整数が何らかの整数の3乗である場合にTrueを返す関数を作成します。
    注意：入力は常に有効であると仮定できます。
    例：
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    整数aを受け取り、その整数がある整数の立方である場合はTrue、
    そうでない場合はFalseを返す関数を作成してください。
    注：入力は常に有効であると仮定して構いません。
    例：
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """文字列として16進数を受け取り、素数である16進数の桁数を数える関数を作成してください
    （素数とは、1より大きい自然数で、1とその数自身以外の自然数では割り切れない数のことです）。
    16進数の数字は 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F です。
    素数は 2, 3, 5, 7, 11, 13, 17,... です。
    したがって、以下の数字の個数を判定する必要があります：2, 3, 5, 7,
    B（10進数の11）, D（10進数の13）。
    注意：入力は常に正しいか空文字列であり、
    記号 A,B,C,D,E,F は常に大文字であると仮定してください。
    例：
    num = "AB" の場合、出力は 1 になります。
    num = "1077E" の場合、出力は 2 になります。
    num = "ABED1A33" の場合、出力は 4 になります。
    num = "123456789ABCDEF0" の場合、出力は 6 になります。
    num = "2020" の場合、出力は 2 になります。
    """

def hex_key(num):
    """16進数の数値を文字列として受け取り、素数である16進数の桁数を数える関数を作成する必要があります
    （素数とは、1より大きい自然数で、2つのより小さい自然数の積として表せない数のことです）。
    16進数の数字は 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F です。
    素数は 2, 3, 5, 7, 11, 13, 17,... です。
    したがって、以下の数字の数を判定する必要があります：2, 3, 5, 7,
    B (=10進数の11), D (=10進数の13)。
    注意：入力は常に正しいか空の文字列であり、
    記号A,B,C,D,E,Fは常に大文字であると仮定できます。
    例：
    num = "AB" の場合、出力は1になります。
    num = "1077E" の場合、出力は2になります。
    num = "ABED1A33" の場合、出力は4になります。
    num = "123456789ABCDEF0" の場合、出力は6になります。
    num = "2020" の場合、出力は2になります。
    """


def decimal_to_binary(decimal):
    """10進数が与えられたとき、それを2進数形式に変換するのが課題です。
    関数は文字列を返し、各文字は2進数の数字を表します。
    文字列の各文字は'0'または'1'となります。

    文字列の先頭と末尾には'db'という追加の文字が付きます。
    これらの追加文字は、フォーマットを補助するためのものです。

    例：
    decimal_to_binary(15)   # "db1111db" を返す
    decimal_to_binary(32)   # "db100000db" を返す
    """

def decimal_to_binary(decimal):
    """10進数の数値が与えられ、それをバイナリ形式に変換することが課題です。
    関数は文字列を返し、各文字はバイナリ数を表します。文字列の各文字は'0'または'1'となります。

    文字列の先頭と末尾には'db'という追加の文字が付きます。
    これらの追加文字は形式を整えるためのものです。

    例：
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """10進数の数値が与えられ、それをバイナリ形式に変換することが課題です。
    関数は文字列を返し、各文字はバイナリ数を表します。文字列の各文字は'0'または'1'となります。

    文字列の先頭と末尾には'db'という追加の文字が付きます。
    この追加文字は形式を整えるために存在します。

    例：
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """文字列sが与えられます。
    文字列が幸せかどうかを確認するのが課題です。
    文字列が幸せとは、長さが3以上で、連続する3文字がすべて異なる場合です。
    例：
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """文字列sが与えられます。
    あなたのタスクは、その文字列がハッピーであるかどうかを判定することです。
    文字列がハッピーであるためには、長さが少なくとも3であり、連続する3つの文字がすべて異なる必要があります。
    例：
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """学期の最終週であり、教師は生徒に成績を付ける必要があります。
    教師は独自の採点アルゴリズムを作成していました。
    唯一の問題は、採点に使用していたコードを紛失してしまったことです。
    教師は一部の生徒のGPAのリストを提供しており、あなたは
    以下の表を使用して文字による成績のリストを出力する関数を作成する必要があります：
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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

def numerical_letter_grade(grades):
    """これは学期の最終週で、教師は生徒に成績を付ける必要があります。
    教師は採点のための独自のアルゴリズムを作成していました。
    唯一の問題は、採点に使用していたコードを紛失してしまったことです。
    教師は一部の生徒のGPAのリストを提供しており、あなたは
    以下の表を使用して文字による成績のリストを出力する関数を作成する必要があります：
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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

def numerical_letter_grade(grades):
    """学期の最終週で、教師は学生に成績を付けなければなりません。
    教師は独自の採点アルゴリズムを使用していましたが、
    採点に使用していたコードを紛失してしまいました。
    教師は一部の学生のGPAのリストを提供しており、
    あなたは以下の表を使用して評価のリストを
    出力する関数を作成する必要があります：
             GPA       |    評価
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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


def prime_length(string):
    """文字列を受け取り、その文字列の長さが素数の場合はTrue、
    そうでない場合はFalseを返す関数です。
    例：
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """文字列を受け取り、その文字列の長さが素数の場合はTrue、
    そうでない場合はFalseを返す関数を作成します
    例
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """文字列を受け取り、その長さが素数の場合はTrue、
    そうでない場合はFalseを返す関数を作成します
    例
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    正の整数nが与えられた場合、1で始まるまたは1で終わる
    n桁の正の整数の数を返します。
    """

def starts_one_ends(n):
    """
    正の整数nに対して、1で始まるか1で終わるn桁の正の整数の個数を返します。
    """

def starts_one_ends(n):
    """
    正の整数nが与えられたとき、1で始まるか終わるn桁の正の整数の個数を返します。
    """


def solve(N):
    """
    正の整数 N が与えられたとき、その桁の合計を計算し、その合計を 2 進数で表した文字列を返します。

    例:
        N = 1000 の場合、桁の合計は 1 なので、出力は "1" です。
        N = 150 の場合、桁の合計は 6 なので、出力は "110" です。
        N = 147 の場合、桁の合計は 12 なので、出力は "1100" です。

    変数:
        @N 整数
            制約: 0 ≤ N ≤ 10000
    Output:
        桁の合計を 2 進数で表した文字列
    """

def solve(N):
    """正の整数Nが与えられた場合、その桁の合計を2進数で返します。

    例
        N = 1000の場合、桁の合計は1となり、出力は"1"となります。
        N = 150の場合、桁の合計は6となり、出力は"110"となります。
        N = 147の場合、桁の合計は12となり、出力は"1100"となります。

    Variables:
        @N integer
             Constraints: 0 ≤ N ≤ 10000.
    Output:
         a string of binary number
    """


def add(lst):
    """空でない整数のリストlstが与えられたとき、奇数のインデックスにある偶数の要素の合計を返します。

    例：
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """空ではない整数のリストlstが与えられます。奇数のインデックスにある偶数の要素を加算します。

    例：
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """空でない整数のリストlstが与えられます。奇数のインデックスにある偶数の要素を加算します。

    例：
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    文字列を受け取り、その順序付けされたバージョンを返す関数を作成します。
    順序付けされた文字列とは、（スペースで区切られた）すべての単語が、
    ASCII値に基づいて昇順に並べ替えられた文字で構成される新しい単語に
    置き換えられた文字列のことです。
    注意：文章内の単語の順序と空白は維持する必要があります。

    例：
    anti_shuffle('Hi') は 'Hi' を返します
    anti_shuffle('hello') は 'ehllo' を返します
    anti_shuffle('Hello World!!!') は 'Hello !!!Wdlor' を返します
    """

def anti_shuffle(s):
    """
    文字列を受け取り、その整列された版を返す関数を作成します。
    整列された版とは、（空白で区切られた）すべての単語が、
    その中の文字をASCII値に基づいて昇順に並べ替えた新しい単語に
    置き換えられた文字列のことです。
    注意：文中の単語の順序と空白の位置は維持する必要があります。

    例：
    anti_shuffle('Hi')は'Hi'を返します
    anti_shuffle('hello')は'ehllo'を返します
    anti_shuffle('Hello World!!!')は'Hello !!!Wdlor'を返します
    """

def anti_shuffle(s):
    """
    文字列を受け取り、その順序付けされたバージョンを返す関数を作成します。
    順序付けされたバージョンとは、（スペースで区切られた）すべての単語が、
    ASCII値に基づいて昇順に並べ替えられた文字で構成される新しい単語に
    置き換えられた文字列のことです。
    注意：文章内の単語の順序と空白は維持する必要があります。

    例：
    anti_shuffle('Hi') は 'Hi' を返します
    anti_shuffle('hello') は 'ehllo' を返します
    anti_shuffle('Hello World!!!') は 'Hello !!!Wdlor' を返します
    """


def get_row(lst, x):
    """
    2次元データがネストされたリストとして与えられます。
    これは行列に似ていますが、行列とは異なり、
    各行の列数が異なる場合があります。
    lstと整数xが与えられた場合、リスト内のxを見つけ、
    タプルのリスト[(x1, y1), (x2, y2) ...]を返します。
    各タプルは座標(行、列)を表し、0から始まります。
    座標は最初に行で昇順にソートします。
    また、行の座標は列で降順にソートします。

    例：
    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):
    """
    2次元データとして、ネストされたリストが与えられます。
    これは行列に似ていますが、行列とは異なり、
    各行の列数が異なる場合があります。
    lstと整数xが与えられたとき、リスト内の整数xを見つけ、
    [(x1, y1), (x2, y2) ...]のようなタプルのリストを返します。
    各タプルは座標（行、列）を表し、0から始まります。
    座標は最初に行を昇順でソートします。
    また、行の座標は列を降順でソートします。

    例：
    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):
    """
    非負整数の配列が与えられたとき、その配列をソートしたコピーを返します。
    最初のインデックスの値と最後のインデックスの値の合計が奇数の場合は昇順に、
    偶数の場合は降順にソートします。

    注意：
    * 与えられた配列を変更しないでください。

    例：
    * 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):
    """
    非負整数の配列が与えられた場合、ソート後の配列のコピーを返します。
    最初のインデックス値と最後のインデックス値の合計が奇数の場合は昇順にソートし、
    最初のインデックス値と最後のインデックス値の合計が偶数の場合は降順にソートします。

    注意：
    * 与えられた配列を変更しないでください。

    例：
    * 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):
    """文字列を引数として受け取り、アルファベットを回転させて暗号化された
    文字列を返す関数encryptを作成してください。
    アルファベットは、文字が2つずつ2つの位置だけ下にシフトする形で
    回転される必要があります。
    例：
    encrypt('hi') は 'lm' を返します
    encrypt('asdfghjkl') は 'ewhjklnop' を返します
    encrypt('gf') は 'kj' を返します
    encrypt('et') は 'ix' を返します
    """

def encrypt(s):
    """ encrypt 関数は、文字列を引数として受け取り、アルファベットを回転させて暗号化された文字列を返します。
    具体的には、アルファベットの各文字を「2 × 2 = 4」文字分ずつ後ろにシフトさせます。
    アルファベットの端を越えた場合（例えば、'z' 以降）は、循環して先頭文字に戻ります。
    例:
    encrypt('hi') は 'lm' を返します
    encrypt('asdfghjkl') は 'ewhjklnop' を返します
    encrypt('gf') は 'kj' を返します
    encrypt('et') は 'ix' を返します
    """

def encrypt(s):
    """文字列を引数として受け取り、アルファベットを回転させて
    暗号化された文字列を返す関数を作成します。
    アルファベットは、文字が2を2倍した数だけ
    下方向にシフトするような方法で回転させる必要があります。
    例：
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """


def next_smallest(lst):
    """
    整数のリストが与えられます。
    2番目に小さい要素を返す関数next_smallest()を作成してください。
    該当する要素が存在しない場合はNoneを返します。

    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):
    """
    整数のリストが与えられます。
    関数 next_smallest() を作成し、そのリストの2番目に小さい要素を返します。
    そのような要素が存在しない場合は None を返してください。

    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):
    """
    整数のリストが与えられます。
    リストの 2 番目に小さい要素を返す関数 next_smallest() を記述します。
    そのような要素がない場合は None を返します。

    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):
    """
    文字列が与えられ、退屈度をカウントする必要があります。
    退屈度とは「I」という単語で始まる文章の数を指します。
    文章は「.」、「?」、「!」で区切られています。

    例：
    >>> 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):
    '''
    3つの数値を受け取る関数を作成します。
    3つの数値のうち1つが他の2つの合計と等しく、かつすべての数値が整数である場合はTrueを返します。
    その他の場合はFalseを返します。

    Examples
    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):
    '''
    3つの数値を受け取る関数を作成します。
    1つの数が他の2つの合計に等しく、すべての数が整数である場合にtrueを返します。
    上記以外の場合はFalseを返します。

    例
    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):
    '''
    3つの数値を受け取る関数を作成します。
    3つの数値がすべて整数で、かつそのうちの1つが他の2つの合計と等しい場合はTrueを返します。
    それ以外の場合はFalseを返します。

    Examples
    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):
    """
    メッセージを受け取り、以下のルールで暗号化する関数：
    - すべての文字の大文字小文字を入れ替える
    - メッセージ内のすべての母音を、アルファベットでその母音の2文字後の文字に置き換える
    文字のみを想定する

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

def encode(message):
    """
    メッセージを受け取り、以下のルールで暗号化する関数を作成してください：
    全ての文字の大文字小文字を入れ替え、メッセージ内の全ての母音を
    英語のアルファベットでその母音から2文字後ろの文字に置き換えます。
    アルファベットのみが含まれていると仮定します。

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

def encode(message):
    """
    メッセージを受け取り、以下のような方法で暗号化する関数を作成してください：
    すべての文字の大文字小文字を入れ替え、メッセージ内のすべての母音を
    アルファベットでその母音の2文字後に位置する文字に置き換えます。
    文字のみを想定します。

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


def skjkasdkd(lst):
    """整数のリストが与えられます。
    最大の素数を見つけて、その桁の合計を返す必要があります。

    例：
    lst = [0,3,2,1,3,5,7,4,5,5,5,5,2,181,32,4,32,3,2,32,324,4,3] の場合、出力は 10 になります。
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] の場合、出力は 25 になります。
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] の場合、出力は 13 になります
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] の場合、出力は 11 になります
    lst = [0,81,12,3,1,21] の場合、出力は 3 になります
    lst = [0,8,1,2,1,7] の場合、出力は 7 になります。
    """

def skjkasdkd(lst):
    """整数のリストが与えられます。
    リスト内の最大の素数を見つけ、その素数の各桁の合計を返す必要があります。

    例：
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] の場合、出力は10となります
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] の場合、出力は25となります
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] の場合、出力は13となります
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] の場合、出力は11となります
    lst = [0,81,12,3,1,21] の場合、出力は3となります
    lst = [0,8,1,2,1,7] の場合、出力は7となります
    """

def skjkasdkd(lst):
    """整数のリストが与えられます。
    最大の素数を見つけ、その各桁の合計を返す必要があります。

    例：
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] の場合、出力は 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] の場合、出力は 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] の場合、出力は 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] の場合、出力は 11
    lst = [0,81,12,3,1,21] の場合、出力は 3
    lst = [0,8,1,2,1,7] の場合、出力は 7
    """


def check_dict_case(dict):
    """
    与えられた辞書に対して、すべてのキーが小文字の文字列であるか、
    すべてのキーが大文字の文字列である場合はTrueを返し、
    それ以外の場合はFalseを返します。
    与えられた辞書が空の場合はFalseを返します。
    例：
    check_dict_case({"a":"apple", "b":"banana"}) はTrueを返します。
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) はFalseを返します。
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) はFalseを返します。
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) はFalseを返します。
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) はTrueを返します。
    """

def check_dict_case(dict):
    """
    辞書が与えられた場合、すべてのキーが小文字の文字列であるか、すべてのキーが大文字の文字列である場合にTrueを返し、
    それ以外の場合はFalseを返します。
    与えられた辞書が空の場合、関数はFalseを返すべきです。
    例：
    check_dict_case({"a":"apple", "b":"banana"}) は True を返す必要があります。
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) は False を返す必要があります。
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) は False を返す必要があります。
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) は False を返す必要があります。
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) は True を返す必要があります。
    """

def check_dict_case(dict):
    """
    辞書が与えられたとき、すべてのキーが小文字の文字列であるか、
    すべてのキーが大文字の文字列である場合はTrueを返し、そうでない場合はFalseを返します。
    また、与えられた辞書が空の場合もFalseを返します。

    例：
    check_dict_case({"a":"apple", "b":"banana"}) は True を返します。
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) は False を返します。
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) は False を返します。
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) は False を返します。
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) は True を返します。
    """


def count_up_to(n):
    """非負整数を受け取り、n未満の素数である最初のn個の整数の配列を返す関数を実装します。
    例：
    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):
    """非負整数を受け取り、n未満の素数を順番に並べた配列を返す関数を実装します。
    例：
    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):
    """2つの整数を受け取り、それらの一の位の数字の積を返す関数です。
    入力は常に有効であると仮定します。
    例：
    multiply(148, 412) は 16 を返します。
    multiply(19, 28) は 72 を返します。
    multiply(2020, 1851) は 0 を返します。
    multiply(14,-15) は 20 を返します。
    """

def multiply(a, b):
    """2つの整数を受け取り、それらの1の位の数字の積を返す関数を完成させてください。
    入力は常に有効であると仮定します。
    例：
    multiply(148, 412) は 16 を返します。
    multiply(19, 28) は 72 を返します。
    multiply(2020, 1851) は 0 を返します。
    multiply(14,-15) は 20 を返します。
    """


def count_upper(s):
    """
    与えられた文字列sの偶数のインデックスにある大文字の母音の数を数えます。

    例：
    count_upper('aBCdEf') は 1 を返します
    count_upper('abcdefg') は 0 を返します
    count_upper('dBBE') は 0 を返します
    """

def count_upper(s):
    """
    文字列 s が与えられた場合、偶数インデックスの大文字の母音の数を数えます。

    例えば：
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    文字列sが与えられた場合、偶数のインデックスにある大文字の母音の数を数えます。

    例：
    count_upper('aBCdEf') は1を返します
    count_upper('abcdefg') は0を返します
    count_upper('dBBE') は0を返します
    """


def closest_integer(value):
    '''
    与えられた数値（文字列）を受け取り、最も近い整数を返す関数を作成します。
    数値が2つの整数から等距離にある場合は、0から遠い方に丸めます。

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

    注意:
    0から遠い方への丸めとは、与えられた数値が2つの整数から等距離にある場合、
    0からより遠い方の整数を返すということです。例えば、closest_integer("14.5")は
    15を返し、closest_integer("-14.5")は-15を返すべきです。
    '''

def closest_integer(value):
    '''
    文字列として与えられた数値に最も近い整数を返す関数を作成します。
    その数が2つの整数から等距離にある場合は、0から遠い方に丸めます。

    例：
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    注意：
    0から遠い方向への丸めとは、与えられた数が2つの整数から等距離にある場合、
    0からより遠い方の整数を返すということです。
    例えば、closest_integer("14.5")は15を返し、
    closest_integer("-14.5")は-15を返すべきです。
    '''

def closest_integer(value):
    '''
    与えられた数値（文字列）を受け取り、最も近い整数を返す関数を作成します。
    数値が2つの整数から等距離にある場合、ゼロから遠い方に丸めます。

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

    注意：
    ゼロから遠い方への丸めとは、与えられた数値が2つの整数から等距離にある場合、
    ゼロからより遠い整数を返すということです。例えば、closest_integer("14.5")は
    15を返し、closest_integer("-14.5")は-15を返すべきです。
    '''


def make_a_pile(n):
    """
    正の整数nが与えられた場合、n段の石の山を作る必要があります。
    最初の段にはn個の石があります。
    次の段の石の数は:
        - nが奇数の場合、次の奇数
        - nが偶数の場合、次の偶数
    各段の石の数をリストで返します。インデックスiの要素は
    段(i+1)の石の数を表します。

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

def make_a_pile(n):
    """
    正の整数nが与えられたとき、n段の石の積み重ねを作る必要があります。
    最初の段にはn個の石があります。
    次の段の石の数は以下のルールで決まります：
        - nが奇数の場合、次の奇数
        - nが偶数の場合、次の偶数
    各段の石の数をリストで返します。リストのインデックスiの要素は、
    (i+1)段目の石の数を表します。

    例：
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    カンマまたはスペースで区切られた単語の文字列が与えられます。あなたの課題は、
    その文字列を単語に分割し、単語の配列として返すことです。

    例：
    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):
    """
    単語がカンマまたはスペースで区切られた文字列が与えられます。あなたのタスクは、
    文字列を単語に分割し、単語の配列を返すことです。

    例えば:
    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):
    """
    カンマまたは空白で区切られた単語の文字列が与えられます。あなたの課題は、
    この文字列を単語に分割し、単語の配列として返すことです。

    例：
    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):
    """この関数は2つの正の数値xとyを受け取り、範囲[x, y]（両端を含む）内で
    最大の偶数整数を返します。そのような数値が存在しない場合、
    関数は-1を返します。

    例：
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """この関数は2つの正の数値xとyを受け取り、範囲[x, y]（両端を含む）内にある
    最大の偶数を返します。そのような数値が存在しない場合、
    関数は-1を返します。

    例：
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """この関数は2つの正の数xとyを受け取り、範囲[x, y]内にある
    最大の偶数を返します。そのような数が存在しない場合は-1を返します。

    例：
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """2つの正の整数nとmが与えられ、nからmまでの整数（nとmを含む）の
    平均値を計算するタスクです。
    計算結果を最も近い整数に四捨五入し、その値を2進数に変換してください。
    もしnがmより大きい場合は、-1を返してください。
    例：
    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):
    """2つの正の整数nとmが与えられ、nからm（nとmを含む）までの整数の
    平均値を計算するのが課題です。
    答えを最も近い整数に四捨五入し、それを2進数に変換してください。
    nがmより大きい場合は、-1を返します。
    Example:
    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):
    """2つの正の整数nとmが与えられたとき、nからmまでの整数の平均を計算する
    （nとmを含む）。答えを最も近い整数に丸めて、それを2進数に変換する。
    nがmより大きい場合は、-1を返します。
    例:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """正の整数のリストxが与えられたとき、偶数の数字を1つも含まない
    すべての要素をソートしたリストを返します。

    注：返されるリストは昇順にソートされている必要があります。

    例：
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """正の整数のリストxが与えられた場合、偶数の数字を含まない
    すべての要素をソートしたリストを返します。

    注意：返されるリストは昇順でソートされている必要があります。

    例：
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """正の整数のリストxが与えられた場合、偶数の数字を含まない
    すべての要素をソートしたリストを返します。

    注意：返されるリストは昇順でソートされる必要があります。

    例：
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    整数配列が与えられたとき、1から9までの整数のみを抽出してソートし、
    その結果を逆順にした後、各数字を対応する英語名  "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"に置き換えます。

    例：
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> ソート -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> 逆順 -> [8, 5, 4, 3, 2, 2, 1, 1]
      戻り値：["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      配列が空の場合は空配列を返します：
      arr = []
      戻り値：[]

      範囲外の数字は無視します：
      arr = [1, -1 , 55]
            -> ソート -> [-1, 1, 55]
            -> 逆順 -> [55, 1, -1]
      戻り値：['One']
    """

def by_length(arr):
    """
    1から9までの整数を含む配列が与えられた場合、それらの整数をソートし、
    結果の配列を逆順にし、各数字を対応する
    "One"、"Two"、"Three"、"Four"、"Five"、"Six"、"Seven"、"Eight"、"Nine"の名前に置き換えます。

    例：
      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"]

      配列が空の場合、空の配列を返します：
      arr = []
      return []

      配列に範囲外の数字がある場合、それを無視します：
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ パラメータnを受け取り、サイズnのリストを返す関数fを実装します。
    リストの各要素について、インデックスiが偶数の場合はiの階乗を、
    それ以外の場合は1からiまでの数の合計を値とします。
    iは1から開始します。
    iの階乗は1からiまでの数の掛け算です（1 * 2 * ... * i）。
    例：
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ nをパラメータとして受け取り、サイズnのリストを返す関数fを実装します。
    インデックスiの要素の値は、iが偶数の場合はiの階乗、
    それ以外の場合は1からiまでの数値の合計となります。
    iは1から始まります。
    iの階乗は1からiまでの数値の積です（1 * 2 * ... * i）。
    例：
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    正の整数nが与えられた場合、range(1, n)の範囲内（nを含む）にある偶数と奇数の回文整数の数をタプルとして返します。

    例題 1:

        Input: 3
        Output: (1, 2)
        説明：
        整数の回文は1、2、3です。そのうち1つが偶数で、2つが奇数です。

    例題 2:

        Input: 12
        Output: (4, 6)
        説明：
        整数の回文は1、2、3、4、5、6、7、8、9、11です。そのうち4つが偶数で、6つが奇数です。

    注意：
        1. 1 <= n <= 10^3
        2. 返されるタプルには、それぞれ偶数と奇数の回文整数の数が含まれます。
    """

def even_odd_palindrome(n):
    """
    正の整数nが与えられた時、範囲(1, n)（nを含む）内にある偶数と奇数の
    整数回文数の個数をタプルとして返します。

    例 1:

        入力: 3
    出力: (1, 2)
    　説明:
        整数回文数は1、2、3です。そのうち1つが偶数で、2つが奇数です。

    例　2:

        入力: 12
    　出力: (4, 6)
    説明:
        整数回文数は1、2、3、4、5、6、7、8、9、11です。そのうち4つが偶数で、6つが奇数です。

    注意:
        1. 1 <= n <= 10^3
        2. 返されるタプルには、それぞれ偶数と奇数の整数回文数の個数が含まれます。
    """

def even_odd_palindrome(n):
    """
    正の整数nが与えられた場合、range(1, n)の範囲内（nを含む）にある偶数と奇数の
    整数回文数の数をタプルとして返します。

    例題 1:

        Input: 3
        Output: (1, 2)
        説明:
        整数の回文数は1, 2, 3です。そのうち1つが偶数で、2つが奇数です。

    例題 2:

        Input: 12
        Output: (4, 6)
        説明:
        整数の回文数は1, 2, 3, 4, 5, 6, 7, 8, 9, 11です。そのうち4つが偶数で、6つが奇数です。

    注意:
        1. 1 <= n <= 10^3
        2. 返されるタプルは、それぞれ偶数と奇数の整数回文数の数を表します。
    """


def count_nums(arr):
    """
    整数の配列を受け取り、各要素の各桁の合計が0より大きい要素の数を返す関数です。
    負の数の場合、最初の桁は符号付きとして扱います：
    例えば、-123の場合、符号付きの桁は-1, 2, 3となります。
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    整数の配列を受け取り、各要素の桁の合計が0より大きい要素の数を返す関数を作成します。
    数値が負の場合、最初の符号付き桁は負になります：
    例えば、-123の符号付き桁は-1、2、3となります。
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    配列の整数を受け取り、桁の合計が0より大きい要素の数を返す関数 count_nums を作成します。
    数字が負の場合、その最初の符号付き桁は負になります：
    例：-123 は符号付き桁 -1, 2, 3 を持ちます。
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """N個の整数arr[1], arr[2], ..., arr[N]からなる配列'arr'があります。
    配列内の数字はランダムな順序で並んでいます。与えられた配列に対して
    以下の操作を行うことで、非減少順（昇順）に並べ替えることが可能かどうかを
    判定するのが課題です：
        右シフト操作を任意の回数行うことができます。

    右シフト操作とは、配列のすべての要素を右に1つ移動させることを意味します。
    配列の最後の要素は配列の開始位置、例：インデックス0に移動します。

    上記の操作を行うことでソートされた配列を得ることが可能な場合はTrueを、
    不可能な場合はFalseを返してください。
    与えられた配列が空の場合はTrueを返してください。

    注：与えられる配列は重複のない要素で構成されることが保証されています。

    例：

    move_one_ball([3, 4, 5, 1, 2])==>True
    説明：2回の右シフト操作を行うことで、与えられた配列を非減少順に
          並べ替えることができます。
    move_one_ball([3, 5, 4, 1, 2])==>False
    説明：どのような回数の右シフト操作を行っても、与えられた配列を
          非減少順に並べ替えることはできません。

    """

def move_one_ball(arr):
    """配列 'arr' には N個の整数 arr[1], arr[2], ..., arr[N] があります。
    配列内の数字はランダムに並べられています。与えられた配列に対して
    以下の操作を実行することで、非減少順序の配列を得ることが可能かどうかを
    判断するのが課題です：
        右シフト操作を任意の回数実行することができます。

    1回の右シフト操作とは、配列のすべての要素を右方向に1つ移動することを
    意味します。配列の最後の要素は配列の開始位置（インデックス0）に
    移動されます。

    上記の操作を実行することでソートされた配列を得ることが可能な場合は
    Trueを返し、そうでない場合はFalseを返します。
    与えられた配列が空の場合はTrueを返します。

    注意：与えられたリストには重複する要素がないことが保証されています。

    例：

    move_one_ball([3, 4, 5, 1, 2])==>True
    説明：2回の右シフト操作を実行することで、与えられた配列を
          非減少順序にすることができます。
    move_one_ball([3, 5, 4, 1, 2])==>False
    説明：どのような回数の右シフト操作を実行しても、与えられた配列を
          非減少順序にすることはできません。

    """

def move_one_ball(arr):
    """配列 'arr' には N個の整数 arr[1], arr[2], ..., arr[N] があります。
    配列内の数字はランダムに並べられています。与えられた配列に対して
    以下の操作を実行することで、非減少順序の配列を得ることが可能かどうかを
    判断するのが課題です：
        右シフト操作を任意の回数実行することができます。

    1回の右シフト操作は、配列のすべての要素を右方向に1つ移動することを
    意味します。配列の最後の要素は配列の開始位置（インデックス0）に
    移動されます。

    上記の操作を実行することでソートされた配列を得ることが可能な場合は
    Trueを返し、そうでない場合はFalseを返します。
    与えられた配列が空の場合はTrueを返します。

    注：与えられたリストには重複する要素がないことが保証されています。

    例：

    move_one_ball([3, 4, 5, 1, 2])==>True
    説明：2回の右シフト操作を実行することで、与えられた配列を
          非減少順序にすることができます。
    move_one_ball([3, 5, 4, 1, 2])==>False
    説明：どのような回数の右シフト操作を実行しても、与えられた
          配列を非減少順序にすることはできません。

    """


def exchange(lst1, lst2):
    """この問題では、2つの数値リストを受け取り、要素を交換することで
    lst1を偶数のみのリストにすることが可能かどうかを判断する関数を実装します。
    lst1とlst2の間で交換できる要素の数に制限はありません。
    lst1とlst2の間で要素を交換することで、lst1のすべての要素を
    偶数にすることが可能な場合は、"YES"を返します。
    そうでない場合は、"NO"を返します。
    例：
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    入力リストは空でないことが前提となっています。
    """

def exchange(lst1, lst2):
    """この問題では、2つの数値リストを受け取り、lst1をすべて偶数にするために
    リスト間で要素を交換することが可能かどうかを判定する関数を実装します。
    lst1とlst2の間で交換できる要素の数に制限はありません。
    lst1とlst2の間で要素を交換することで、lst1のすべての要素を偶数にすることが
    可能な場合は"YES"を返します。
    それ以外の場合は"NO"を返します。
    例：
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    入力リストは空ではないものとします。
    """

def exchange(lst1, lst2):
    """この問題では、2つの数値リストを受け取り、要素を交換することで
    lst1を偶数のみのリストにすることが可能かどうかを判定する関数を実装します。
    lst1とlst2の間で交換できる要素の数に制限はありません。
    lst1とlst2の間で要素を交換することで、lst1のすべての要素を
    偶数にすることが可能な場合は"YES"を返します。
    そうでない場合は"NO"を返します。
    例:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    入力リストは空でないことが前提です。
    """


def histogram(test):
    """スペースで区切られた小文字の文字列が与えられた場合、最も繰り返し回数が多い文字と
    その出現回数を含む辞書を返します。
    複数の文字が同じ出現回数を持つ場合、それらすべてを返します。

    例：
    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):
    """空白区切りの小文字からなる文字列が与えられたとき、最も多く出現する文字と
    その出現回数を含む辞書を返します。
    複数の文字が同じ回数出現する場合は、それらすべてを返します。

    例：
    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):
    """スペースで区切られた小文字の文字列が与えられた場合、最も繰り返し回数が多い文字とその出現回数を含む辞書を返します。
    複数の文字が同じ出現回数を持つ場合は、それらすべてを返します。

    例：
    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):
    """課題
    2つの文字列sとcが与えられます。sの中からcに含まれる文字をすべて削除し、
    その結果の文字列が回文かどうかを確認する必要があります。
    回文とは、前から読んでも後ろから読んでも同じ文字列となるものです。
    結果の文字列と回文かどうかの真偽値（True/False）をタプルとして返してください。
    例
    s = "abcde", c = "ae" の場合、結果は ('bcd',False) となります
    s = "abcdef", c = "b" の場合、結果は ('acdef',False) となります
    s = "abcdedcba", c = "ab" の場合、結果は ('cdedc',True) となります
    """

def reverse_delete(s,c):
    """タスク
    2つの文字列sとcが与えられ、cの任意の文字に等しいsのすべての文字を削除する必要があります
    次に、結果の文字列が回文であるかどうかを確認します。
    文字列は、後方と前方と同じように読む場合、回文と呼ばれます。
    結果の文字列とチェックの True/False を含むタプルを返す必要があります。
    例
    s = "abcde", c = "ae" の場合、結果は ('bcd',False) になります。
    s = "abcdef", c = "b" の場合、結果は ('acdef',False) になります。
    s = "abcdedcba", c = "ab" の場合、結果は ('cdedc',True) になります。
    """

def reverse_delete(s,c):
    """タスク
    文字列sとcが与えられ、文字列s内のc内のいずれかの文字と等しい文字をすべて削除し、
    結果の文字列が回文かどうかをチェックする必要があります。
    回文とは、前から読んでも後ろから読んでも同じ文字列のことです。
    結果の文字列とチェック結果（True/False）をタプルとして返す必要があります。
    例
    s = "abcde", c = "ae" の場合、結果は ('bcd',False)
    s = "abcdef", c = "b" の場合、結果は ('acdef',False)
    s = "abcdedcba", c = "ab" の場合、結果は ('cdedc',True)
    """


def odd_count(lst):
    """数字のみで構成された文字列のリストが与えられた場合、リストを返します。
    出力の各要素iは「入力の文字列iにおける奇数要素の数」となります。
    ここで、すべてのiは入力のi番目の文字列における奇数の数に置き換えられます。

    >>> 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):
    """
    整数配列numsが与えられたとき、numsの空でない任意の部分配列の和の最小値を求めます。
    例：
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    整数配列numsが与えられた場合、numsの任意の空でない部分配列の最小和を求めます。
    例
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    整数の配列numsが与えられた場合、numsの任意の空でない部分配列の最小和を求めます。
    例
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    各行が1つの井戸を表す長方形の井戸グリッドが与えられます。
    各行の1は、1単位の水を表します。
    各井戸には水を汲み出すために使用できるバケツがあり、
    すべてのバケツは同じ容量を持っています。
    あなたの課題は、バケツを使用して井戸を空にすることです。
    バケツを下ろす必要がある回数を出力してください。

    例 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    例 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    例 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    制約条件:
        * すべての井戸は同じ長さです
        * 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):
    """
    あなたは井戸の長方形のグリッドを与えられます。各行は単一の井戸を表し、
    行の各1は水の単位を表します。
    各井戸にはそれから水を抽出するために使用できる対応するバケツがあり、
    すべてのバケツは同じ容量を持っています。
    あなたのタスクは、バケツを使って井戸を空にすることです。
    バケツを下ろす必要がある回数を出力してください。

    例1:
        入力:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        出力: 6

    例2:
        入力:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        出力: 5

    例3:
        入力:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        出力: 0

    制約:
        * すべての井戸は同じ長さを持つ
        * 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):
    """
    井戸の長方形グリッドが与えられます。各行は1つの井戸を表し、
    行内の1は1単位の水を表します。
    各井戸には水を汲み出すためのバケツが対応しており、
    すべてのバケツは同じ容量を持っています。
    あなたの課題は、バケツを使用して井戸から水を空にすることです。
    バケツを下ろす必要がある回数を出力してください。

    例 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    例 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    例 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    制約:
        * すべての井戸は同じ長さを持つ
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    このKataでは、非負整数の配列を、その2進数表現における
    1の数に基づいて昇順にソートする必要があります。
    1の数が同じ場合は、10進数の値に基づいてソートします。

    以下のように実装する必要があります：
    >>> 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):
    """文字列sと自然数nが与えられた場合、文字列s内で正確にn個の子音を含む
    すべての単語をリストとして返す関数を実装する必要があります。
    単語は文字列s内に現れる順序で返されます。
    文字列sが空の場合、関数は空のリストを返す必要があります。
    注意：入力文字列には文字とスペースのみが含まれると仮定できます。
    例：
    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):
    """文字列 s と自然数 n が与えられたとき、文字列 s からちょうど n 個の子音を含む
    単語をすべてリストとして返す関数を実装することが求められています。
    これらの単語は文字列 s に現れる順序で返されます。
    文字列 s が空の場合、関数は空のリストを返すべきです。
    注意: 入力文字列には文字とスペースのみが含まれていると仮定してよいです。
    例:
    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):
    """文字列sと自然数nが与えられた時、文字列s内のすべての単語のうち、
    ちょうどn個の子音を含む単語をリストとして返す関数を実装してください。
    単語は文字列s内に出現する順序で返されます。
    文字列sが空の場合は、空のリストを返します。
    注意：入力文字列にはアルファベットとスペースのみが含まれると仮定してよい。
    例：
    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):
    """与えられた単語の中で、右側から見て2つの子音に挟まれた最も近い母音を
    見つけるのが課題です（大文字小文字を区別）。

    先頭と末尾の母音は対象外です。上記の条件を満たす母音が見つからない場合は
    空文字列を返してください。

    与えられる文字列は英語のアルファベットのみを含むと仮定して構いません。

    例：
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """単語が与えられます。あなたのタスクは、単語の右側から2つの子音の間にある
    最も近い母音を見つけることです（大文字と小文字を区別します）。

    始まりと終わりの母音はカウントしません。上記の条件を満たす母音が見つからない場合は、
    空の文字列を返します。

    与えられた文字列が英字のみを含むと仮定してよい。

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

def get_closest_vowel(word):
    """与えられた単語の中で、右側から見て2つの子音に挟まれている母音を探すタスクです
    （大文字・小文字は区別されます）。

    単語の最初と最後にある母音は対象外です。上記の条件を満たす母音が見つからない場合は
    空文字列を返します。

    与えられた文字列は英語のアルファベットのみを含むと仮定できます。

    例：
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    2つの文字列のリストが与えられます。両方の文字列は開き括弧'('または閉じ括弧')'のみで構成されています。
    あなたの仕事は、2つの文字列を何らかの順序で連結して、結果の文字列が適切になる可能性があるかどうかを
    チェックすることです。
    文字列Sは、Sのすべての括弧が均衡している場合にのみ適切とみなされます。
    例えば、文字列'(())()' は適切ですが、文字列'())' は適切ではありません。
    適切な文字列を作成する方法がある場合は'Yes'を返し、ない場合は'No'を返します。

    例：
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    2つの文字列を含むリストが与えられます。各文字列は開き括弧'('または閉じ括弧')'のみで構成されています。
    あなたの仕事は、この2つの文字列を何らかの順序で連結して、正しい文字列を作ることができるかどうかを
    チェックすることです。
    文字列Sは、すべての括弧がバランスの取れている場合にのみ、正しい文字列と見なされます。
    例えば、文字列'(())()'は正しい文字列ですが、文字列'())'は正しくありません。
    正しい文字列を作ることができる場合は'Yes'を、できない場合は'No'を返します。

    例：
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    2つの文字列のリストが与えられます。両方の文字列は開き括弧'('または閉じ括弧')'のみで構成されています。
    あなたの仕事は、2つの文字列を何らかの順序で連結して、結果の文字列が適切になる可能性があるかどうかを
    チェックすることです。
    文字列Sは、S内のすべての括弧が均衡している場合にのみ適切とみなされます。
    例えば、文字列'(())()' は適切ですが、文字列'())' は適切ではありません。
    適切な文字列を作成する方法がある場合は'Yes'を返し、ない場合は'No'を返します。

    例：
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    整数の配列arrと正の整数kが与えられたとき、arr内の最大のk個の数値を含む、
    長さkのソートされたリストを返します。

    例1:

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

    例2:

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

    例3:

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

    注意事項:
        1. 配列の長さは[1, 1000]の範囲内です。
        2. 配列内の要素は[-1000, 1000]の範囲内です。
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    整数の配列arrと正の整数kが与えられた場合、arr内の最大のk個の数値を含む、
    長さkのソートされたリストを返します。

    例 1:

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

    例 2:

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

    例 3:

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

    注意:
        1. 配列の長さは[1, 1000]の範囲内です。
        2. 配列内の要素は[-1000, 1000]の範囲内です。
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    整数の配列 arr と正の整数 k を指定すると、ソートされたリストを返します
    長さ k で、arr の最大 k 数。

    例1:

        入力: arr = [-3, -4, 5], k = 3
        出力: [-4, -3, 5]

    例2:

        入力: arr = [4, -4, 4], k = 2
        出力: [4, 4]

    例3:

        入力: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        出力: [2]

    注意：
        1. 配列の長さは [1, 1000] の範囲になります。
        2.配列内の要素は[-1000、1000]の範囲になります。
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """非空整数リストが与えられた場合、偶数位置にあるすべての奇数要素の合計を返してください。

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


def add_elements(arr, k):
    """
    空ではない整数の配列arrと整数kが与えられたとき、
    配列arrの最初のk個の要素から最大2桁の整数の合計を返します。

    例：

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

    制約条件：
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    整数の配列arrと整数kが与えられた場合、
    配列arrの最初のk個の要素から2桁以下の要素の合計を返します。

    例：

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

    制約：
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    正の整数 n が与えられたとき、コラッツ数列の奇数を含むソートされたリストを返します。

    コラッツの予想は、次のように定義される数列に関する数学の予想です。
    任意の正の整数 n から開始します。その後、各項は次のようにして前の項から得られます。
    前の項が偶数の場合、次の項は前の項の半分です。
    前の項が奇数の場合、次の項は前の項の3倍に1を加えたものです。
    この予想は、n の値が何であっても、数列は常に1に到達するというものです。

    注意:
        1. Collatz(1) は [1] です。
        2. 返されるリストは昇順にソートされます。

    例:
    get_odd_collatz(5) は [1, 5] を返します # 5 のコラッツ数列は [5, 16, 8, 4, 2, 1] であり、奇数は 1 と 5 のみです。
    """

def get_odd_collatz(n):
    """
    正の整数nが与えられた場合、コラッツ数列における奇数をソートしたリストを返します。

    コラッツ予想は数学における予想で、以下のように定義される数列に関するものです：
    任意の正の整数nから始めます。その後、各項は前の項から以下のように得られます：
    前の項が偶数の場合、次の項は前の項の半分になります。前の項が奇数の場合、
    次の項は前の項の3倍に1を加えたものになります。この予想は、nがどのような値であっても、
    数列は必ず1に到達するというものです。

    注意：
        1. Collatz(1)は[1]です。
        2. 返されるリストは昇順でソートされています。

    例：
    get_odd_collatz(5)は[1, 5]を返します # 5のコラッツ数列は[5, 16, 8, 4, 2, 1]で、奇数は1と5のみです。
    """

def get_odd_collatz(n):
    """
    正の整数nが与えられたとき、コラッツ数列に含まれる奇数を昇順にソートしたリストを返します。

    コラッツの予想は数学における予想で、以下のように定義される数列に関するものです：
    任意の正の整数nから始めます。そして、各項は前の項から以下のように得られます：
    前の項が偶数の場合、次の項は前の項の半分になります。
    前の項が奇数の場合、次の項は前の項の3倍に1を加えたものになります。
    この予想は、どのような値のnから始めても、最終的に必ず1に到達するというものです。

    注意事項:
        1. Collatz(1)は[1]です。
        2. 返されるリストは昇順にソートされます。

    例：
    get_odd_collatz(5)は[1, 5]を返します。 # 5のコラッツ数列は[5, 16, 8, 4, 2, 1]で、奇数は1と5のみです。
    """


def valid_date(date):
    """与えられた日付文字列を検証し、日付が有効な場合はTrue、そうでない場合はFalseを返す関数を
    作成する必要があります。
    以下のすべてのルールを満たす場合、その日付は有効とみなされます：
    1. 日付文字列が空でないこと。
    2. 日数が1日未満または1,3,5,7,8,10,12月の場合31日を超えないこと。4,6,9,11月の場合30日を超えないこと。そして、2月の場合29日を超えないこと。
    3. 月は1以上12以下であること。
    4. 日付はmm-dd-yyyyの形式であること。

    例：
    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):
    """与えられた日付文字列を検証し、日付が有効な場合はTrueを、そうでない場合はFalseを返す関数を作成する必要があります。
    以下のすべてのルールが満たされている場合、日付は有効です：
    1. 日付文字列が空でないこと。
    2. 月が1,3,5,7,8,10,12の場合、日数は1未満または31日を超えてはいけません。月が4,6,9,11の場合、日数は1未満または30日を超えてはいけません。また、月が2の場合、日数は1未満または29日を超えてはいけません。
    3. 月は1未満または12を超えてはいけません。
    4. 日付は次の形式である必要があります：mm-dd-yyyy

    例：
    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):
    '''
    与えられた文字列に対して、空白で区切られた単語のリストを返します。空白が存在しない場合は
    カンマ ',' で分割します。カンマも存在しない場合は、アルファベットの順序が奇数である小文字の数を返します。
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25 とします。
    例
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    単語の文字列が与えられた場合、空白で分割された単語のリストを返します。テキストに空白が存在しない場合は、カンマ','で分割する必要があります。
    カンマが存在しない場合は、アルファベットの奇数番目の順序にある小文字の数を返す必要があります。ord('a') = 0、ord('b') = 1、... ord('z') = 25
    例：
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    単語の文字列が与えられた場合、空白文字で分割した単語のリストを返します。
    テキストに空白文字が存在しない場合はカンマ','で分割します。
    カンマも存在しない場合は、アルファベットの順序が奇数である小文字の数を返します。
    ただし、ord('a') = 0、ord('b') = 1、... ord('z') = 25 とします。
    例
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    数値のリストが与えられた場合、それらが昇順にソートされているかどうかを返します。
    リストに同じ数値が2回以上重複している場合はFalseを返します。
    負の数値は含まれず、整数のみと仮定します。

    例
    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):
    '''
    数値のリストが与えられたとき、それらが昇順にソートされているかどうかを返します。
    リストに同じ数値が2回以上重複している場合はFalseを返します。
    負の数は含まれず、すべて整数であると仮定します。

    例
    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
    '''