Prompt:
長方形のグリッド状(grid)の井戸が与えられる。各行が1つの井戸を表し、
    行の1が1単位の水を表す。
    各井戸には，そこから水を汲み上げるのに使える対応するバケツがあり，
    すべてのバケツ容量(capacity)は同じである．
    あなたの仕事は，バケツを使って井戸を空にすることである．
    バケツを降ろす回数を出力せよ．

    例 1:
        入力:
            グリッド : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            バケツ容量 : 1
        出力: 6

    例 2:
        入力:
            グリッド : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            バケツ容量 : 2
        出力: 5

    例 3:
        入力:
            グリッド : [[0,0,0], [0,0,0]]
            バケツ容量 : 5
        出力: 0

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

def max_fill(grid, capacity):
    return sum([math.ceil(sum(arr)/capacity) for arr in grid])

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([[0,0,1,0], [0,1,0,0], [1,1,1,1]], 1) == 6, "Error"
    assert candidate([[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]], 2) == 5, "Error"
    assert candidate([[0,0,0], [0,0,0]], 5) == 0, "Error"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([[1,1,1,1], [1,1,1,1]], 2) == 4, "Error"
    assert candidate([[1,1,1,1], [1,1,1,1]], 9) == 2, "Error"

candidate = max_fill
check(candidate)


Prompt:
この問題では、非負整数の配列を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 sort_array(arr):
    return sorted(sorted(arr), key=lambda x: bin(x)[2:].count('1'))

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,5,2,3,4]) == [1, 2, 4, 3, 5]
    assert candidate([-2,-3,-4,-5,-6]) == [-4, -2, -6, -5, -3]
    assert candidate([1,0,2,3,4]) == [0, 1, 2, 4, 3]
    assert candidate([]) == []
    assert candidate([2,5,77,4,5,3,5,7,2,3,4]) == [2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]
    assert candidate([3,6,44,12,32,5]) == [32, 3, 5, 6, 12, 44]
    assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
    assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

candidate = sort_array
check(candidate)


Prompt:
ある文字列sと自然数nが与えらる。あなたに課せられたタスクは、文字列s
    の中から、ちょうどn個の子音を含むすべての単語のリストを現れる順に返す
    関数を実装することである。
    注意：入力文字列には英文字と空白しか含まれないと仮定してもよい。
    例:
    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):
    result = []
    for word in s.split():
        n_consonants = 0
        for i in range(0, len(word)):
            if word[i].lower() not in ["a","e","i","o","u"]:
                n_consonants += 1
        if n_consonants == n:
            result.append(word)
    return result

def check(candidate):

    # Check some simple cases
    assert candidate("Mary had a little lamb", 4) == ["little"], "First test error: " + str(candidate("Mary had a little lamb", 4))
    assert candidate("Mary had a little lamb", 3) == ["Mary", "lamb"], "Second test error: " + str(candidate("Mary had a little lamb", 3))
    assert candidate("simple white space", 2) == [], "Third test error: " + str(candidate("simple white space", 2))
    assert candidate("Hello world", 4) == ["world"], "Fourth test error: " + str(candidate("Hello world", 4))
    assert candidate("Uncle sam", 3) == ["Uncle"], "Fifth test error: " + str(candidate("Uncle sam", 3))

    # Check some edge cases that are easy to work out by hand.
    assert candidate("", 4) == [], "1st edge test error: " + str(candidate("", 4))
    assert candidate("a b c d e f", 1) == ["b", "c", "d", "f"], "2nd edge test error: " + str(candidate("a b c d e f", 1))

candidate = select_words
check(candidate)


Prompt:
単語が与えられる。あなたの仕事は、単語の右側から2つの子音（大文字と
    小文字を区別）の間に立っている最も近い母音を見つけることである。

    最初と最後の母音はカウントされない。上記の条件を満たす母音が見つから
    なかった場合は、空の文字列を返せ。

    指定された文字列は英字のみを含むとみなしてよい。

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

def get_closest_vowel(word):
    if len(word) < 3:
        return ""

    vowels = {"a", "e", "i", "o", "u", "A", "E", 'O', 'U', 'I'}
    for i in range(len(word)-2, 0, -1):
        if word[i] in vowels:
            if (word[i+1] not in vowels) and (word[i-1] not in vowels):
                return word[i]
    return ""

def check(candidate):

    # Check some simple cases
    assert candidate("yogurt") == "u"
    assert candidate("full") == "u"
    assert candidate("easy") == ""
    assert candidate("eAsy") == ""
    assert candidate("ali") == ""
    assert candidate("bad") == "a"
    assert candidate("most") == "o"
    assert candidate("ab") == ""
    assert candidate("ba") == ""
    assert candidate("quick") == ""
    assert candidate("anime") == "i"
    assert candidate("Asia") == ""
    assert candidate("Above") == "o"

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = get_closest_vowel
check(candidate)


Prompt:
2つの文字列からなるリストが与えられます。両方の文字列は開き括弧 '(' または
    閉じ括弧 ')' のみで構成されています。
    あなたの仕事は、2つの文字列を何らかの順序で結合して、「良い」文字列にすることが
    可能かどうかを確認することです。

    文字列Sが「良い」とは、文字列内のすべての括弧がバランスしている場合に限ります。
    例えば、文字列 '(())()' は良いですが、文字列 '())' は良くありません。
    良い文字列を作る方法がある場合は 'Yes' を返し、そうでない場合は 'No' を返してください。

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

def match_parens(lst):
    def check(s):
        val = 0
        for i in s:
            if i == '(':
                val = val + 1
            else:
                val = val - 1
            if val < 0:
                return False
        return True if val == 0 else False

    S1 = lst[0] + lst[1]
    S2 = lst[1] + lst[0]
    return 'Yes' if check(S1) or check(S2) else 'No'

def check(candidate):

    # Check some simple cases
    assert candidate(['()(', ')']) == 'Yes'
    assert candidate([')', ')']) == 'No'
    assert candidate(['(()(())', '())())']) == 'No'
    assert candidate([')())', '(()()(']) == 'Yes'
    assert candidate(['(())))', '(()())((']) == 'Yes'
    assert candidate(['()', '())']) == 'No'
    assert candidate(['(()(', '()))()']) == 'Yes'
    assert candidate(['((((', '((())']) == 'No'
    assert candidate([')(()', '(()(']) == 'No'
    assert candidate([')(', ')(']) == 'No'

    # Check some edge cases that are easy to work out by hand.
    assert candidate(['(', ')']) == 'Yes'
    assert candidate([')', '(']) == 'Yes'

candidate = match_parens
check(candidate)


Prompt:
整数の配列 arr と正の整数 k が与えられる。arr に含まれる大きい方から k 個の数を含む
    長さ 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 maximum(arr, k):
    if k == 0:
        return []
    arr.sort()
    ans = arr[-k:]
    return ans


Prompt:
整数の空でないリストが与えられた時、偶数の位置にある奇数の要素の合計を返す。
    例
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0

def solution(lst):
    return sum([x for idx, x in enumerate(lst) if idx%2==0 and x%2==1])

def check(candidate):

    # Check some simple cases
    assert candidate([5, 8, 7, 1])    == 12
    assert candidate([3, 3, 3, 3, 3]) == 9
    assert candidate([30, 13, 24, 321]) == 0
    assert candidate([5, 9]) == 5
    assert candidate([2, 4, 8]) == 0
    assert candidate([30, 13, 23, 32]) == 23
    assert candidate([3, 13, 2, 9]) == 3

    # Check some edge cases that are easy to work out by hand.

candidate = solution
check(candidate)


Prompt:
整数の空でない配列 arr と整数 k が与えられたとき、
    arr の最初の k 個の要素から高々 2 桁までの要素の和を返す。

    例:

        入力: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        出力: 24 # 21 + 3 の話

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

def add_elements(arr, k):
    return sum(elem for elem in arr[:k] if len(str(elem)) <= 2)

def check(candidate):

    # Check some simple cases
    assert candidate([1,-2,-3,41,57,76,87,88,99], 3) == -4
    assert candidate([111,121,3,4000,5,6], 2) == 0
    assert candidate([11,21,3,90,5,6,7,8,9], 4) == 125
    assert candidate([111,21,3,4000,5,6,7,8,9], 4) == 24, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1], 1) == 1, "This prints if this assert fails 2 (also good for debugging!)"

candidate = add_elements
check(candidate)


Prompt:
正の整数nが与えられたとき、コラッツ数列の奇数を持つソートされたリストを返す。
    コラッツ予想とは数学の予想で、次のように定義される数列に関するものである：
    任意の正の整数nから始め、各項は前の項から次のように求められる。
    前の項が偶数なら、次の項は前の項の2分の1である。前の項が奇数の場合、次の項は前の項の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):
    if n%2==0:
        odd_collatz = []
    else:
        odd_collatz = [n]
    while n > 1:
        if n % 2 == 0:
            n = n/2
        else:
            n = n*3 + 1

        if n%2 == 1:
            odd_collatz.append(int(n))

    return sorted(odd_collatz)

def check(candidate):

    # Check some simple cases
    assert candidate(14) == [1, 5, 7, 11, 13, 17]
    assert candidate(5) == [1, 5]
    assert candidate(12) == [1, 3, 5], "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1) == [1], "This prints if this assert fails 2 (also good for debugging!)"

candidate = get_odd_collatz
check(candidate)


Prompt:
与えられた日付文字列を検証し、その日付が有効であれば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 valid_date(date):
    try:
        date = date.strip()
        month, day, year = date.split('-')
        month, day, year = int(month), int(day), int(year)
        if month < 1 or month > 12:
            return False
        if month in [1,3,5,7,8,10,12] and day < 1 or day > 31:
            return False
        if month in [4,6,9,11] and day < 1 or day > 30:
            return False
        if month == 2 and day < 1 or day > 29:
            return False
    except:
        return False

    return True

def check(candidate):

    # Check some simple cases
    assert candidate('03-11-2000') == True

    assert candidate('15-01-2012') == False

    assert candidate('04-0-2040') == False

    assert candidate('06-04-2020') == True

    assert candidate('01-01-2007') == True

    assert candidate('03-32-2011') == False

    assert candidate('') == False

    assert candidate('04-31-3000') == False

    assert candidate('06-06-2005') == True

    assert candidate('21-31-2000') == False

    assert candidate('04-12-2003') == True

    assert candidate('04122003') == False

    assert candidate('20030412') == False

    assert candidate('2003-04') == False

    assert candidate('2003-04-12') == False

    assert candidate('04-2003') == False

candidate = valid_date
check(candidate)


Prompt:
単語の文字列が与えられた場合、空白で分割された単語のリストを返す。
    テキスト中に空白が存在しない場合は、カンマ ',' で分割する必要がある。カンマが存在しない場合は、
    アルファベットの奇数順の小文字の数を返す必要がある。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):
    if " " in txt:
        return txt.split()
    elif "," in txt:
        return txt.replace(',',' ').split()
    else:
        return len([i for i in txt if i.islower() and ord(i)%2 == 0])

def check(candidate):

    assert candidate("Hello world!") == ["Hello","world!"]
    assert candidate("Hello,world!") == ["Hello","world!"]
    assert candidate("Hello world,!") == ["Hello","world,!"]
    assert candidate("Hello,Hello,world !") == ["Hello,Hello,world","!"]
    assert candidate("abcdef") == 3
    assert candidate("aaabb") == 2
    assert candidate("aaaBb") == 1
    assert candidate("") == 0

candidate = split_words
check(candidate)


Prompt:
数字のリストが与えられたとき、昇順に整列されているかどうかを返す。
    リストに同じ数の重複が1つ以上ある場合は、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):
    count_digit = dict([(i, 0) for i in lst])
    for i in lst:
        count_digit[i]+=1
    if any(count_digit[i] > 2 for i in lst):
        return False
    if all(lst[i-1] <= lst[i] for i in range(1, len(lst))):
        return True
    else:
        return False

def check(candidate):

    # Check some simple cases
    assert candidate([5]) == True
    assert candidate([1, 2, 3, 4, 5]) == True
    assert candidate([1, 3, 2, 4, 5]) == False
    assert candidate([1, 2, 3, 4, 5, 6]) == True
    assert candidate([1, 2, 3, 4, 5, 6, 7]) == True
    assert candidate([1, 3, 2, 4, 5, 6, 7]) == False, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([]) == True, "This prints if this assert fails 2 (good for debugging!)"
    assert candidate([1]) == True, "This prints if this assert fails 3 (good for debugging!)"
    assert candidate([3, 2, 1]) == False, "This prints if this assert fails 4 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1, 2, 2, 2, 3, 4]) == False, "This prints if this assert fails 5 (good for debugging!)"
    assert candidate([1, 2, 3, 3, 3, 4]) == False, "This prints if this assert fails 6 (good for debugging!)"
    assert candidate([1, 2, 2, 3, 3, 4]) == True, "This prints if this assert fails 7 (good for debugging!)"
    assert candidate([1, 2, 3, 4]) == True, "This prints if this assert fails 8 (good for debugging!)"

candidate = is_sorted
check(candidate)


Prompt:
2つの区間が与えられます。
    それぞれの区間は整数のペアで示されます。例えば、区間 = (start, end ) = (1, 2) です。
    与えられた区間は閉区間であり、start と end の両端が含まれます。
    各区間について、start は end 以下であると仮定します。

    あなたの仕事は、これら2つの区間の交差部分の長さが素数であるかどうかを判断することです。

    例えば、区間  (1, 3)  と  (2, 4)  の交差部分は  (2, 3)  で、その長さは1ですが、これは素数ではありません。

    交差部分の長さが素数であれば "YES" を返し、そうでなければ "NO" を返してください。
    もし2つの区間が交差しない場合も "NO" を返してください。

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

def intersection(interval1, interval2):
    def is_prime(num):
        if num == 1 or num == 0:
            return False
        if num == 2:
            return True
        for i in range(2, num):
            if num%i == 0:
                return False
        return True

    l = max(interval1[0], interval2[0])
    r = min(interval1[1], interval2[1])
    length = r - l
    if length > 0 and is_prime(length):
        return "YES"
    return "NO"

def check(candidate):

    # Check some simple cases
    assert candidate((1, 2), (2, 3)) == "NO"
    assert candidate((-1, 1), (0, 4)) == "NO"
    assert candidate((-3, -1), (-5, 5)) == "YES"
    assert candidate((-2, 2), (-4, 0)) == "YES"

    # Check some edge cases that are easy to work out by hand.
    assert candidate((-11, 2), (-1, -1)) == "NO"
    assert candidate((1, 2), (3, 5)) == "NO"
    assert candidate((1, 2), (1, 2)) == "NO"
    assert candidate((-2, -2), (-3, -2)) == "NO"

candidate = intersection
check(candidate)


Prompt:
整数の配列 arr が与えられます。この配列に含まれる各数値の絶対値の合計と、
    各数値の符号（プラスは1、マイナスは-1、ゼロは0）の積を掛け合わせた値を
    返してください。
    注意：配列`arr`が空の場合は`None`を返してください。

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

def prod_signs(arr):
    if not arr: return None
    prod = 0 if 0 in arr else (-1) ** len(list(filter(lambda x: x < 0, arr)))
    return prod * sum([abs(i) for i in arr])

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1, 2, 2, -4]) == -9
    assert candidate([0, 1]) == 0
    assert candidate([1, 1, 1, 2, 3, -1, 1]) == -10
    assert candidate([]) == None
    assert candidate([2, 4,1, 2, -1, -1, 9]) == 20
    assert candidate([-1, 1, -1, 1]) == 4
    assert candidate([-1, 1, 1, 1]) == -4
    assert candidate([-1, 1, 1, 0]) == 0

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

candidate = prod_signs
check(candidate)


Prompt:
N行とN列 (N >= 2)) のグリッドと正の整数kが与えられた場合、各セルには値が含まれている。
   範囲[1, N * N]（両端を含む）のすべての整数は、グリッドのセルに一度だけ表れる。

    このグリッド内で長さkの最短の経路を見つける必要がある。任意のセルからスタートでき、
    各ステップで隣接するセルに移動できる。言い換えれば、現在のセルと辺を共有するセルに
    移動できる。長さkの経路とは、正確にk個のセル（必ずしも異なるとは限らない）を訪れる
    ことを意味する。ただし、グリッドから出ることはない。

    長さkの2つの経路AとBがある場合、AとBが通るセルの値を順番にリスト化したものを
    それぞれlst_A、lst_Bと呼ぶ。lst_Aがlst_Bより辞書順で小さい場合、経路Aは経路Bよりも
    小さいとする。つまり、整数インデックスi（ 1 <= i <= k ) が存在して、lst_A[i] < lst_B[i] となり、
    任意の j（ 1 <= j < i ）に対して lst_A[j] = lst_B[j] が成立する。

    答えは一意であることが保証されている。
    最短の経路が通るセルの値の順番に並べたリストを返すようにせよ。

    例：

        入力：grid =[ [1,2,3], [4,5,6], [7,8,9]]. k = 3
        出力：[1, 2, 1]

        入力：grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        出力：[1]

def minPath(grid, k):
    n = len(grid)
    val = n * n + 1
    for i in range(n):
        for j in range(n):
            if grid[i][j] == 1:
                temp = []
                if i != 0:
                    temp.append(grid[i - 1][j])

                if j != 0:
                    temp.append(grid[i][j - 1])

                if i != n - 1:
                    temp.append(grid[i + 1][j])

                if j != n - 1:
                    temp.append(grid[i][j + 1])

                val = min(temp)

    ans = []
    for i in range(k):
        if i % 2 == 0:
            ans.append(1)
        else:
            ans.append(val)
    return ans


Prompt:
フィボナッチ数列は、ここ数世紀の間に数学者によって深く研究され、誰もが知っている。
    しかし、人々が知らないのはトリボナッチ数列である。
    トリボナッチ数列は再帰によって定義される:
    tri(1) = 3
    tri(n) = 1 + n / 2,    n が偶数の場合.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1),  n が奇数の場合d.
    例えば:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    あなたは非負の整数nが与えられるので、トリボナッチ数列の最初のn + 1個の数の
    リストを返さなければならない。
    例:
    tri(3) = [1, 3, 2, 8]

def tri(n):
    if n == 0:
        return [1]
    my_tri = [1, 3]
    for i in range(2, n + 1):
        if i % 2 == 0:
            my_tri.append(i / 2 + 1)
        else:
            my_tri.append(my_tri[i - 1] + my_tri[i - 2] + (i + 3) / 2)
    return my_tri


Prompt:
正の整数 n が与えられた時、奇数桁数の積を返す。
    全ての桁が偶数の場合は0を返す。
    例えば:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15

def digits(n):
    product = 1
    odd_count = 0
    for digit in str(n):
        int_digit = int(digit)
        if int_digit%2 == 1:
            product= product*int_digit
            odd_count+=1
    if odd_count ==0:
        return 0
    else:
        return product

def check(candidate):

    # Check some simple cases
    assert candidate(5) == 5
    assert candidate(54) == 5
    assert candidate(120) ==1
    assert candidate(5014) == 5
    assert candidate(98765) == 315
    assert candidate(5576543) == 2625

    # Check some edge cases that are easy to work out by hand.
    assert candidate(2468) == 0

candidate = digits
check(candidate)


Prompt:
この関数は、角括弧だけを含む文字列を入力として受け取ります。括弧が有効な順序で
    並んでいて、その中に少なくとも1つの括弧が入れ子になっている場合、関数はTrueを
    返すようにしてください。

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

def is_nested(string):
    opening_bracket_index = []
    closing_bracket_index = []
    for i in range(len(string)):
        if string[i] == '[':
            opening_bracket_index.append(i)
        else:
            closing_bracket_index.append(i)
    closing_bracket_index.reverse()
    cnt = 0
    i = 0
    l = len(closing_bracket_index)
    for idx in opening_bracket_index:
        if i < l and idx < closing_bracket_index[i]:
            cnt += 1
            i += 1
    return cnt >= 2

def check(candidate):

    # Check some simple cases
    assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate('[]]]]]]][[[[[]') == False
    assert candidate('[][]') == False
    assert candidate(('[]')) == False
    assert candidate('[[[[]]]]') == True
    assert candidate('[]]]]]]]]]]') == False
    assert candidate('[][][[]]') == True
    assert candidate('[[]') == False
    assert candidate('[]]') == False
    assert candidate('[[]][[') == True
    assert candidate('[[][]]') == True

    # Check some edge cases that are easy to work out by hand.
    assert candidate('') == False, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate('[[[[[[[[') == False
    assert candidate(']]]]]]]]') == False

candidate = is_nested
check(candidate)


Prompt:
数字のリストが与えられます。
    与えられたリスト内の各数値をまず切り上げ（天井関数を使って最も近い整数に丸める）、
    その後それぞれの数値を二乗した値の合計を返してください。
    例:
    lst = [1,2,3] のときの出力は 14
    lst = [1,4,9] のときの出力は 98
    lst = [1,3,5,7] のときの出力は 84
    lst = [1.4,4.2,0] のときの出力は 29
    lst = [-2.4,1,1] のときの出力は 6

def sum_squares(lst):
    import math
    squared = 0
    for i in lst:
        squared += math.ceil(i)**2
    return squared

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1.4,4.2,0])==29, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-2.4,1,1])==6, "This prints if this assert fails 1 (good for debugging!)"

    assert candidate([100,1,15,2])==10230, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([10000,10000])==200000000, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-1.4,4.6,6.3])==75, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-1.4,17.9,18.9,19.9])==1086, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([0])==0, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([-1])==1, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([-1,1,0])==2, "This prints if this assert fails 2 (also good for debugging!)"

candidate = sum_squares
check(candidate)


Prompt:
与えられた文字列の最後の文字がアルファベットであり、かつ単語の一部でなければTrueを、
    そうでなければFalseを返す関数を作成せよ。
    注意：単語とはスペースで区切られた文字の並びである。
    例:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False

def check_if_last_char_is_a_letter(txt):

    check = txt.split(' ')[-1]
    return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False

def check(candidate):

    # Check some simple cases
    assert candidate("apple") == False
    assert candidate("apple pi e") == True
    assert candidate("eeeee") == False
    assert candidate("A") == True
    assert candidate("Pumpkin pie ") == False
    assert candidate("Pumpkin pie 1") == False
    assert candidate("") == False
    assert candidate("eeeee e ") == False
    assert candidate("apple pie") == False
    assert candidate("apple pi e ") == False

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = check_if_last_char_is_a_letter
check(candidate)


Prompt:
直前の要素よりも大きくない要素の中で、最も大きなインデックスを持つ要素を探して
    そのインデックスを返す関数を作成してください。そのような要素が存在しない場合は、
    -1を返してください。与えられる配列には重複する値は含まれません。
    例:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1

def can_arrange(arr):
    ind=-1
    i=1
    while i<len(arr):
      if arr[i]<arr[i-1]:
        ind=i
      i+=1
    return ind

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,4,3,5])==3
    assert candidate([1,2,4,5])==-1
    assert candidate([1,4,2,5,6,7,8,9,10])==2
    assert candidate([4,8,5,7,3])==4

    # Check some edge cases that are easy to work out by hand.
    assert candidate([])==-1

candidate = can_arrange
check(candidate)


Prompt:
リストから最も大きな負の整数と最も小さな正の整数を見つけ、それらをタプル（a, b）
    として返す関数を作成してください。リストに負の整数もしくは正の整数がない場合は、
    代わりにNoneを返します。

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

def largest_smallest_integers(lst):
    smallest = list(filter(lambda x: x < 0, lst))
    largest = list(filter(lambda x: x > 0, lst))
    return (max(smallest) if smallest else None, min(largest) if largest else None)

def check(candidate):

    # Check some simple cases
    assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
    assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
    assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
    assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
    assert candidate([7, 3, 8, 4, 9, 2, 5, -9]) == (-9, 2)
    assert candidate([]) == (None, None)
    assert candidate([0]) == (None, None)
    assert candidate([-1, -3, -5, -6]) == (-1, None)
    assert candidate([-1, -3, -5, -6, 0]) == (-1, None)
    assert candidate([-6, -4, -4, -3, 1]) == (-3, 1)
    assert candidate([-6, -4, -4, -3, -100, 1]) == (-3, 1)

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = largest_smallest_integers
check(candidate)


Prompt:
整数、浮動小数点数、または実数を表す文字列を引数として受け取り、その中で最も大きい値を
    その元の型で返す関数を作成してください。もし値が同じであれば、Noneを返してください。
    注意：実数が文字列として表されている場合、小数点はピリオド（.）またはカンマ（,）の可能性があります。

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

def compare_one(a, b):
    temp_a, temp_b = a, b
    if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
    if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
    if float(temp_a) == float(temp_b): return None
    return a if float(temp_a) > float(temp_b) else b

def check(candidate):

    # Check some simple cases
    assert candidate(1, 2) == 2
    assert candidate(1, 2.5) == 2.5
    assert candidate(2, 3) == 3
    assert candidate(5, 6) == 6
    assert candidate(1, "2,3") == "2,3"
    assert candidate("5,1", "6") == "6"
    assert candidate("1", "2") == "2"
    assert candidate("1", 1) == None

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = compare_one
check(candidate)


Prompt:
与えられた数値nが、ちょうど4つの正の偶数の合計として表現できるかどうかを評価してください。
    例
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True

def is_equal_to_sum_even(n):
    return n%2 == 0 and n >= 8

def check(candidate):
    assert candidate(4) == False
    assert candidate(6) == False
    assert candidate(8) == True
    assert candidate(10) == True
    assert candidate(11) == False
    assert candidate(12) == True
    assert candidate(13) == False
    assert candidate(16) == True

candidate = is_equal_to_sum_even
check(candidate)


Prompt:
ブラジリアン階乗は次のように定義される：
    brazilian_factorial(n) = n！* (n-1)! * (n-2)! * ... * 1!
    ただし n > 0

    例えば:
    >>> special_factorial(4)
    288

    この関数は入力として整数を受け取り、整数の特殊な階乗を返す。

def special_factorial(n):
    fact_i = 1
    special_fact = 1
    for i in range(1, n+1):
        fact_i *= i
        special_fact *= fact_i
    return special_fact

def check(candidate):

    # Check some simple cases
    assert candidate(4) == 288, "Test 4"
    assert candidate(5) == 34560, "Test 5"
    assert candidate(7) == 125411328000, "Test 7"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1) == 1, "Test 1"

candidate = special_factorial
check(candidate)


Prompt:
文字列テキストが与えられた場合、その中のすべての空白をアンダースコアに置換し、
    文字列が2つ以上の連続した空白を持つ場合、すべての連続した空白を - に置換する

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

def fix_spaces(text):
    new_text = ""
    i = 0
    start, end = 0, 0
    while i < len(text):
        if text[i] == " ":
            end += 1
        else:
            if end - start > 2:
                new_text += "-"+text[i]
            elif end - start > 0:
                new_text += "_"*(end - start)+text[i]
            else:
                new_text += text[i]
            start, end = i+1, i+1
        i+=1
    if end - start > 2:
        new_text += "-"
    elif end - start > 0:
        new_text += "_"
    return new_text

def check(candidate):

    # Check some simple cases
    assert candidate("Example") == "Example", "This prints if this assert fails 1 (good for debugging!)"
    assert candidate("Mudasir Hanif ") == "Mudasir_Hanif_", "This prints if this assert fails 2 (good for debugging!)"
    assert candidate("Yellow Yellow  Dirty  Fellow") == "Yellow_Yellow__Dirty__Fellow", "This prints if this assert fails 3 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("Exa   mple") == "Exa-mple", "This prints if this assert fails 4 (good for debugging!)"
    assert candidate("   Exa 1 2 2 mple") == "-Exa_1_2_2_mple", "This prints if this assert fails 4 (good for debugging!)"

candidate = fix_spaces
check(candidate)


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

def file_name_check(file_name):
    suf = ['txt', 'exe', 'dll']
    lst = file_name.split(sep='.')
    if len(lst) != 2:
        return 'No'
    if not lst[1] in suf:
        return 'No'
    if len(lst[0]) == 0:
        return 'No'
    if not lst[0][0].isalpha():
        return 'No'
    t = len([x for x in lst[0] if x.isdigit()])
    if t > 3:
        return 'No'
    return 'Yes'

def check(candidate):

    # Check some simple cases
    assert candidate("example.txt") == 'Yes'
    assert candidate("1example.dll") == 'No'
    assert candidate('s1sdf3.asd') == 'No'
    assert candidate('K.dll') == 'Yes'
    assert candidate('MY16FILE3.exe') == 'Yes'
    assert candidate('His12FILE94.exe') == 'No'
    assert candidate('_Y.txt') == 'No'
    assert candidate('?aREYA.exe') == 'No'
    assert candidate('/this_is_valid.dll') == 'No'
    assert candidate('this_is_valid.wow') == 'No'
    assert candidate('this_is_valid.txt') == 'Yes'
    assert candidate('this_is_valid.txtexe') == 'No'
    assert candidate('#this2_i4s_5valid.ten') == 'No'
    assert candidate('@this1_is6_valid.exe') == 'No'
    assert candidate('this_is_12valid.6exe4.txt') == 'No'
    assert candidate('all.exe.txt') == 'No'
    assert candidate('I563_No.exe') == 'Yes'
    assert candidate('Is3youfault.txt') == 'Yes'
    assert candidate('no_one#knows.dll') == 'Yes'
    assert candidate('1I563_Yes3.exe') == 'No'
    assert candidate('I563_Yes3.txtt') == 'No'
    assert candidate('final..txt') == 'No'
    assert candidate('final132') == 'No'
    assert candidate('_f4indsartal132.') == 'No'

    # Check some edge cases that are easy to work out by hand.
    assert candidate('.txt') == 'No'
    assert candidate('s.') == 'No'

candidate = file_name_check
check(candidate)


Prompt:
"
    この関数は整数のリストを受け取ります。リスト内の各要素に対して、そのインデックスが3の倍数で
    あればその整数を二乗し、インデックスが4の倍数でかつ3の倍数でない場合はその整数を三乗します。
    インデックスが3または4の倍数でない要素については、何も変更しません。最後に、すべての要素の
    合計値を返します。

    例:
    lst = [1,2,3] の時、返り値は 6
    lst = []  の時、返り値は 0
    lst = [-1,-5,2,-1,-5]  の時、返り値は -126

def sum_squares(lst):
    result =[]
    for i in range(len(lst)):
        if i %3 == 0:
            result.append(lst[i]**2)
        elif i % 4 == 0 and i%3 != 0:
            result.append(lst[i]**3)
        else:
            result.append(lst[i])
    return sum(result)


Prompt:
文を表す文字列が与えられ、その文には空白で区切られたいくつかの単語が含まれている。
    元の文の単語を含みその長さが素数である文字列を返す必要がある。
    新しい文字列の単語の順序は元の文字列と同じでなければならない。

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

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

    制約:
        * 1 <= len(sentence) <= 100
        * sentence contains only letters

def words_in_sentence(sentence):
    new_lst = []
    for word in sentence.split():
        flg = 0
        if len(word) == 1:
            flg = 1
        for i in range(2, len(word)):
            if len(word)%i == 0:
                flg = 1
        if flg == 0 or len(word) == 2:
            new_lst.append(word)
    return " ".join(new_lst)

def check(candidate):

    # Check some simple cases
    assert candidate("This is a test") == "is"
    assert candidate("lets go for swimming") == "go for"
    assert candidate("there is no place available here") == "there is no place"
    assert candidate("Hi I am Hussein") == "Hi am Hussein"
    assert candidate("go for it") == "go for it"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("here") == ""
    assert candidate("here is") == "is"

candidate = words_in_sentence
check(candidate)


Prompt:
あなたの仕事は、式 x * n を簡単にする関数を実装することです。
    この関数は、x * n が整数になる場合はTrueを、そうでない場合はFalseを
    返します。xとnはともに分数の文字列表現であり、<分子>/<分母>という形式で、
    分子と分母はともに正の整数です。

    xとnが有効な分数であり、分母がゼロでないことは仮定してかまいません。

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

def simplify(x, n):
    a, b = x.split("/")
    c, d = n.split("/")
    numerator = int(a) * int(c)
    denom = int(b) * int(d)
    if (numerator/denom == int(numerator/denom)):
        return True
    return False

def check(candidate):

    # Check some simple cases
    assert candidate("1/5", "5/1") == True, 'test1'
    assert candidate("1/6", "2/1") == False, 'test2'
    assert candidate("5/1", "3/1") == True, 'test3'
    assert candidate("7/10", "10/2") == False, 'test4'
    assert candidate("2/10", "50/10") == True, 'test5'
    assert candidate("7/2", "4/2") == True, 'test6'
    assert candidate("11/6", "6/1") == True, 'test7'
    assert candidate("2/3", "5/2") == False, 'test8'
    assert candidate("5/2", "3/5") == False, 'test9'
    assert candidate("2/4", "8/4") == True, 'test10'

    # Check some edge cases that are easy to work out by hand.
    assert candidate("2/4", "4/2") == True, 'test11'
    assert candidate("1/5", "5/1") == True, 'test12'
    assert candidate("1/5", "1/5") == False, 'test13'

candidate = simplify
check(candidate)


Prompt:
各数字の桁の合計に基づいて、与えられた整数のリストを昇順に並べる
    関数を作成してください。
    注意：もし桁の合計が同じである複数の項目がある場合は、
    元のリストでの位置に基づいて並べてください。
    例えば
    >> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11].
    >> order_by_points([]) == [].

def order_by_points(nums):
    def digits_sum(n):
        neg = 1
        if n < 0: n, neg = -1 * n, -1
        n = [int(i) for i in str(n)]
        n[0] = n[0] * neg
        return sum(n)
    return sorted(nums, key=digits_sum)


Prompt:
数値の配列を入力とし、配列中の要素のうち、10より大きく、
    かつ数値の最初と最後の桁の両方が奇数（1, 3, 5, 7, 9）である要素の数を返す関数を書く。
    例えば
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2

def specialFilter(nums):

    count = 0
    for num in nums:
        if num > 10:
            odd_digits = (1, 3, 5, 7, 9)
            number_as_string = str(num)
            if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
                count += 1

    return count

def check(candidate):

    # Check some simple cases
    assert candidate([5, -2, 1, -5]) == 0
    assert candidate([15, -73, 14, -15]) == 1
    assert candidate([33, -2, -3, 45, 21, 109]) == 2
    assert candidate([43, -12, 93, 125, 121, 109]) == 4
    assert candidate([71, -2, -33, 75, 21, 19]) == 3

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1]) == 0
    assert candidate([]) == 0

candidate = specialFilter
check(candidate)


Prompt:
正の整数 n が与えられるので、長さ n の整数配列 a を作成せよ。
       各 i (1 ≤ i ≤ n) に対して、 a[i] = i * i - i + 1 とする。
        i < j < k において、a[i] + a[j] + a[k] が3の倍数となるような三つ組 (a[i], a[j], a[k]) を返す。

    例 :
        入力: n = 5
        出力t: 1
        解説:
        a = [1, 3, 7, 13, 21]
        唯一の妥当な三つ組は (1, 7, 13)である。

def get_max_triples(n):
    A = [i*i - i + 1 for i in range(1,n+1)]
    ans = []
    for i in range(n):
        for j in range(i+1,n):
            for k in range(j+1,n):
                if (A[i]+A[j]+A[k])%3 == 0:
                    ans += [(A[i],A[j],A[k])]
    return len(ans)

def check(candidate):

    assert candidate(5) == 1
    assert candidate(6) == 4
    assert candidate(10) == 36
    assert candidate(100) == 53361

candidate = get_max_triples
check(candidate)


Prompt:
私たちの太陽系には8つの惑星があります：太陽に最も近いのはVenus, Earth, Mars, Jupiter, Saturn,
    Uranus, Neptuneです。
    planet1とplanet2という2つの惑星名を文字列として受け取る関数を作成してください。
    この関数は、planet1の軌道とplanet2の軌道の間に位置するすべての惑星を太陽に近い順に並べたタプルを返すべきです。
    planet1またはplanet2が正確な惑星名でない場合、関数は空のタプルを返すべきです。
    例
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")

def bf(planet1, planet2):
    planet_names = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
    if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
        return ()
    planet1_index = planet_names.index(planet1)
    planet2_index = planet_names.index(planet2)
    if planet1_index < planet2_index:
        return (planet_names[planet1_index + 1: planet2_index])
    else:
        return (planet_names[planet2_index + 1 : planet1_index])

def check(candidate):

    # Check some simple cases
    assert candidate("Jupiter", "Neptune") == ("Saturn", "Uranus"), "First test error: " + str(len(candidate("Jupiter", "Neptune")))
    assert candidate("Earth", "Mercury") == ("Venus",), "Second test error: " + str(candidate("Earth", "Mercury"))
    assert candidate("Mercury", "Uranus") == ("Venus", "Earth", "Mars", "Jupiter", "Saturn"), "Third test error: " + str(candidate("Mercury", "Uranus"))
    assert candidate("Neptune", "Venus") == ("Earth", "Mars", "Jupiter", "Saturn", "Uranus"), "Fourth test error: " + str(candidate("Neptune", "Venus"))

    # Check some edge cases that are easy to work out by hand.
    assert candidate("Earth", "Earth") == ()
    assert candidate("Mars", "Earth") == ()
    assert candidate("Jupiter", "Makemake") == ()

candidate = bf
check(candidate)


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

def sorted_list_sum(lst):
    lst.sort()
    new_lst = []
    for i in lst:
        if len(i)%2 == 0:
            new_lst.append(i)
    return sorted(new_lst, key=len)

def check(candidate):

    # Check some simple cases
    assert candidate(["aa", "a", "aaa"]) == ["aa"]
    assert candidate(["school", "AI", "asdf", "b"]) == ["AI", "asdf", "school"]
    assert candidate(["d", "b", "c", "a"]) == []
    assert candidate(["d", "dcba", "abcd", "a"]) == ["abcd", "dcba"]

    # Check some edge cases that are easy to work out by hand.
    assert candidate(["AI", "ai", "au"]) == ["AI", "ai", "au"]
    assert candidate(["a", "b", "b", "c", "c", "a"]) == []
    assert candidate(['aaaa', 'bbbb', 'dd', 'cc']) == ["cc", "dd", "aaaa", "bbbb"]

candidate = sorted_list_sum
check(candidate)


Prompt:
素数である場合はxの値を返し、それ以外の場合はyの値を返す簡単なプログラム。

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

def x_or_y(n, x, y):
    if n == 1:
        return y
    for i in range(2, n):
        if n % i == 0:
            return y
            break
    else:
        return x

def check(candidate):

    # Check some simple cases
    assert candidate(7, 34, 12) == 34
    assert candidate(15, 8, 5) == 5
    assert candidate(3, 33, 5212) == 33
    assert candidate(1259, 3, 52) == 3
    assert candidate(7919, -1, 12) == -1
    assert candidate(3609, 1245, 583) == 583
    assert candidate(91, 56, 129) == 129
    assert candidate(6, 34, 1234) == 1234

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1, 2, 0) == 0
    assert candidate(2, 2, 0) == 2

candidate = x_or_y
check(candidate)


Prompt:
数字のリストが与えられた場合、そのリスト内の奇数の数値の二乗の合計を返してください。
    負の数や整数でない数は無視してください。

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

    入力リストが空の場合は0を返すようにしてください。

def double_the_difference(lst):
    return sum([i**2 for i in lst if i > 0 and i%2!=0 and "." not in str(i)])

def check(candidate):

    # Check some simple cases
    assert candidate([]) == 0 , "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([5, 4]) == 25 , "This prints if this assert fails 2 (good for debugging!)"
    assert candidate([0.1, 0.2, 0.3]) == 0 , "This prints if this assert fails 3 (good for debugging!)"
    assert candidate([-10, -20, -30]) == 0 , "This prints if this assert fails 4 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([-1, -2, 8]) == 0, "This prints if this assert fails 5 (also good for debugging!)"
    assert candidate([0.2, 3, 5]) == 34, "This prints if this assert fails 6 (also good for debugging!)"
    lst = list(range(-99, 100, 2))
    odd_sum = sum([i**2 for i in lst if i%2!=0 and i > 0])
    assert candidate(lst) == odd_sum , "This prints if this assert fails 7 (good for debugging!)"

candidate = double_the_difference
check(candidate)


Prompt:
待ち望んでいた出来事の結果がようやく判明したときの感覚は、誰もが覚えていると思う。
    その瞬間に抱いた感情や思考は、間違いなくメモして比較する価値がある。
    あなたの仕事は、人がいくつかの試合の結果を正確に予想したかどうかを判断することです。
    スコアと予想の2つの配列が等しい長さで与えられます。各インデックスは1つの試合を示しています。
    各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。予想が正確であれば、
    その値は0です。そうでなければ、その値は予想とスコアの絶対的な差です。

    例:

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

def compare(game,guess):
    return [abs(x-y) for x,y in zip(game,guess)]

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,3,4,5,1],[1,2,3,4,2,-2])==[0,0,0,0,3,3], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([0,0,0,0,0,0],[0,0,0,0,0,0])==[0,0,0,0,0,0], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,2,3],[-1,-2,-3])==[2,4,6], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,2,3,5],[-1,2,3,4])==[2,0,0,1], "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

candidate = compare
check(candidate)


Prompt:
クラスの名前（文字列）と拡張子のリストが与えられます。
    この拡張子は、指定されたクラスに追加のクラスをロードするために使用されます。
    拡張子の強度は次のように計算されます：CAPは拡張子の名前に含まれる
    大文字の数、SMは小文字の数です。強度は、CAP - SM で与えられます。
    最も強い拡張子を見つけて、この形式の文字列を返してください：ClassName.StrongestExtensionName。
    同じ強度を持つ2つ以上の拡張子がある場合は、リストで最初に来るものを選びます。
    例えば、"Slices"というクラスと、拡張子のリスト['SErviNGSliCes', 'Cheese', 'StuFfed'] が与えられた場合、'
    SErviNGSliCes'が最も強い拡張子（強度は-1）となるため、'Slices.SErviNGSliCes'を返すべきです。
    例：
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'

def Strongest_Extension(class_name, extensions):
    strong = extensions[0]
    my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
    for s in extensions:
        val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
        if val > my_val:
            strong = s
            my_val = val

    ans = class_name + "." + strong
    return ans

def check(candidate):

    # Check some simple cases
    assert candidate('Watashi', ['tEN', 'niNE', 'eIGHt8OKe']) == 'Watashi.eIGHt8OKe'
    assert candidate('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']) == 'Boku123.YEs.WeCaNe'
    assert candidate('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']) == '__YESIMHERE.NuLl__'
    assert candidate('K', ['Ta', 'TAR', 't234An', 'cosSo']) == 'K.TAR'
    assert candidate('__HAHA', ['Tab', '123', '781345', '-_-']) == '__HAHA.123'
    assert candidate('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-']) == 'YameRore.okIWILL123'
    assert candidate('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW']) == 'finNNalLLly.WoW'

    # Check some edge cases that are easy to work out by hand.
    assert candidate('_', ['Bb', '91245']) == '_.Bb'
    assert candidate('Sp', ['671235', 'Bb']) == 'Sp.671235'

candidate = Strongest_Extension
check(candidate)


Prompt:
2つの単語が与えられる。2番目の単語またはその回転させた文字列が最初の単語の部分文字列である場合、Trueを返す必要がある。
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

def cycpattern_check(a , b):
    l = len(b)
    pat = b + b
    for i in range(len(a) - l + 1):
        for j in range(l + 1):
            if a[i:i+l] == pat[j:j+l]:
                return True
    return False

def check(candidate):

    # Check some simple cases
    #assert True, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    #assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert  candidate("xyzw","xyw") == False , "test #0"
    assert  candidate("yello","ell") == True , "test #1"
    assert  candidate("whattup","ptut") == False , "test #2"
    assert  candidate("efef","fee") == True , "test #3"
    assert  candidate("abab","aabb") == False , "test #4"
    assert  candidate("winemtt","tinem") == True , "test #5"

candidate = cycpattern_check
check(candidate)


Prompt:
整数が与えられた場合、偶数桁数と奇数桁数をそれぞれ持つタプルを返す。
     例:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)

def even_odd_count(num):
    even_count = 0
    odd_count = 0
    for i in str(abs(num)):
        if int(i)%2==0:
            even_count +=1
        else:
            odd_count +=1
    return (even_count, odd_count)

def check(candidate):

    # Check some simple cases
    assert candidate(7) == (0, 1)
    assert candidate(-78) == (1, 1)
    assert candidate(3452) == (2, 2)
    assert candidate(346211) == (3, 3)
    assert candidate(-345821) == (3, 3)
    assert candidate(-2) == (1, 0)
    assert candidate(-45347) == (2, 3)
    assert candidate(0) == (1, 0)

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = even_odd_count
check(candidate)


Prompt:
正の整数が与えられたとき、ローマ数字に相当する文字列を小文字で返す。
    制限事項1 <= num <= 1000
    例:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'

def check(candidate):

    # Check some simple cases
    assert candidate(19) == 'xix'
    assert candidate(152) == 'clii'
    assert candidate(251) == 'ccli'
    assert candidate(426) == 'cdxxvi'
    assert candidate(500) == 'd'
    assert candidate(1) == 'i'
    assert candidate(4) == 'iv'
    assert candidate(43) == 'xliii'
    assert candidate(90) == 'xc'
    assert candidate(94) == 'xciv'
    assert candidate(532) == 'dxxxii'
    assert candidate(900) == 'cm'
    assert candidate(994) == 'cmxciv'
    assert candidate(1000) == 'm'

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = int_to_mini_roman
check(candidate)


Prompt:
三角形の3辺の長さを与える。三角形が直角三角形ならTrueを、そうでなければFalseを返す。
    直角三角形とは、1つの角が直角または90度である三角形のことである。
    例:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False

def right_angle_triangle(a, b, c):
    return a*a == b*b + c*c or b*b == a*a + c*c or c*c == a*a + b*b

def check(candidate):

    # Check some simple cases
    assert candidate(3, 4, 5) == True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate(1, 2, 3) == False
    assert candidate(10, 6, 8) == True
    assert candidate(2, 2, 2) == False
    assert candidate(7, 24, 25) == True
    assert candidate(10, 5, 7) == False
    assert candidate(5, 12, 13) == True
    assert candidate(15, 8, 17) == True
    assert candidate(48, 55, 73) == True

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1, 1, 1) == False, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate(2, 2, 10) == False

candidate = right_angle_triangle
check(candidate)


Prompt:
文字列のリストを受け取る関数を書きなさい。
    リストは異なる単語を含む。異なる固有の文字数が最も多い単語を返す。
    複数の文字列が同じ文字数を持つ場合は、辞書順で最初に来るものを返すことにする。

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

def find_max(words):
    return sorted(words, key = lambda x: (-len(set(x)), x))[0]

def check(candidate):

    # Check some simple cases
    assert (candidate(["name", "of", "string"]) == "string"), "t1"
    assert (candidate(["name", "enam", "game"]) == "enam"), 't2'
    assert (candidate(["aaaaaaa", "bb", "cc"]) == "aaaaaaa"), 't3'
    assert (candidate(["abc", "cba"]) == "abc"), 't4'
    assert (candidate(["play", "this", "game", "of","footbott"]) == "footbott"), 't5'
    assert (candidate(["we", "are", "gonna", "rock"]) == "gonna"), 't6'
    assert (candidate(["we", "are", "a", "mad", "nation"]) == "nation"), 't7'
    assert (candidate(["this", "is", "a", "prrk"]) == "this"), 't8'

    # Check some edge cases that are easy to work out by hand.
    assert (candidate(["b"]) == "b"), 't9'
    assert (candidate(["play", "play", "play"]) == "play"), 't10'

candidate = find_max
check(candidate)


Prompt:
あなたはお腹を空かせたウサギです。すでに一定数のニンジンを食べました。
    これからさらにニンジンを食べなければその日の食事は完了しません。
    あなたは [ 食事の後に食べたニンジンの総数, 食事の後に残ったニンジンの数 ] の配列を返してください。
    もし残りのニンジンが十分でなければ、あなたは残りのニンジンをすべて食べますが、まだお腹が空いています。

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

    変数:
    @number : 整数
        食べたニンジンの数。
    @need : 整数
        にんじんを何本食べるか。
    @remaining : 整数
        残りのニンジンの在庫数

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

    楽しんで :)

def eat(number, need, remaining):
    if(need <= remaining):
        return [ number + need , remaining-need ]
    else:
        return [ number + remaining , 0]

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate(5, 6, 10) == [11, 4], "Error"
    assert candidate(4, 8, 9) == [12, 1], "Error"
    assert candidate(1, 10, 10) == [11, 0], "Error"
    assert candidate(2, 11, 5) == [7, 0], "Error"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate(4, 5, 7) == [9, 2], "Error"
    assert candidate(4, 5, 1) == [5, 0], "Error"

candidate = eat
check(candidate)


Prompt:
演算子(operator)とオペランド(operand)の2つのリストが与えられる。ひとつ目のリストは
    基本的な算術演算を持ち、二つ目のリストは整数のリストである。与えられた2つのリストを
    使って算術式を構築し、その評価結果を返そう。

    基本的な算術演算:
    加算 ( + )
    減算 ( - )
    乗算 ( * )
    階除算 ( // )
    指数化 ( ** )

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

    注：演算子のリストの長さは、オペランドのリストの長さから1を引いた長さに等しい。
           オペランドは非負整数のリストである。
           operator は少なくとも1つの演算子を持ち、operand は少なくとも2つのオペランドを持つ。

def do_algebra(operator, operand):
    expression = str(operand[0])
    for oprt, oprn in zip(operator, operand[1:]):
        expression+= oprt + str(oprn)
    return eval(expression)

def check(candidate):

    # Check some simple cases
    assert candidate(['**', '*', '+'], [2, 3, 4, 5]) == 37
    assert candidate(['+', '*', '-'], [2, 3, 4, 5]) == 9
    assert candidate(['//', '*'], [7, 3, 4]) == 8, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

candidate = do_algebra
check(candidate)


Prompt:
文字列sが与えられます。
    もしs[i]がアルファベットなら、その文字の大文字と小文字を反転させる。そうでない場合は、そのままにしておく。
    もし文字列にアルファベットが一つも含まれていない場合は、文字列全体を逆順にする。
    関数は結果の文字列を返すようにします。
    例
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"

def solve(s):
    flg = 0
    idx = 0
    new_str = list(s)
    for i in s:
        if i.isalpha():
            new_str[idx] = i.swapcase()
            flg = 1
        idx += 1
    s = ""
    for i in new_str:
        s += i
    if flg == 0:
        return s[len(s)::-1]
    return s

def check(candidate):

    # Check some simple cases
    assert candidate("AsDf") == "aSdF"
    assert candidate("1234") == "4321"
    assert candidate("ab") == "AB"
    assert candidate("#a@C") == "#A@c"
    assert candidate("#AsdfW^45") == "#aSDFw^45"
    assert candidate("#6@2") == "2@6#"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("#$a^D") == "#$A^d"
    assert candidate("#ccc") == "#CCC"

    # Don't remove this line:

candidate = solve
check(candidate)


Prompt:
文字列 text が与えられたとき、その md5 ハッシュと等価な文字列を返す。
    text' が空文字列の場合は None を返す。

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

def string_to_md5(text):
    import hashlib
    return hashlib.md5(text.encode('ascii')).hexdigest() if text else None

def check(candidate):

    # Check some simple cases
    assert candidate('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    assert candidate('') == None
    assert candidate('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'
    assert candidate('password') == '5f4dcc3b5aa765d61d8327deb882cf99'

    # Check some edge cases that are easy to work out by hand.
    assert True

candidate = string_to_md5
check(candidate)


Prompt:
正の整数aとbが与えられたとき、aとbの間にある偶数の数字を昇順で返してください。

    例えば:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []

def generate_integers(a, b):
    lower = max(2, min(a, b))
    upper = min(8, max(a, b))

    return [i for i in range(lower, upper+1) if i % 2 == 0]

def check(candidate):

    # Check some simple cases
    assert candidate(2, 10) == [2, 4, 6, 8], "Test 1"
    assert candidate(10, 2) == [2, 4, 6, 8], "Test 2"
    assert candidate(132, 2) == [2, 4, 6, 8], "Test 3"
    assert candidate(17,89) == [], "Test 4"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

candidate = generate_integers
check(candidate)