Datasets:

myst72

/

sakuraeval-alpha0101

like 0

en/0

def calculate_tsubo(x: float, y: float) -> int: """ Calculates the size of the land with the specified length x meters and width y meters, and returns the number of tsubos. The land size is returned as an integer. 1 tsubo = 3.30579 square meters Args: x (float): Vertical length of land (meters) y (float): horizontal length of land (meters) Returns: int: Returns the land area in tsubo units. Example: >>> calculate_tsubo(10, 10) 30 >>> calculate_tsubo(5, 7) 10 """

area_square_meters = x * y tsubo = area_square_meters / 3.30579 return int(tsubo)

def check(candidate): assert candidate(10.0, 10.0) == 30 assert candidate(5.5, 7.2) == 11 assert candidate(0.3, 10.0) == 0 assert candidate(10.0, 0.3) == 0 assert candidate(0.0, 0.0) == 0 assert candidate(100.0, 100.0) == 3024 assert candidate(5.5, 5.5) == 9 assert candidate(3.14, 3.14) == 2

calculate_tsubo

en/1

def calculate_tax_included_price(amount: int) -> int: """ Calculate the tax-included amount by adding consumption tax to the total amount at the time of takeout. The consumption tax rate is calculated at 8%, rounded off, and returned as an integer. argument: amount (int): Total amount for takeout (excluding tax) Return value: int: Tax-included amount including consumption tax (rounded off) Usage example: >>> calculate_tax_included_price(1000) 1080 >>> calculate_tax_included_price(500) 540 >>> calculate_tax_included_price(1234) 1333 """

tax_rate = 0.08 tax_included_price = amount * (1 + tax_rate) return round(tax_included_price)

def check(candidate): assert candidate(1000) == 1080 assert candidate(500) == 540 assert candidate(1234) == 1333 assert candidate(0) == 0 assert candidate(1) == 1 assert candidate(2500) == 2700 assert candidate(999) == 1079

calculate_tax_included_price

en/2

def tatami_to_square_meters(n: int) -> float: """ Convert the number of tatami mats to square meters and calculate to two decimal places. Convert as 1 tatami = 1.62 square meters. argument: n (int): number of tatami mats Return value: float: square meter (2 decimal places) Usage example: >>> tatami_to_square_meters(1) 1.62 >>> tatami_to_square_meters(6) 9.72 >>> tatami_to_square_meters(10) 16.20 """

square_meters = n * 1.62 return round(square_meters, 2)

def check(candidate): assert candidate(1) == 1.62 assert candidate(2) == 3.24 assert candidate(3) == 4.86 assert candidate(6) == 9.72 assert candidate(6) == 9.72 assert candidate(9) == 14.58 assert candidate(10) == 16.20 assert candidate(15) == 24.30 assert candidate(20) == 32.40

tatami_to_square_meters

en/3

def tokyo_dome_units(n: int) -> float: """ Calculates how many Tokyo Dome areas are covered by the given area `n` and returns it in two decimal places. `n` is an integer value representing the area you want to calculate in square meters. The area equivalent to one Tokyo Dome is approximately 46,755 square meters. argument: n (int): Area to be calculated (square meters) Return value: float: How many Tokyo Domes the area is equivalent to (up to 2 decimal places) example: >>> tokyo_dome_units(100000) 2.14 >>> tokyo_dome_units(50000) 1.07 >>> tokyo_dome_units(46755) 1.00 """

# 東京ドームの床面積（平方メートル） tokyo_dome_area = 46755 # 東京ドーム何個分かを計算して、小数点以下2桁までの浮動小数点数で返す units = n / tokyo_dome_area return round(units, 2)

def check(candidate): assert candidate(100000) == 2.14 assert candidate(50000) == 1.07 assert candidate(46755) == 1.00 assert candidate(46755 * 2) == 2.00 assert candidate(46755 * 10) == 10.00 assert candidate(1000000) == 21.39 assert candidate(467550) == 10.00

tokyo_dome_units

en/4

def judge_janken(a: str, b: str) -> str: """ Determines the result of rock, paper, scissors and returns the winner as "A" or "B", and in case of a tie, returns "引き分け". It is based on the rule that "グー" beats "チョキ", "チョキ" beats "パー", and "パー" beats "グー". argument: a (str): Player A's hand ("グー", "チョキ", "パー") b (str): Player B's hand ("グー", "チョキ", "パー") Return value: str: Returns the winner as "A" or "B", or "引き分け" in case of a tie. Usage example: >>> judge_janken("グー", "チョキ") 'A' >>> judge_janken("パー", "チョキ") 'B' >>> judge_janken("グー", "グー") '引き分け' """

if a == b: return "引き分け" win_map = { ("グー", "チョキ"): "A", ("チョキ", "パー"): "A", ("パー", "グー"): "A", ("チョキ", "グー"): "B", ("パー", "チョキ"): "B", ("グー", "パー"): "B" } return win_map.get((a, b))

def check(candidate): assert candidate("グー", "チョキ") == "A" assert candidate("パー", "チョキ") == "B" assert candidate("チョキ", "グー") == "B" assert candidate("グー", "パー") == "B" assert candidate("チョキ", "パー") == "A" assert candidate("パー", "グー") == "A" assert candidate("グー", "グー") == "引き分け" assert candidate("チョキ", "チョキ") == "引き分け" assert candidate("パー", "パー") == "引き分け"

judge_janken

en/5

def count_pencils(n: int) -> str: """ When counting pencils in Japanese, ``hon'' is added after the number as a particle. This particle is read differently depending on the ones place of the number. If the ones place is "0, 1, 6, or 8", it is read as "ぽん", and if it is "3", it is read as "ぼん". Other numbers such as "2, 4, 5, 7, and 9" are read as "ほん". argument: n (int): Number of pencils (positive integer less than or equal to 999) Return value: str: How to read the particle ``hon'' ('ほん', 'ぽん', or 'ぼん') Usage example: >>> count_pencils(1) 'ぽん' >>> count_pencils(3) 'ぼん' >>> count_pencils(7) 'ほん' """

last_digit = n % 10 if last_digit in [2, 4, 5, 7, 9]: return "ほん" elif last_digit in [0, 1, 6, 8]: return "ぽん" elif last_digit == 3: return "ぼん"

def check(candidate): assert candidate(6) == "ぽん" assert candidate(8) == "ぽん" assert candidate(10) == "ぽん" assert candidate(21) == "ぽん" assert candidate(3) == "ぼん" assert candidate(13) == "ぼん" assert candidate(4) == "ほん" assert candidate(5) == "ほん" assert candidate(7) == "ほん" assert candidate(12) == "ほん" assert candidate(99) == "ほん"

count_pencils

en/6

def eto_from_year(year: int) -> str: """ Given a year in the Western calendar, find the zodiac sign for that year. The zodiac signs repeat in order: the zodiac (子, 丑, 寅, 卯, 辰, 巳, 午, 未, 申, 酉, 戌, 亥). >>> eto_from_year(2024) '辰' >>> eto_from_year(2023) '卯' >>> eto_from_year(2000) '辰' """

eto_cycle = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"] index = (year - 4) % 12 return eto_cycle[index]

def check(candidate): assert candidate(2020) == "子" assert candidate(2021) == "丑" assert candidate(2022) == "寅" assert candidate(2023) == "卯" assert candidate(2024) == "辰" assert candidate(2025) == "巳" assert candidate(2026) == "午" assert candidate(2027) == "未" assert candidate(2028) == "申" assert candidate(2029) == "酉" assert candidate(2030) == "戌" assert candidate(2031) == "亥" assert candidate(2008) == "子" assert candidate(1996) == "子" assert candidate(1984) == "子"

eto_from_year

en/7

def is_valid_postal_code(postal_code: str) -> bool: """ A function that determines whether a postal code is formatted correctly. The correct format for a postal code is 123-4567, which meets the following conditions: - It is a 7 digit number. - A hyphen ('-') is between the third and fourth digits. - There is a 3-digit number before the hyphen and a 4-digit number after it. argument: postal_code (str): Postal code string Return value: bool: True if the format is correct, False if it is not. """

# 文字列の長さが8であり、4文字目に '-' があり、前3桁と後4桁が数字か確認 if len(postal_code) == 8 and postal_code[3] == '-': # ハイフン前の部分とハイフン後の部分が数字かどうか確認 if postal_code[:3].isdigit() and postal_code[4:].isdigit(): return True return False

def check(candidate): assert candidate("123-4567") == True assert candidate("000-0000") == True assert candidate("12-34567") == False assert candidate("1234-567") == False assert candidate("123-456") == False assert candidate("1234567") == False assert candidate("abc-defg") == False

is_valid_postal_code

en/8

def convert_wareki_to_seireki(wareki: str) -> int: """ Converts the given Japanese calendar to the Western calendar. The Japanese calendar is limited to era names from ``明治'' to ``令和.'' The Japanese calendar is expressed as "令和3年" or "平成30年". Argument: wareki (str): Japanese calendar string Return: int: An integer representing the year in the Western calendar Execution example: >>> convert_wareki_to_seireki('令和3年') 2021 >>> convert_wareki_to_seireki('平成30年') 2018 >>> convert_wareki_to_seireki('昭和64年') 1989 >>> convert_wareki_to_seireki('平成元年') 1989 """

eras = { "令和": 2019, "平成": 1989, "昭和": 1926, "大正": 1912, "明治": 1868 } era_name = wareki[:2] year_str = wareki[2:-1] year = 1 if year_str == "元" else int(year_str) return eras[era_name] + year - 1

def check(candidate): assert candidate('令和3年') == 2021 assert candidate('平成30年') == 2018 assert candidate('昭和64年') == 1989 assert candidate('平成元年') == 1989 assert candidate('大正元年') == 1912 assert candidate('明治45年') == 1912 assert candidate('令和元年') == 2019 assert candidate('昭和1年') == 1926 assert candidate('明治1年') == 1868

convert_wareki_to_seireki

en/9

def is_shichi_go_san_age(birth_year: int, current_year: int) -> bool: """ Given the year of birth and the current year, determine whether that age is eligible for Shichi-Go-San. Since Shichi-Go-San is celebrated in the years when people are 3, 5, or 7 years old, it returns True if it is applicable, and False otherwise. argument: birth_year (int): Year of birth (Western calendar) current_year (int): Current year (Western calendar) Return value: bool: True if the target age of Shichi-Go-San, otherwise False Execution example: >>> is_shichi_go_san_age(2020, 2023) True # 3 years old >>> is_shichi_go_san_age(2018, 2023) True # 5 years old >>> is_shichi_go_san_age(2016, 2023) True # 7 years old >>> is_shichi_go_san_age(2017, 2023) False >>> is_shichi_go_san_age(2020, 2024) False """

age = current_year - birth_year return age in {3, 5, 7}

def check(candidate): assert candidate(2020, 2023) == True assert candidate(2018, 2023) == True assert candidate(2016, 2023) == True assert candidate(2017, 2023) == False assert candidate(2020, 2024) == False assert candidate(2015, 2023) == False assert candidate(2021, 2023) == False

is_shichi_go_san_age

en/10

def solve_tsurukame(total_animals: int, total_legs: int) -> tuple: """ A function that solves Tsurukame arithmetic. Calculate the number of each from the total of the crane and turtle and the total of the legs. Use the fact that cranes have two legs and turtles have four legs to solve this problem. For example, if the number of cranes is x and the number of turtles is y, the following formula holds. 1. x + y = total_animals (total number of cranes and turtles is given) 2. 2x + 4y = total_legs (given the sum of the legs of the crane and turtle) Transform this simultaneous equation to first find the number of turtles, y, and then find the number of cranes, x, by subtracting the number of turtles from the total number. argument: total_animals (int): Total number of cranes and turtles total_legs (int): total number of legs Return value: tuple: (number of cranes, number of turtles) Usage example: >>> solve_tsurukame(10, 28) (6, 4) """

y = (total_legs - 2 * total_animals) // 2 x = total_animals - y return x, y

def check(candidate): # 基本的なテストケース assert candidate(10, 28) == (6, 4) assert candidate(8, 24) == (4, 4) assert candidate(5, 14) == (3, 2) # 鶴と亀が全て鶴または全て亀の場合 assert candidate(10, 20) == (10, 0) assert candidate(5, 20) == (0, 5) # エッジケース: 鶴と亀が1匹ずつ assert candidate(2, 6) == (1, 1)

solve_tsurukame

en/11

def get_emergency_service(text: str) -> int: """ If the input string matches the service name of an emergency number, returns that number. Corresponding service name: - 消防・救急: 119 - 警察: 110 - 天気予報: 177 - 災害用伝言ダイヤル: 171 - 海上保安庁: 118 - 消費者ホットライン: 188 argument: text (str): Service name corresponding to the emergency number. Return value: int: Corresponding emergency phone number (integer). Execution example: >>> extract_emergency_number_from_key("消防・救急") 119 >>> extract_emergency_number_from_key("警察") 110 >>> extract_emergency_number_from_key("天気予報") 177 """

emergency_services = { "消防・救急": 119, "警察": 110, "天気予報": 177, "災害用伝言ダイヤル": 171, "海上保安庁": 118, "消費者ホットライン": 188 } return emergency_services.get(text)

def check(candidate): assert candidate("消防・救急") == 119 assert candidate("警察") == 110 assert candidate("天気予報") == 177 assert candidate("災害用伝言ダイヤル") == 171 assert candidate("海上保安庁") == 118 assert candidate("消費者ホットライン") == 188

get_emergency_service

en/12

def missing_positions(player_positions): """ Check the baseball positions and identify the missing positions. argument: player_positions (list): List of positions the player is in (in Kanji). Return value: list: List of missing positions. Execution example: >>> positions = ["投手", "捕手", "一塁手", "二塁手", "三塁手", "遊撃手"] >>> missing_positions(positions) ['中堅手', '左翼手', '右翼手'] >>> positions = ["投手", "捕手", "中堅手", "左翼手", "右翼手"] >>> missing_positions(positions) ['一塁手', '二塁手', '三塁手', '遊撃手'] """

required_positions = { "投手", "捕手", "一塁手", "二塁手", "三塁手", "遊撃手", "中堅手", "左翼手", "右翼手" } current_positions = set(player_positions) missing = required_positions - current_positions return list(missing)

def check(candidate): assert set(candidate(["投手", "捕手", "一塁手", "二塁手", "三塁手", "遊撃手"])) == {"中堅手", "左翼手", "右翼手"} assert set(candidate(["投手", "捕手", "一塁手", "二塁手", "三塁手", "遊撃手", "中堅手"])) == {"左翼手", "右翼手"} assert set(candidate([])) == {"投手", "捕手", "一塁手", "二塁手", "三塁手", "遊撃手", "中堅手", "左翼手", "右翼手"} assert set(candidate(["投手", "捕手", "中堅手"])) == {"一塁手", "二塁手", "三塁手", "遊撃手", "左翼手", "右翼手"}

missing_positions

en/13

def calculate_salt_solution_concentration(salt: float, water: float) -> float: """ Calculate the concentration of saline solution. Concentration = (weight of salt / (weight of salt + weight of water)) * 100 argument: salt (float): weight of salt (g) water (float): weight of water (g) Return value: float: Concentration of saline solution (%) Usage example: >>> calculate_salt_solution_concentration(10, 90) 10.0 >>> calculate_salt_solution_concentration(15, 85) 15.0 """

if salt + water == 0: return 0.0 concentration = (salt / (salt + water)) * 100 return concentration

def check(candidate): assert candidate(10, 90) == 10.0 assert candidate(15, 85) == 15.0 assert candidate(50, 50) == 50.0 assert candidate(30, 70) == 30.0

calculate_salt_solution_concentration

en/14

def corrections_needed(lyrics: str) -> int: """ Compare the given lyrics with the lyrics of Japan's national anthem "Kimigayo". Calculate the number of edits required to correct mistakes. Lyrics comparison is performed using character strings that do not include spaces. argument: lyrics (str): Lyrics entered by the user Return value: int: Number of times required for insertion/replacement/deletion and correction Execution example: >>> corrections_needed("君が代は千代に八千代に細石の巌となりて苔のむすまで") 0 >>> corrections_needed("君が代は千代に八千代に細石の巌となりて苔のむすまだ") 1 """

correct_lyrics = "君が代は千代に八千代に細石の巌となりて苔のむすまで" lyrics = lyrics.replace(" ", "") len_lyrics, len_correct = len(lyrics), len(correct_lyrics) dp = [[0] * (len_correct + 1) for _ in range(len_lyrics + 1)] for i in range(len_lyrics + 1): dp[i][0] = i for j in range(len_correct + 1): dp[0][j] = j for i in range(1, len_lyrics + 1): for j in range(1, len_correct + 1): if lyrics[i - 1] == correct_lyrics[j - 1]: cost = 0 else: cost = 1 dp[i][j] = min( dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost ) return dp[len_lyrics][len_correct]

def check(candidate): assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすまで") == 0 assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすまだ") == 1 assert candidate("君が代は千代に百千代に細石の巌となりて苔のむすまで") == 1 assert candidate("君が代は千代に八千代に細石の巌となり苔のむすまで") == 1 assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすま") == 1 assert candidate("君が代千代に八千代に細石の巌となりて苔のむすまでだよ") == 3 assert candidate("君が代は千代に八千代に細石の巌となり苔のむすま") == 2

corrections_needed

en/15

def get_condiment_by_hiragana(hiragana: str) -> str: """ Returns the seasoning that corresponds to the hiragana in the input line. argument: hiragana (str): Hiragana for the line (``さ'', ``し', ``す'', ``せ'', ``そ'') Return value: str: Compatible seasonings ("砂糖", "塩", "酢", "醤油", "miso") Usage example: >>> get_condiment_by_hiragana("さ") '砂糖' >>> get_condiment_by_hiragana("し") '塩' >>> get_condiment_by_hiragana("す") '酢' >>> get_condiment_by_hiragana("せ") '醤油' >>> get_condiment_by_hiragana("そ") '味噌' """

condiments = { "さ": "砂糖", "し": "塩", "す": "酢", "せ": "醤油", "そ": "味噌" } return condiments.get(hiragana)

def check(candidate): assert candidate("さ") == "砂糖" assert candidate("し") == "塩" assert candidate("す") == "酢" assert candidate("せ") == "醤油" assert candidate("そ") == "味噌"

get_condiment_by_hiragana

en/16

def classify_bow(angle: int) -> str: """ Based on the angle of the bow, the type of bow ('会釈', '普通礼', '最敬礼') is determined. argument: angle (int): angle of bow (integer) Return value: str: type of bow ('会釈', '普通礼', '最敬礼', or '無効な角度') Execution example: >>> classify_bow(15) '会釈' >>> classify_bow(30) '普通礼' >>> classify_bow(45) '最敬礼' >>> classify_bow(20) '無効な角度' """

if angle == 15: return "会釈" elif angle == 30: return "普通礼" elif angle == 45: return "最敬礼" else: return "無効な角度"

def check(candidate): assert candidate(15) == "会釈" assert candidate(30) == "普通礼" assert candidate(45) == "最敬礼" assert candidate(20) == "無効な角度" assert candidate(0) == "無効な角度" assert candidate(60) == "無効な角度"

classify_bow

en/17

def tatami_area(num_tatami: int, tatami_type: str) -> float: """ Calculate the area of ​​the room from the number of tatami mats and the type of tatami mats. The type of tatami is designated as ``江戸間'' or ``京間''. - 江戸間: 1.76 square meters (approximately 1.76 square meters) - 京間: 1.82 square meters (approximately 1.82 square meters) argument: num_tatami (int): Number of tatami tatami_type (str): Tatami type. Either '江戸間' or '京間'. Return value: float: area of ​​the room (square meters) Execution example: >>> tatami_area(6, "江戸間") 10.56 >>> tatami_area(6, "京間") 10.92 """

tatami_sizes = { "江戸間": 1.76, "京間": 1.82 } return round(num_tatami * tatami_sizes[tatami_type], 2)

def check(candidate): assert candidate(6, "江戸間") == 10.56 assert candidate(6, "京間") == 10.92 assert candidate(1, "江戸間") == 1.76 assert candidate(1, "京間") == 1.82 assert candidate(10, "江戸間") == 17.6 assert candidate(10, "京間") == 18.2

tatami_area

en/18

def compare_fortunes(last_year: str, this_year: str) -> str: """ Compare last year's fortune with this year's fortune and decide whether this year's fortune is better, worse, or unchanged than last year. Omikuji ranks are evaluated in the following order (left is best): 大吉 > 中吉 > 小吉 > 吉 > 末吉 > 凶 > 大凶 Argument: last_year (str): Last year's omikuji result this_year (str): This year's fortune results Return value: str: Message indicating whether this year is 良い, 悪い, or 変化なし than last year Example: >>> compare_fortunes("吉", "大吉") '良い' >>> compare_fortunes("大吉", "小吉") '悪い' >>> compare_fortunes("中吉", "中吉") '変化なし' """

fortune_ranks = { "大吉": 1, "中吉": 2, "小吉": 3, "吉": 4, "末吉": 5, "凶": 6, "大凶": 7 } last_rank = fortune_ranks.get(last_year, float('inf')) this_rank = fortune_ranks.get(this_year, float('inf')) if this_rank < last_rank: return '良い' elif this_rank > last_rank: return '悪い' else: return '変化なし'

def check(candidate): assert candidate("吉", "大吉") == '良い' assert candidate("大吉", "小吉") == '悪い' assert candidate("中吉", "中吉") == '変化なし' assert candidate("凶", "吉") == '良い' assert candidate("大凶", "大吉") == '良い' assert candidate("大吉", "大凶") == '悪い' assert candidate("末吉", "末吉") == '変化なし' assert candidate("小吉", "中吉") == '良い' assert candidate("小吉", "凶") == '悪い' assert candidate("中吉", "小吉") == '悪い' assert candidate("大吉", "大吉") == '変化なし'

compare_fortunes

en/19

def judo_match_winner(A: dict, B: dict) -> str: """ Determine the winner or loser of a judo match. argument: A (dict): Player A's score and foul information - "一本" (int): Number of one - "技あり" (int): number of wazaari - "指導" (int): number of teachings B (dict): Player B's score and foul information - "一本" (int): Number of one - "技あり" (int): number of wazaari - "指導" (int): number of teachings Return value: str: string representing the winner ("A", "B", "extension") Execution example: >>> judo_match_winner({"一本": 1, "技あり": 0, "指導": 0}, {"一本": 0, "技あり": 1, "指導": 0}) 'A' >>> judo_match_winner({"一本": 0, "技あり": 2, "指導": 1}, {"一本": 0, "技あり": 1, "指導": 0}) 'A' >>> judo_match_winner({"一本": 0, "技あり": 0, "指導": 3}, {"一本": 0, "技あり": 0, "指導": 3}) '延長' """

# 1. 一本勝ちの判定 if A["一本"] > B["一本"]: return "A" elif A["一本"] < B["一本"]: return "B" # 2. 技ありの判定（2つで一本と同等） if A["技あり"] >= 2: return "A" if B["技あり"] >= 2: return "B" if A["技あり"] > B["技あり"]: return "A" if A["技あり"] < B["技あり"]: return "B" # 3. 指導による敗北（指導3つで敗北） if A["指導"] >= 3 and B["指導"] < 3: return "B" if B["指導"] >= 3 and A["指導"] < 3: return "A" # 4. 引き分け（延長） return "延長"

def check(candidate): # 一本勝ちの例 assert candidate({"一本": 1, "技あり": 0, "指導": 0}, {"一本": 0, "技あり": 0, "指導": 0}) == "A" assert candidate({"一本": 0, "技あり": 0, "指導": 0}, {"一本": 1, "技あり": 0, "指導": 0}) == "B" # 技ありの判定 assert candidate({"一本": 0, "技あり": 2, "指導": 1}, {"一本": 0, "技あり": 1, "指導": 0}) == "A" assert candidate({"一本": 0, "技あり": 1, "指導": 0}, {"一本": 0, "技あり": 2, "指導": 0}) == "B" # 指導による勝敗 assert candidate({"一本": 0, "技あり": 0, "指導": 3}, {"一本": 0, "技あり": 0, "指導": 2}) == "B" assert candidate({"一本": 0, "技あり": 0, "指導": 2}, {"一本": 0, "技あり": 0, "指導": 3}) == "A" # 引き分け（延長） assert candidate({"一本": 0, "技あり": 0, "指導": 3}, {"一本": 0, "技あり": 0, "指導": 3}) == "延長" assert candidate({"一本": 0, "技あり": 1, "指導": 1}, {"一本": 0, "技あり": 1, "指導": 1}) == "延長"

judo_match_winner

en/20

def compare_to_tokyo_tower(height: int) -> str: """ Compare the height of Tokyo Tower (333m) and the input height, Determine if they are higher, lower, or the same height. argument: height (int): Height to compare (unit: meters) Return: str: Is the input height "高い", "低い", or "同じ" Usage example: >>> compare_to_tokyo_tower(400) '高い' >>> compare_to_tokyo_tower(333) '同じ' >>> compare_to_tokyo_tower(100) '低い' """

TOKYO_TOWER_HEIGHT = 333 # 東京タワーの高さ（単位: メートル） if height > TOKYO_TOWER_HEIGHT: return "高い" elif height < TOKYO_TOWER_HEIGHT: return "低い" else: return "同じ"

def check(candidate): assert candidate(400) == "高い" assert candidate(333) == "同じ" assert candidate(100) == "低い" assert candidate(500) == "高い" assert candidate(0) == "低い"

compare_to_tokyo_tower

en/21

def is_valid_mynumber_format(mynumber: str) -> bool: """ Determine whether the My Number format is correct. My Number is a 12-digit number that is unique to each person. argument: mynumber (str): My number (string format) Return value: bool: True if the format is correct, False otherwise example: >>> is_valid_mynumber_format("123456789012") True >>> is_valid_mynumber_format("12345678ABCD") False >>> is_valid_mynumber_format("12345678901") False """

return mynumber.isdigit() and len(mynumber) == 12

def check(candidate): assert candidate("123456789012") == True assert candidate("135790246810") == True assert candidate("12345678901") == False assert candidate("1234567890123") == False assert candidate("ABCDEFGGIJKL") == False

is_valid_mynumber_format

en/22

def can_vote(birthday: str, today: str) -> bool: """ A program to determine voting age (18 years or older). argument: birthday (str): Date of birth ("YYYY年MM月DD日"). today (str): Current date ("YYYY年MM月DD日"). Return value: bool: True if you have the right to vote, False otherwise. Execution example: >>> can_vote("2000年01月01日", "2008年01月01日") False >>> can_vote("2000年01月01日", "2020年01月01日") True """

# 生年月日と現在の日付を分割し、整数に変換 birth_year, birth_month, birth_day = map(int, birthday.replace("年", "-").replace("月", "-").replace("日", "").split("-")) today_year, today_month, today_day = map(int, today.replace("年", "-").replace("月", "-").replace("日", "").split("-")) # 年齢を計算 age = today_year - birth_year if (today_month, today_day) < (birth_month, birth_day): age -= 1 # 誕生日が来ていない場合は年齢を1引く # 18歳以上かどうかを判定 return age >= 18

def check(candidate): assert candidate("2000年01月01日", "2008年01月01日") == False assert candidate("2000年01月01日", "2020年01月01日") == True assert candidate("2002年12月31日", "2021年12月31日") == True assert candidate("2005年07月01日", "2023年06月30日") == False assert candidate("2005年07月01日", "2023年07月01日") == True

can_vote

en/23

def get_rokuyou(days: int) -> str: """ Assuming that today's Rokuyo is "先勝", returns the Rokuyo from the specified number of days later. argument: days (int): Number of days since today Return value: str: Rokuyo (any of "先勝", "友引", "先負", "仏滅", "大安", "赤口") """

rokuyou_names = ["先勝", "友引", "先負", "仏滅", "大安", "赤口"] index = days % 6 return rokuyou_names[index]

def check(candidate): assert candidate(0) == "先勝" assert candidate(1) == "友引" assert candidate(2) == "先負" assert candidate(3) == "仏滅" assert candidate(4) == "大安" assert candidate(5) == "赤口" assert candidate(6) == "先勝" assert candidate(7) == "友引" assert candidate(30) == "先勝" assert candidate(365) == "赤口"

get_rokuyou

en/24

import re def normalize_postal_code(postal_code: str) -> str: """ A function that unifies the notation of postal codes. ・Delete extra white space ・Convert full-width numbers and full-width symbols (such as "-") to half-width - Place the hyphen in the postal code in the correct position (e.g. '1234567' → '123-4567') argument: postal_code (str): Postal code string Return value: str: Normalized postal code example: >>> normalize_postal_code("〒1234567") '123-4567' >>> normalize_postal_code("1234567") '123-4567' """

postal_code = re.sub(r'\s+|〒', '', postal_code) full_width_to_half_width = str.maketrans( '０１２３４５６７８９－', '0123456789-' ) postal_code = postal_code.translate(full_width_to_half_width) postal_code = re.sub(r'(\d{3})(\d{4})', r'\1-\2', postal_code) return postal_code

def check(candidate): assert candidate("１２３-４５６７") == '123-4567' assert candidate("1234567") == '123-4567' assert candidate(" 123 4567 ") == '123-4567' assert candidate("〒１２３４５６７") == '123-4567' assert candidate("１２３　４５６７") == '123-4567' assert candidate("123-4567") == '123-4567' assert candidate("１２３－４５６７") == '123-4567'

normalize_postal_code

en/25

def identify_nanakusa(name: str) -> bool: """ Returns True if the given name `name` applies to the seven spring herbs, otherwise returns False. The seven herbs of spring are "せり", "なずな", "ごぎょう", "はこべら", "ほとけのざ", "すずな" or "すずしろ". argument: - name (str): Hiragana name Return value: - bool: True/False Example: >>> identify_nanakusa("せり") True >>> identify_nanakusa("なずな") True >>> identify_nanakusa("さくら") False >>> identify_nanakusa("きく") False """

# 春の七草のリスト nanakusa = {"せり", "なずな", "ごぎょう", "はこべら", "ほとけのざ", "すずな", "すずしろ"} # 名前が七草に含まれるかどうかを判定 return name in nanakusa

def check(candidate): assert candidate("せり") == True assert candidate("なずな") == True assert candidate("ごぎょう") == True assert candidate("はこべら") == True assert candidate("ほとけのざ") == True assert candidate("すずな") == True assert candidate("すずしろ") == True assert candidate("さくら") == False assert candidate("きく") == False assert candidate("たんぽぽ") == False assert candidate("ほうれんそう") == False

identify_nanakusa

en/26

import math def calculate_fan(radius: int, angle: int, threshold: float) -> bool: """ If the area of ​​the fan is greater than or equal to `threshold`, it is determined that the pattern looks beautiful. Calculates the area of ​​the fan and returns True if it looks good, False if it doesn't. The area of ​​the fan is calculated using the following formula: Area = 0.5 * radius^2 * (radian value of angle) argument: radius (int): Radius of the fan (unit: cm, positive integer). angle (int): The angle of the fan (unit: degrees, 0-360). threshold (float): The area threshold (unit: square cm) for the pattern to look good. Return value: bool: True if the area is greater than or equal to the threshold, otherwise False. example: >>> calculate_fan(10, 180, 100) True >>> calculate_fan(10, 90, 100) False """

# 角度をラジアンに変換 angle_rad = math.radians(angle) # 扇子の面積を計算 area = 0.5 * (radius ** 2) * angle_rad # 面積が閾値以上か判定 return area >= threshold

def check(candidate): assert candidate(10, 180, 100) == True assert candidate(10, 90, 100) == False assert candidate(15, 120, 150) == True assert candidate(5, 360, 150) == False assert candidate(20, 360, 500) == True assert candidate(1, 1, 0.01) == False

calculate_fan

en/27

def calculate_mission_success(skill: int, difficulty: int) -> int: """ Calculate the ninja's mission success rate. The mission success rate can be calculated from the difference between the ninja's technical ability and the difficulty of the mission. argument: skill (int): Ninja's technical ability (1-100) difficulty (int): Difficulty of the mission (1-100) Return value: int: Mission success rate (0-100) """

return max(0, skill - difficulty)

def check(candidate): assert candidate(80, 50) == 30 assert candidate(40, 60) == 0 assert candidate(100, 100) == 0 assert candidate(70, 50) == 20 assert candidate(50, 50) == 0 assert candidate(90, 30) == 60 assert candidate(30, 70) == 0 assert candidate(1, 100) == 0 assert candidate(100, 1) == 99

calculate_mission_success

en/28

def weight_needed_for_sumo(height: int, current_weight: int) -> tuple: """ Calculate the amount of weight gain needed to reach the average BMI of a sumo wrestler from your height and current weight. If the sumo wrestler's average BMI is 33, returns the target weight and required weight gain. argument: height (int): Height (cm) current_weight (int): Current weight (kg) Return value: tuple: target weight and required weight gain (both integers) example: >>> weight_needed_for_sumo(180, 100) (106, 6) >>> weight_needed_for_sumo(175, 80) (101, 21) """

target_bmi = 33 height_m = height / 100 target_weight = target_bmi * (height_m ** 2) weight_increase = target_weight - current_weight target_weight = int(round(target_weight)) weight_increase = int(round(weight_increase)) return (target_weight, weight_increase)

def check(candidate): assert candidate(180, 100) == (107, 7) assert candidate(175, 80) == (101, 21) assert candidate(160, 60) == (84, 24) assert candidate(200, 120) == (132, 12) assert candidate(165, 75) == (90, 15) assert candidate(150, 50) == (74, 24) assert candidate(190, 90) == (119, 29) assert candidate(185, 85) == (113, 28) assert candidate(155, 65) == (79, 14) assert candidate(178, 70) == (105, 35)

weight_needed_for_sumo

en/29

def month_to_emoji(month: int) -> str: """ A function that accepts the month and returns the corresponding emoji. """ number_to_emoji = { 1: '🎍', 2: '👹', 3: '🎎', 4: '🌸', 5: '🎏', 6: '☔', 7: '🎋', 8: '🍉', 9: '🎑', 10: '🏃', 11: '🍁', 12: '🎄' } emoji = number_to_emoji.get(month, '') return emoji def create_monthly_message(month: int) -> str: """ A function that accepts the month and creates a corresponding message. month_to_emoji gets the emoji for the month and returns it on both sides of the message. >>> create_monthly_message(1) '🎍今月は1月です🎍' >>> create_monthly_message(12) '🎄今月は12月です🎄' """

emoji = month_to_emoji(month) return f'{emoji}今月は{month}月です{emoji}'

def check(candidate): assert candidate(1) == '🎍今月は1月です🎍' assert candidate(2) == '👹今月は2月です👹' assert candidate(3) == '🎎今月は3月です🎎' assert candidate(4) == '🌸今月は4月です🌸' assert candidate(5) == '🎏今月は5月です🎏' assert candidate(6) == '☔今月は6月です☔' assert candidate(7) == '🎋今月は7月です🎋' assert candidate(8) == '🍉今月は8月です🍉' assert candidate(9) == '🎑今月は9月です🎑' assert candidate(10) == '🏃今月は10月です🏃' assert candidate(11) == '🍁今月は11月です🍁' assert candidate(12) == '🎄今月は12月です🎄'

create_monthly_message

en/30

def calculate_postcard_fee(fee: int, x: int) -> int: """ This is a function that calculates the price of postcards. argument: fee (int): Fee for one postcard (yen) x (int): Number of postcards Return value: int: Total postcard fee (yen) example: >>> calculate_postcard_fee(63, 1) 63 >>> calculate_postcard_fee(63, 5) 315 """

return fee * x

def check(candidate): assert candidate(63, 1) == 63 assert candidate(63, 5) == 315 assert candidate(63, 10) == 630 assert candidate(70, 10) == 700 assert candidate(84, 2) == 168 assert candidate(84, 3) == 252

calculate_postcard_fee

en/31

from typing import List def sort_koinobori(sizes: List[int]) -> List[int]: """ Sort the carp streamer size list from largest to largest. - sizes (List[int]): List of sizes (cm) of each carp streamer. - Returns: A list of carp streamers sorted by size. example: >>> sort_koinobori([30, 50, 70, 20]) [70, 50, 30, 20] >>> sort_koinobori([100, 200, 150]) [200, 150, 100] """

return sorted(sizes, reverse=True)

def check(candidate): assert candidate([30, 50, 70, 20]) == [70, 50, 30, 20] assert candidate([100, 200, 150]) == [200, 150, 100] assert candidate([10, 10, 10]) == [10, 10, 10] assert candidate([5, 3, 8, 1]) == [8, 5, 3, 1] assert candidate([500, 100, 300, 200]) == [500, 300, 200, 100] assert candidate([1]) == [1] assert candidate([999, 1000, 888, 1000]) == [1000, 1000, 999, 888]

sort_koinobori

en/32

from typing import List def determine_winner(red_scores: List[int], white_scores: List[int]) -> str: """ The winner of the 紅白歌合戦 will be determined. Each group is given a score, and the team with the highest total score is the winning team. Returns either "紅組", "白組", or "引き分け". Example: >>> determine_winner([10, 20, 30], [15, 25, 20]) '引き分け' >>> determine_winner([50, 40, 60], [30, 20, 10]) '紅組' >>> determine_winner([10, 20, 30], [40, 50, 60]) '白組' """

red_total = sum(red_scores) white_total = sum(white_scores) if red_total > white_total: return "紅組" elif white_total > red_total: return "白組" else: return "引き分け"

def check(candidate): assert candidate([10, 20, 30], [15, 25, 20]) == '引き分け' assert candidate([50, 40, 60], [30, 20, 10]) == '紅組' assert candidate([10, 20, 30], [40, 50, 60]) == '白組' assert candidate([100, 200, 300], [100, 150, 200]) == '紅組' assert candidate([0, 0, 0], [0, 0, 0]) == '引き分け' assert candidate([999], [1000]) == '白組'

determine_winner

en/33

from typing import List def calculate_yamanote_distance(start: str, end: str, stations: List[str]) -> int: """ Given a list of stations on the Yamanote Line, a departure station, and an arrival station, calculate the number of stations from the departure station to the arrival station. Since the Yamanote Line is a circular line, we consider two routes, one clockwise and one counterclockwise, and return the one with fewer stations. - start (str): Name of departure station - end (str): name of arrival station - stations (List[str]): List of station names on the Yamanote Line (in order along the loop line) - Return value: Shortest number of stations """

start_index = stations.index(start) end_index = stations.index(end) clockwise_distance = (end_index - start_index) % len(stations) counterclockwise_distance = (start_index - end_index) % len(stations) return min(clockwise_distance, counterclockwise_distance)

def check(candidate): stations = ["東京", "有楽町", "新橋", "浜松町", "田町", "品川", "大崎", "五反田", "目黒", "恵比寿", "渋谷", "原宿", "代々木", "新宿", "新大久保", "高田馬場", "目白", "池袋", "大塚", "巣鴨", "駒込", "田端", "西日暮里", "日暮里", "鶯谷", "上野", "御徒町", "秋葉原", "神田"] assert candidate("東京", "品川", stations) == 5 assert candidate("東京", "渋谷", stations) == 10 assert candidate("渋谷", "東京", stations) == 10 assert candidate("恵比寿", "目黒", stations) == 1 assert candidate("大塚", "上野", stations) == 7 assert candidate("秋葉原", "東京", stations) == 2

calculate_yamanote_distance

en/34

def daruma_block(blocks: list, count: int) -> list: """ Daruma blocks are arranged in the order of blocks. Drops the bottom block count times and returns the list of currently remaining Daruma blocks. argument: blocks (list): list of Daruma blocks count (int): Number of drops Return value: list: Daruma's block list after dropping it Example: >>> daruma_block(['赤', '青', '緑', '黄'], 2) ['赤', '青'] >>> daruma_block(['赤', '青'], 1) ['赤'] """

return blocks[:-count] if count < len(blocks) else []

def check(candidate): assert candidate(['赤', '青', '緑', '黄'], 1) == ['赤', '青', '緑'] assert candidate(['赤', '青', '緑', '黄'], 2) == ['赤', '青'] assert candidate(['赤', '青', '緑', '黄'], 3) == ['赤'] assert candidate(['赤', '青', '緑', '黄'], 4) == [] assert candidate(['赤', '青'], 1) == ['赤']

daruma_block

en/35

def ryugu_time_passed(days: int) -> int: """ Returns the number of days elapsed on earth based on the number of days spent in Ryugu Castle. If you spend one day in Ryugu Castle, 365 days have passed on earth. argument: days (int): Number of days spent in Ryugujo Return value: int: Number of days on earth Usage example: >>> ryugu_time_passed(1) 365 >>> ryugu_time_passed(10) 3650 """

return int(days) * 365

def check(candidate): assert candidate(1) == 365 assert candidate(0) == 0 assert candidate(10) == 3650 assert candidate(100) == 36500 assert candidate(365) == 133225 assert candidate(2) == 730 assert candidate(50) == 18250 assert candidate(123) == 44895

ryugu_time_passed

en/36

def check_kendo_gear(gear: list) -> str: """ A function that determines whether all Kendo armor is available. argument: gear (list): List of equipped armor Return value: str: '準備完了' or '準備不足' Usage example: >>> check_kendo_gear(['面', '小手', '胴', '垂']) '準備完了' >>> check_kendo_gear(['面', '小手', '垂']) '準備不足' """

required_gear = {'面', '小手', '胴', '垂'} if required_gear.issubset(set(gear)): return '準備完了' else: return '準備不足'

def check(candidate): assert candidate(['面', '小手', '胴', '垂']) == '準備完了' assert candidate(['面', '小手', '垂']) == '準備不足' assert candidate(['面', '小手']) == '準備不足' assert candidate(['面', '面', '面', '面']) == '準備不足' assert candidate(['面', '小手', '胴']) == '準備不足' assert candidate([]) == '準備不足' assert candidate(['小手', '胴', '垂', '面']) == '準備完了' assert candidate(['面', '小手', '胴', '垂', 'サポーター']) == '準備完了' assert candidate(['面', '垂', '小手', '胴', '足袋']) == '準備完了'

check_kendo_gear

en/37

def get_ehou_direction(year: int) -> str: """ A function that receives the year in the Western calendar and returns the lucky direction (東北東, 南南東, 西南西, or 北北西) of that year. argument: year (int): year of the Western calendar Return value: str: Direction of lucky direction for the year Usage example: >>> get_ehou_direction(2024) '東北東' >>> get_ehou_direction(2025) '北北西' >>> get_ehou_direction(2026) '西南西' >>> get_ehou_direction(2027) '南南東' """

directions = ['東北東', '北北西', '西南西', '南南東'] return directions[year % 4]

def check(candidate): assert candidate(2020) == '東北東' assert candidate(2021) == '北北西' assert candidate(2022) == '西南西' assert candidate(2023) == '南南東' assert candidate(2024) == '東北東' assert candidate(2025) == '北北西' assert candidate(2026) == '西南西' assert candidate(2027) == '南南東' assert candidate(2028) == '東北東'

get_ehou_direction

en/38

from collections import Counter def rank_sushi_ingredients(orders: list) -> list: """ A function that returns popular sushi items from a sushi order list in order of ranking. argument: orders (list): List of ordered sushi items Return value: list: List of sushi toppings arranged in order of popularity Usage example: >>> rank_sushi_ingredients(["まぐろ", "サーモン", "まぐろ", "いくら", "サーモン", "まぐろ"]) ['まぐろ', 'サーモン', 'いくら'] >>> rank_sushi_ingredients(["えび", "えび", "たまご", "いか", "いか", "いか"]) ['いか', 'えび', 'たまご'] >>> rank_sushi_ingredients(["まぐろ", "まぐろ", "まぐろ"]) ['まぐろ'] """

count = Counter(orders) sorted_items = sorted(count.items(), key=lambda x: (-x[1], x[0])) return [item[0] for item in sorted_items]

def check(candidate): # 基本的なテストケース assert candidate(["まぐろ", "サーモン", "まぐろ", "いくら", "サーモン", "まぐろ"]) == ['まぐろ', 'サーモン', 'いくら'] assert candidate(["えび", "えび", "たまご", "いか", "いか", "いか"]) == ['いか', 'えび', 'たまご'] assert candidate(["まぐろ", "まぐろ", "まぐろ"]) == ['まぐろ'] assert candidate(["うに", "いくら", "いくら", "たこ", "たこ", "たこ", "サーモン", "サーモン", "サーモン"]) == ['たこ', 'サーモン', 'いくら', 'うに'] # 境界値テスト assert candidate([]) == [] assert candidate(["まぐろ"]) == ["まぐろ"] assert candidate(["まぐろ", "まぐろ", "まぐろ", "まぐろ", "まぐろ"]) == ["まぐろ"]

rank_sushi_ingredients

en/39

def calculate_remaining_bill(total_bill: int, boss_bills: list, other_members_count: int) -> int: """ A function that distributes the amount of your bill. argument: total_bill (int): Total amount boss_bills (list): List of amounts paid by the boss other_members_count (int): Number of people other than the boss Return value: int: amount paid by each member Usage example: >>> calculate_remaining_bill(10000, [3000, 2000], 3) 1666 >>> calculate_remaining_bill(15000, [5000], 4) 2500 >>> calculate_remaining_bill(20000, [8000, 8000], 1) 4000 """

total_boss_payment = sum(boss_bills) remaining_amount = total_bill - total_boss_payment if remaining_amount <= 0: return 0 remaining_per_member = remaining_amount // other_members_count return remaining_per_member

def check(candidate): assert candidate(10000, [3000, 2000], 3) == 1666 assert candidate(15000, [5000], 4) == 2500 assert candidate(20000, [8000, 8000], 1) == 4000 assert candidate(10000, [10000], 3) == 0 assert candidate(10000, [11000], 3) == 0 assert candidate(1000000, [400000, 300000], 10) == 30000 assert candidate(1000000, [999999], 1) == 1

calculate_remaining_bill

en/40

def recommend_least_crowded_train(train_crowdings: dict) -> str: """ A function that recommends the least crowded train based on the congestion level of each train. argument: train_crowdings (dict): Dictionary of {train name: crowding rate (0-100%)} Return value: str: name of the least crowded train Usage example: >>> recommend_least_crowded_train({"A train": 80, "B train": 60, "C train": 90}) 'B train' >>> recommend_least_crowded_train({"Yamanote Line": 95, "Keihin Tohoku Line": 85, "Chuo Line": 99}) 'Keihin Tohoku Line' """

return min(train_crowdings, key=lambda train: train_crowdings[train])

def check(candidate): assert candidate({"A列車": 80, "B列車": 60, "C列車": 90}) == 'B列車' assert candidate({"山手線": 95, "京浜東北線": 85, "中央線": 99}) == '京浜東北線' assert candidate({"A列車": 50, "B列車": 50, "C列車": 50}) == 'A列車' assert candidate({"列車1": 0, "列車2": 100}) == '列車1' assert candidate({"列車1": 0}) == '列車1' assert candidate({"新幹線": 10, "特急": 20, "快速": 15}) == '新幹線' assert candidate({"夜行列車": 100, "通勤快速": 99, "普通列車": 98}) == '普通列車' assert candidate({"A": 100, "B": 100, "C": 100}) == 'A' assert candidate({"急行": 70, "普通": 40, "特急": 90}) == '普通'

recommend_least_crowded_train

en/41

def get_izumo_traditional_month_name(n: int) -> str: """ Returns the traditional month name of the Izumo region that corresponds to the current month. In the Izumo region, October is called "神有月". argument: n (int): current month (1-12) Return value: str: Ancient month name in Izumo region example: >>> get_izumo_traditional_month_name(1) '睦月' >>> get_izumo_traditional_month_name(6) '水無月' >>> get_izumo_traditional_month_name(10) '神有月' """

month_names = [ "睦月", "如月", "弥生", "卯月", "皐月", "水無月", "文月", "葉月", "長月", "神有月", "霜月", "師走" ] return month_names[n - 1]

def check(candidate): assert candidate(1) == "睦月" assert candidate(2) == "如月" assert candidate(3) == "弥生" assert candidate(4) == "卯月" assert candidate(5) == "皐月" assert candidate(6) == "水無月" assert candidate(7) == "文月" assert candidate(8) == "葉月" assert candidate(9) == "長月" assert candidate(10) == "神有月" assert candidate(11) == "霜月" assert candidate(10) == "神有月" assert candidate(12) == "師走"

get_izumo_traditional_month_name

en/42

def append_administrative_unit(prefecture: str) -> str: """ Returns the given prefecture name with the correct administrative unit ("都", "道", "府", "県"). argument: prefecture (str): prefecture name without administrative unit Return value: str: Prefecture name with administrative unit example: >>> append_administrative_unit("東京") '東京都' >>> append_administrative_unit("北海道") '北海道' >>> append_administrative_unit("京都") '京都府' >>> append_administrative_unit("愛知") '愛知県' """

prefectures_with_special_units = { "東京": "東京都", "大阪": "大阪府", "京都": "京都府", "北海道": "北海道" } if prefecture in prefectures_with_special_units: return prefectures_with_special_units[prefecture] else: return prefecture + "県"

def check(candidate): assert candidate("東京") == "東京都" assert candidate("北海道") == "北海道" assert candidate("大阪") == "大阪府" assert candidate("京都") == "京都府" assert candidate("埼玉") == "埼玉県" assert candidate("神奈川") == "神奈川県" assert candidate("愛知") == "愛知県" assert candidate("新潟") == "新潟県" assert candidate("兵庫") == "兵庫県" assert candidate("福岡") == "福岡県" assert candidate("沖縄") == "沖縄県"

append_administrative_unit

en/43

import math def days_to_complete(m: int, n: int) -> int: """ Calculate how many days it will take Takashi and Kiyoshi to finish their work together. Round the result up to the nearest integer. argument: m (int): How many days would it take for Takashi to do it alone? n (int): How many days would it take if Kiyoshi did it alone? Return value: int: Number of days it takes for two people to finish the job (rounded up to the nearest integer) Usage example: >>> days_to_complete(6, 3) 2 >>> days_to_complete(5, 5) 3 >>> days_to_complete(7, 4) 3 """

combined_rate = 1/m + 1/n total_days = 1 / combined_rate return math.ceil(total_days)

def check(candidate): assert candidate(6, 3) == 2 assert candidate(5, 5) == 3 assert candidate(7, 4) == 3 assert candidate(10, 2) == 2 assert candidate(8, 8) == 4 assert candidate(12, 6) == 4 assert candidate(9, 3) == 3 assert candidate(15, 5) == 4

days_to_complete

en/44

import math def days_to_meet(x: int, y: int) -> int: """ There is an older brother and a younger brother who fly back and forth across the 120 ri between Edo and Kyoto. The older brother goes x miles a day, and the younger brother goes y miles a day. Now, the older brother is heading towards Kyoto and the younger brother is heading towards Edo and Kyoto respectively. We left at the same time. Calculate on what day the brothers will meet. argument: x (int): Distance traveled by my brother in a day (village) y (int): Distance traveled by the younger brother in a day (village) Return value: int: number of days the siblings meet Execution example: >>> days_to_meet(14, 11) 5 >>> days_to_meet(10, 12) 6 """

total_distance = 120 combined_speed = x + y return math.ceil(total_distance / combined_speed)

def check(candidate): assert candidate(14, 11) == 5 assert candidate(10, 12) == 6 assert candidate(20, 20) == 3 assert candidate(15, 15) == 4 assert candidate(25, 30) == 3 assert candidate(1, 1) == 60 assert candidate(10, 110) == 1

days_to_meet

en/45

def find_number_of_thieves(m: int, r: int, c: int) -> int: """ If the thief takes m pieces each, there will be r pieces left over, and if he takes m-1 pieces each, there will be c pieces left over. Calculate the number of thieves. argument: m (int): Number of silk items taken per person r (int): Remaining reciprocal c (int): missing counternumber Return value: int: number of thieves Usage example: >>> find_number_of_thieves(5, 3, 2) -5 >>> find_number_of_thieves(4, 1, 3) -4 >>> find_number_of_thieves(6, 0, 1) -1 """

n = -(r + c) return n

def check(candidate): assert candidate(5, 3, 2) == -5 assert candidate(4, 1, 3) == -4 assert candidate(6, 0, 1) == -1 assert candidate(10, 5, 7) == -12 assert candidate(3, 2, 2) == -4

find_number_of_thieves

en/46

def total_bales_of_rice(n: int) -> int: """ Rice bales are stacked sideways in a cedar shape. Find the total number of rice bales. argument: n (int): Number of rice bags in the bottom row Return value: int: How many bales are there in total? Execution example: >>> total_bales_of_rice(3) 6 >>> total_bales_of_rice(5) 15 >>> total_bales_of_rice(1) 1 """

return n * (n + 1) // 2

def check(candidate): assert candidate(3) == 6 assert candidate(5) == 15 assert candidate(1) == 1 assert candidate(10) == 55 assert candidate(0) == 0 assert candidate(20) == 210

total_bales_of_rice

en/47

def total_cries(n: int) -> int: """ If there are n crows, each crow crows n times, and they are in n pools, calculate how many crows they crow in total. argument: n (int): An integer representing the number of crows, number of uras, and number of crows per crow Return value: int: Total number of cries Execution example: >>> total_cries(1) 1 >>> total_cries(2) 8 >>> total_cries(3) 27 >>> total_cries(4) 64 """

return n ** 3

def check(candidate): assert candidate(1000) == 1000 ** 3 assert candidate(500) == 500 ** 3 assert candidate(1234) == 1234 ** 3 assert candidate(0) == 0 ** 3 assert candidate(1) == 1 ** 3 assert candidate(2500) == 2500 ** 3 assert candidate(999) == 999 ** 3

total_cries

en/48

def min_coins(x: int) -> int: """ Calculate the minimum number of coins required to pay x yen. The coins that can be used are 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen. argument: x (int): amount to pay Return value: int: minimum number of coins Execution example: >>> min_coins(1) 1 >>> min_coins(567) 6 """

coins = [500, 100, 50, 10, 5, 1] count = 0 for coin in coins: count += x // coin x %= coin return count

def check(candidate): assert candidate(1) == 1 assert candidate(5) == 1 assert candidate(11) == 2 assert candidate(250) == 3 assert candidate(567) == 6 assert candidate(1000) == 2 assert candidate(1234) == 11

min_coins

en/49

def count_ways(n: int) -> int: """ When you go up the n-step stairs at Yamadera, you go up one or two steps, Calculate the number of ways to climb if you do not climb two steps in succession. argument: n (int): Number of stairs (positive integer) Return value: int: number of ways up the stairs Execution example: >>> count_ways(1) 1 >>> count_ways(2) 2 >>> count_ways(3) 3 """

if n == 1: return 1 if n == 2: return 2 dp = [0] * (n + 1) dp[1] = 1 dp[2] = 2 for i in range(3, n + 1): dp[i] = dp[i - 1] + dp[i - 2] return dp[n]

def check(candidate): assert candidate(1) == 1 assert candidate(2) == 2 assert candidate(3) == 3 assert candidate(4) == 5 assert candidate(5) == 8 assert candidate(6) == 13 assert candidate(7) == 21 assert candidate(8) == 34 assert candidate(9) == 55 assert candidate(10) == 89 assert candidate(15) == 987

count_ways

en/50

def is_japan_prefecture(prefecture): """ A function that determines whether a given prefecture name is a Japanese prefecture. This function is based on a list of Japan's 47 prefectures (1 capital, 1 prefecture, 2 prefectures, 43 prefectures). Checks whether the entered prefecture name is included in that list and returns the result. Parameters: prefecture (str): Prefecture name to be determined Returns: bool: True if the prefecture name is included in Japan, otherwise False example: >>> is_japan_prefecture('東京都') True >>> is_japan_prefecture('ニューヨーク') False """

japan_prefectures = [ '北海道', '青森県', '岩手県', '宮城県', '秋田県', '山形県', '福島県', '茨城県', '栃木県', '群馬県', '埼玉県', '千葉県', '東京都', '神奈川県', '新潟県', '富山県', '石川県', '福井県', '山梨県', '長野県', '岐阜県', '静岡県', '愛知県', '三重県', '滋賀県', '京都府', '大阪府', '兵庫県', '奈良県', '和歌山県', '鳥取県', '島根県', '岡山県', '広島県', '山口県', '徳島県', '香川県', '愛媛県', '高知県', '福岡県', '佐賀県', '長崎県', '熊本県', '大分県', '宮崎県', '鹿児島県', '沖縄県' ] return prefecture in japan_prefectures

def check(candidate): true_prefectures = [ '東京都', '大阪府', '北海道', '福岡県', '沖縄県', '青森県', '岩手県', '宮城県', '秋田県', '山形県', '福島県', '茨城県', '栃木県', '群馬県', '埼玉県', '千葉県', '神奈川県', '新潟県', '富山県', '石川県', '福井県', '山梨県', '長野県', '岐阜県', '静岡県', '愛知県', '三重県', '滋賀県', '京都府', '兵庫県', '奈良県', '和歌山県', '鳥取県', '島根県', '岡山県', '広島県', '山口県', '徳島県', '香川県', '愛媛県', '高知県', '佐賀県', '長崎県', '熊本県', '大分県', '宮崎県', '鹿児島県' ] for prefecture in true_prefectures: assert candidate(prefecture) == True false_prefectures = ['ニューヨーク州', 'カリフォルニア州', '上海市', 'パリ', 'ロンドン', 'シンガポール', 'バンコク', 'シドニー'] for location in false_prefectures: assert candidate(location) == False

is_japan_prefecture

en/51

import math def calculate_coin_change(N: int, bill: int) -> int: """ Calculates the amount of change that is generated when paying for an item worth N yen using the specified banknote. argument: N (int): Product price. bill (int): The amount of banknotes to be used (e.g. 1000 yen, 5000 yen, 10000 yen, etc.). Return value: int: Amount of change (less than 1000 yen). Usage example: >>> calculate_coin_change(1200, 1000) 800 >>> calculate_coin_change(2500, 1000) 500 """

num_of_bills = math.ceil(N / bill) total_paid = num_of_bills * bill change = total_paid - N coin_change = change % 1000 return coin_change

def check(candidate): assert candidate(1200, 1000) == 800 assert candidate(2500, 1000) == 500 assert candidate(3000, 1000) == 0 assert candidate(4500, 2000) == 500 assert candidate(9999, 5000) == 1 assert candidate(1000, 1000) == 0 assert candidate(1, 10000) == 999 assert candidate(1500, 2000) == 500

calculate_coin_change

en/52

import math def lcm(a, b): """Function to find the least common multiple of two integers""" return a * b // math.gcd(a, b) def find_next_fireworks_time(N: int, periods: list) -> int: """ A function that calculates the next time all fireworks will go off at the same time. Parameters: N (int): Number of fireworks periods (list): List of firing periods for each fireworks Return value: int: Time when all fireworks will be launched at the same time """

result = periods[0] for i in range(1, N): result = lcm(result, periods[i]) return result

def check(candidate): assert candidate(3, [3, 5, 7]) == 105 assert candidate(2, [4, 6]) == 12 assert candidate(4, [2, 3, 4, 5]) == 60 assert candidate(5, [1, 1, 1, 1, 1]) == 1 assert candidate(3, [10, 20, 30]) == 60 assert candidate(2, [6, 8]) == 24 assert candidate(3, [11, 13, 17]) == 2431 assert candidate(1, [9]) == 9 assert candidate(3, [15, 25, 35]) == 525

find_next_fireworks_time

en/53

import math def can_measure_water(X: int, Y: int, Z: int) -> bool: """ A function that determines whether bucket A has a capacity of X liters, bucket B has a capacity of Y liters, and can measure Z liters of water. argument: X (int): Capacity of bucket A Y (int): Capacity of bucket B Z (int): amount of water you want to measure Return value: bool: True if Z liters can be measured, False if not. Usage example: >>> can_measure_water(3, 5, 4) True >>> can_measure_water(2, 6, 5) False >>> can_measure_water(1, 2, 3) True """

# ZがXとYを合わせた容量を超える場合は測定不能 if Z > X + Y: return False # ZリットルがXリットルとYリットルの最大公約数で割り切れるか確認 return Z % math.gcd(X, Y) == 0

def check(candidate): assert candidate(3, 5, 4) == True assert candidate(2, 6, 5) == False assert candidate(1, 2, 3) == True assert candidate(8, 12, 20) == True assert candidate(8, 12, 25) == False assert candidate(7, 5, 3) == True assert candidate(7, 5, 0) == True assert candidate(7, 5, 12) == True assert candidate(7, 5, 13) == False

can_measure_water

en/54

def check_olympic_year(year: int) -> bool: """ A function that checks whether the year is the year in which the Olympics were held in Japan. argument: year (int): year to check Return value: bool: True if the year the Olympics were held in Japan, False otherwise. Usage example: >>> check_olympic_year(1964) True >>> check_olympic_year(2000) False >>> check_olympic_year(2021) True """

olympic_years = {1964, 1972, 1998, 2021} return year in olympic_years

def check(candidate): assert candidate(1964) == True assert candidate(1972) == True assert candidate(1998) == True assert candidate(2021) == True assert candidate(2000) == False assert candidate(2016) == False assert candidate(2024) == False

check_olympic_year

en/55

def is_seven_gods(god_name: str) -> bool: """ Returns True if it is the name of the Seven Lucky Gods. >>> is_seven_gods("恵比寿") True >>> is_seven_gods("大黒天") True >>> is_seven_gods("阿弥陀如来") False """

seven_gods = ["恵比寿", "大黒天", "毘沙門天", "弁財天", "福禄寿", "寿老人", "布袋"] return god_name in seven_gods

def check(candidate): assert candidate("恵比寿") == True assert candidate("大黒天") == True assert candidate("毘沙門天") == True assert candidate("弁財天") == True assert candidate("福禄寿") == True assert candidate("寿老人") == True assert candidate("布袋") == True assert candidate("阿弥陀如来") == False assert candidate("釈迦") == False assert candidate("観音") == False assert candidate("不動明王") == False

is_seven_gods

en/56

def next_pigeon_clock_time(current_hour: int, interval: int) -> int: """ Calculate the next time the cuckoo clock will ring. argument: current_hour (int): current time (0 <= current_hour < 24) interval (int): Ringing interval (0 <= interval < 24) Return value: int: next time to ring (0 <= int < 24) Execution example: >>> next_pigeon_clock_time(14, 3) 17 >>> next_pigeon_clock_time(23, 1) 0 >>> next_pigeon_clock_time(22, 5) 3 >>> next_pigeon_clock_time(0, 24) 0 >>> next_pigeon_clock_time(12, 12) 0 """

next_hour = (current_hour + interval) % 24 return next_hour

def check(candidate): assert candidate(14, 3) == 17 assert candidate(23, 1) == 0 assert candidate(22, 5) == 3 assert candidate(0, 24) == 0 assert candidate(12, 12) == 0 assert candidate(6, 18) == 0 assert candidate(15, 10) == 1 assert candidate(23, 25) == 0 assert candidate(0, 1) == 1

next_pigeon_clock_time

en/57

def can_hanako_see_fireworks(A: int, B: int, C: int, D: int) -> bool: """ Determine whether Hanako can watch the fireworks display. - A (int): Start date of the fireworks display (number of days from today, afternoon). - B (int): End date of the fireworks display (number of days from today, afternoon). - C (int): Hanako's arrival date (number of days from today, morning). - D (int): The day Hanako leaves (number of days from today, morning). >>> can_hanako_see_fireworks(2, 4, 1, 3) True >>> can_hanako_see_fireworks(2, 4, 0, 2) False >>> can_hanako_see_fireworks(1, 5, 3, 6) True """

return C <= B and D > A

def check(candidate): assert candidate(2, 4, 1, 3) == True assert candidate(1, 5, 3, 6) == True assert candidate(2, 4, 0, 5) == True assert candidate(2, 4, 0, 2) == False assert candidate(3, 5, 0, 3) == False assert candidate(1, 2, 3, 4) == False assert candidate(2, 3, 4, 5) == False

can_hanako_see_fireworks

en/58

import datetime def get_tokyo_seijinshiki_date(year: int) -> str: """ Finds the coming-of-age ceremony date in Tokyo for the specified year. argument: year (int): year Return value: str: Date of coming-of-age ceremony (YYYY-MM-DD format) Usage example: >>> get_tokyo_seijinshiki_date(2024) '2024-01-08' """

# 指定された年の1月1日を取得 first_january = datetime.date(year, 1, 1) # 第1月曜日を計算 first_monday = first_january + datetime.timedelta(days=(7 - first_january.weekday()) % 7) # 第2月曜日を計算 seijin_shiki_date = first_monday + datetime.timedelta(days=7) return seijin_shiki_date.strftime('%Y-%m-%d')

def check(candidate): assert candidate(2024) == "2024-01-08" assert candidate(2023) == "2023-01-09" assert candidate(2025) == "2025-01-13" assert candidate(2022) == "2022-01-10" assert candidate(2020) == "2020-01-13"

get_tokyo_seijinshiki_date

en/59

def find_number_of_apples(n: int, price: int) -> int: """ Find the number of apples purchased if a total of n apples and oranges are purchased and the total price is price yen. Apples cost 250 yen each, and oranges cost 120 yen each. argument: n (int): Total number of apples and oranges purchased price (int): total price Return value: int: Number of apples purchased. example: >>> find_number_of_apples(2, 370) 1 >>> find_number_of_apples(1, 250) 1 """

for x in range(n + 1): if 250 * x + 120 * (n - x) == price: return x return -1

def check(candidate): assert candidate(1, 250) == 1 assert candidate(1, 120) == 0 assert candidate(2, 370) == 1 assert candidate(5, 860) == 2 assert candidate(9, 1470) == 3 assert candidate(20, 3700) == 10

find_number_of_apples

en/60

def mouse_population(n: int) -> int: """ In January, the parent mouse gave birth to 12 children, and the total number of children was 14. From February onwards, every rat gives birth to 12 pups, so the number of rats each month is 13 times that of the previous month. argument: n (int): Month number (nth month) Return value: int: total number of rats in month n Execution example: >>> mouse_population(1) 14 >>> mouse_population(2) 98 >>> mouse_population(3) 686 >>> mouse_population(4) 4802 """

return 2*7**n

def check(candidate): assert candidate(1) == 14 assert candidate(2) == 98 assert candidate(3) == 686 assert candidate(4) == 4802 assert candidate(5) == 33614 assert candidate(6) == 235298 assert candidate(12) == 27682574402

mouse_population

en/61

import datetime def get_weekday(date: str) -> str: """ A function that returns the day of the week that corresponds to a given date. argument: date (str): date (yyyy-mm-dd format) Return value: str: Day of the week Usage example: >>> get_weekday("2024-01-01") '月曜日' >>> get_weekday("2024-02-14") '水曜日' """

dt = datetime.datetime.strptime(date, "%Y-%m-%d") weekdays = ["月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日", "日曜日"] return weekdays[dt.weekday()]

def check(candidate): assert candidate("2024-01-01") == "月曜日" assert candidate("2024-01-02") == "火曜日" assert candidate("2024-01-03") == "水曜日" assert candidate("2024-01-04") == "木曜日" assert candidate("2024-01-05") == "金曜日" assert candidate("2024-01-06") == "土曜日" assert candidate("2024-01-07") == "日曜日" assert candidate("2024-02-14") == "水曜日" assert candidate("2024-12-31") == "火曜日"

get_weekday

en/62

def find_b_paper_size(width: int, height: int) -> str: """ Determines the size of paper with the given dimensions using JIS standard B version and returns it. argument: width (int): Paper width (mm) height (int): Height of paper (mm) Return value: str: B version paper size (e.g. "B2") """

b_width, b_height = 1030, 1456 for i in range(11): if (width == b_width and height == b_height) or (width == b_height and height == b_width): return f"B{i}" b_width, b_height = b_height // 2, b_width

def check(candidate): assert candidate(1030, 1456) == "B0" assert candidate(728, 1030) == "B1" assert candidate(515, 728) == "B2" assert candidate(364, 515) == "B3" assert candidate(257, 364) == "B4" assert candidate(182, 257) == "B5" assert candidate(128, 182) == "B6" assert candidate(91, 128) == "B7" assert candidate(64, 91) == "B8" assert candidate(45, 64) == "B9" assert candidate(32, 45) == "B10" assert candidate(1456, 1030) == "B0" assert candidate(1030, 728) == "B1" assert candidate(728, 515) == "B2"

find_b_paper_size

en/63

def sanmoku_winner(board: list) -> str: """ Determine the winner or loser of tic-tac-toe. Tic-tac-toe is won when three Go pieces of the same color line up vertically, horizontally, or diagonally. It is assumed that a given board always has a winner or loser. argument: board (list): A 5×5 board represented by a double list. Each element is either "黒", "白", or an empty string (""). Return value: str: "黒" or "白" to represent the winner. """

directions = [(0, 1), (1, 0), (1, 1), (1, -1)] # 横, 縦, 右下がり, 左下がり n = len(board) for row in range(n): for col in range(n): if board[row][col] in ("黒", "白"): player = board[row][col] for dr, dc in directions: if all( 0 <= row + dr * i < n and 0 <= col + dc * i < n and board[row + dr * i][col + dc * i] == player for i in range(3) ): return player

def check(candidate): # 横方向の勝利 board1 = [ ["黒", "黒", "黒", "", ""], ["", "白", "", "", ""], ["", "", "", "白", ""], ["", "", "", "", ""], ["", "", "", "", ""] ] assert candidate(board1) == "黒" # 縦方向の勝利 board2 = [ ["", "", "", "", ""], ["白", "黒", "", "", ""], ["白", "黒", "", "", ""], ["白", "黒", "", "", ""], ["", "", "", "", ""] ] assert candidate(board2) == "白" # 左下がり斜めの勝利 board3 = [ ["", "", "", "", "白"], ["", "", "", "白", ""], ["", "", "白", "", ""], ["", "黒", "", "", ""], ["黒", "", "", "", ""] ] assert candidate(board3) == "白" # 終了時の盤面が複雑なケース（横方向） board4 = [ ["黒", "黒", "黒", "白", "白"], ["白", "白", "黒", "黒", "白"], ["白", "黒", "白", "黒", "黒"], ["黒", "白", "黒", "白", "白"], ["白", "黒", "白", "白", "黒"] ] assert candidate(board4) == "黒" # 終了時の盤面が複雑なケース（縦方向） board6 = [ ["白", "黒", "白", "黒", "白"], ["白", "黒", "白", "黒", "白"], ["白", "黒", "白", "黒", "白"], ["黒", "白", "黒", "白", "黒"], ["白", "黒", "白", "黒", "白"] ] assert candidate(board6) == "白"

sanmoku_winner

en/64

def goldfish_scooping_score(fish_weights: list, poi_strength: int) -> int: """ Calculate the goldfish scooping score. Returns 0 if the sum of the weights exceeds the strength of the poi. argument: fish_weights (list of int): List of weights for each goldfish (e.g. [3, 2, 5]) poi_strength (int): Poi strength (e.g. 10) Return value: int: total score Usage example: >>> goldfish_scooping_score([3, 2, 5], 10) 10 >>> goldfish_scooping_score([3, 4, 6], 10) 0 >>> goldfish_scooping_score([2, 2, 2], 7) 6 """

total_weight = sum(fish_weights) if total_weight > poi_strength: return 0 return total_weight

def check(candidate): assert candidate([3, 2, 5], 10) == 10 assert candidate([2, 2, 2], 7) == 6 assert candidate([3, 4, 6], 10) == 0 assert candidate([4, 3, 3], 10) == 10 assert candidate([1, 1, 1], 3) == 3 assert candidate([], 10) == 0

goldfish_scooping_score

en/65

def hanako_otoshidama(before_price: int, growth_percentage: int, saving_price: int, item_price: int): """ The New Year has arrived. Hanako receives her New Year's gift. New Year's gift is the amount increased by `growth_percentage`% from the previous year's `before_price`. Hanako should determine whether she can reach the amount of money she wants for the game `item_price` by combining her savings `saving_price` with this year's New Year's gift. argument: before_price (int): Amount of New Year's gift from the previous year growth_percentage (int): Growth percentage value saving_price (int): Saving amount item_price (int): Price of the game you want Return value: str: If it can be achieved, it returns "購入可能", otherwise it returns "差額は{差額}円". """

current_otoshidama = before_price * (100 + growth_percentage) // 100 total_money = current_otoshidama + saving_price if total_money >= item_price: return "購入可能" else: return f"差額は{item_price - total_money}円"

def check(candidate): assert candidate(10000, 10, 5000, 16000) == "購入可能" assert candidate(10000, 5, 3000, 15000) == "差額は1500円" assert candidate(5000, 20, 2000, 10000) == "差額は2000円"

hanako_otoshidama

en/66

import math def calculate_folds(x: float) -> int: """ Calculate the number of folds of origami from the length of one side of a small square. argument: x (float): The length of one side of a small square. Return value: int: Number of times the origami was folded n. """

n = math.log2(1 / x) return int(n)

def check(candidate): assert candidate(0.5) == 1 assert candidate(0.25) == 2 assert candidate(0.125) == 3 assert candidate(0.0625) == 4 assert candidate(1) == 0 assert candidate(0.03125) == 5 assert candidate(0.015625) == 6

calculate_folds

en/67

def calculate_and_check_caffeine(logs): """ A record of the drinks and caffeine consumed today will be provided. Check whether your daily caffeine intake exceeds 400mg. argument: logs: A list of dictionaries that record the daily caffeine intake of drinks. Each dictionary contains 'drink' (drink name) and 'caffeine_mg' (caffeine amount). Return value: 'High' if your caffeine intake exceeds 400mg 'Low' if your caffeine intake is less than 400mg """

recommended_limit = 400 total_caffeine = 0 for log in logs: total_caffeine += log['caffeine_mg'] if total_caffeine > recommended_limit: return "High" else: return "Low"

def check(candidate): logs1 = [ {'drink': 'コーヒー', 'caffeine_mg': 95}, {'drink': '紅茶', 'caffeine_mg': 40}, {'drink': 'ジュース', 'caffeine_mg': 10} ] result1 = candidate(logs1) assert result1 == "Low", f"Test 1 failed: {result1}" logs2 = [ {'drink': 'コーヒー', 'caffeine_mg': 100}, {'drink': '紅茶', 'caffeine_mg': 100}, {'drink': 'エナジードリンク', 'caffeine_mg': 100} ] result2 = candidate(logs2) assert result2 == "Low", f"Test 2 failed: {result2}" logs3 = [ {'drink': 'コーヒー', 'caffeine_mg': 200}, {'drink': '紅茶', 'caffeine_mg': 150}, {'drink': 'エナジードリンク', 'caffeine_mg': 100} ] result3 = candidate(logs3) assert result3 == "High", f"Test 3 failed: {result3}"

calculate_and_check_caffeine

en/68

from typing import List def find_best_seat_with_location(seats: List[int], current: int) -> int: """ Given a seating list and current location, Haruko searches for a seat without anyone sitting next to her. argument: seats (List[int]): Seat list (0: empty seats, 1: seated seats). current (int): Haruko's current location (seat index). Return value: int: Index of the seat to which Haruko should move (starting at 0). Returns current location if there is no need to move. """

n = len(seats) best_seat = current # 初期値は現在地 min_distance = float('inf') # 最小移動距離の初期化 for i in range(n): if seats[i] == 0: # 空席を探す # 隣が空いているか確認 left_empty = (i == 0 or seats[i - 1] == 0) right_empty = (i == n - 1 or seats[i + 1] == 0) if left_empty and right_empty: distance = abs(current - i) # 現在地からの距離 if distance < min_distance: # より近い席を探す min_distance = distance best_seat = i return best_seat

def check(candidate): assert candidate([1, 0, 0, 1, 0, 0, 1], 2) == 2 assert candidate([1, 0, 1, 1, 0, 1, 0], 5) == 5 assert candidate([1, 1, 1, 1], 0) == 0 assert candidate([0, 0, 1, 0, 0], 2) == 0 assert candidate([1, 0, 0, 0, 1], 3) == 2 assert candidate([0, 0, 0, 0, 0], 2) == 2 assert candidate([1, 1, 0, 0, 1], 2) == 2

find_best_seat_with_location

en/69

import math def calculate_number_of_trees(r: float) -> int: """ If you want to plant trees around the perimeter of a circular lake with a radius of r meters, calculate the number of trees that can be planted every 3 meters. argument: r (float): radius of the lake (meters) Return value: int: Number of trees to be planted Execution example: >>> calculate_number_of_trees(10) 20 >>> calculate_number_of_trees(5) 10 """

circumference = 2 * math.pi * r return int(circumference // 3)

def check(candidate): assert candidate(10) == 20 assert candidate(5) == 10 assert candidate(15) == 31 assert candidate(3) == 6 assert candidate(1) == 2

calculate_number_of_trees

en/70

def min_cooking_time(ingredients): """ A function that calculates the minimum time to fry tempura using two pots. argument: ingredients (list): list of ingredients for frying time Return value: int: minimum frying time Usage example: >>> min_cooking_time([2, 3, 2, 1, 4]) 7 """

# 食材の揚げ時間をソート（短い順） ingredients.sort() # 2つの鍋を使った最小時間を計算 time1 = 0 # 鍋1の時間 time2 = 0 # 鍋2の時間 for i in range(len(ingredients)): if time1 <= time2: time1 += ingredients[i] # 鍋1に食材を追加 else: time2 += ingredients[i] # 鍋2に食材を追加 return max(time1, time2) # どちらか長い方の時間が全体の時間

def check(candidate): assert candidate([2, 3, 2, 1, 4]) == 7 assert candidate([3, 3, 3, 3]) == 6 assert candidate([5]) == 5 assert candidate([1, 2, 3, 4, 5, 6]) == 12

min_cooking_time

en/71

def get_essay_by_author(author: str) -> str: """ A function that returns the three major essays related to a given author. argument: author (str): name of the author Return value: str: Titles of three major essays related to the author """

essays = { "清少納言": "枕草子", "鴨長明": "方丈記", "吉田兼好": "徒然草" } return essays.get(author)

def check(candidate): assert candidate("清少納言") == "枕草子" assert candidate("鴨長明") == "方丈記" assert candidate("吉田兼好") == "徒然草"

get_essay_by_author

en/72

def calculate_restitution_coefficient(initial_velocity: float, final_velocity: float) -> float: """ Calculate the bounce coefficient of the Ohajiki. argument: initial_velocity (float): Velocity before collision. final_velocity (float): Velocity after collision. Return value: float: bounce coefficient e (value in the range 0 to 1) Usage example: >>> calculate_restitution_coefficient(5.0, 3.0) 0.6 >>> calculate_restitution_coefficient(5.0, 0.0) 0.0 """

if initial_velocity == 0: return 0.0 return final_velocity / initial_velocity

def check(candidate): assert candidate(5.0, 3.0) == 0.6 assert candidate(5.0, 0.0) == 0.0 assert candidate(10.0, 5.0) == 0.5 assert candidate(7.0, 7.0) == 1.0

calculate_restitution_coefficient

en/73

def get_rainbow_color(wavelength: int) -> str: """ Determine the rainbow color that corresponds to the given wavelength. argument: wavelength (int): Wavelength of light in nanometers. Return value: str: Rainbow color corresponding to wavelength (string) Usage example: >>> get_rainbow_color(650) '赤' >>> get_rainbow_color(510) '緑' >>> get_rainbow_color(400) '紫' >>> get_rainbow_color(800) None """

if 620 <= wavelength <= 750: return "赤" elif 590 <= wavelength < 620: return "橙" elif 570 <= wavelength < 590: return "黄" elif 495 <= wavelength < 570: return "緑" elif 450 <= wavelength < 495: return "青" elif 430 <= wavelength < 450: return "藍" elif 380 <= wavelength < 430: return "紫" else: return None

def check(candidate): assert candidate(650) == "赤" assert candidate(610) == "橙" assert candidate(575) == "黄" assert candidate(510) == "緑" assert candidate(480) == "青" assert candidate(445) == "藍" assert candidate(400) == "紫" assert candidate(800) == None

get_rainbow_color

en/74

from typing import List, Tuple import math def calculate_arrow_distance(speed: float, angle: float) -> float: """ Calculate the flight distance from the speed and angle at which the arrow was shot. argument: speed (float): initial speed of the arrow (m/s) angle (float): Angle at which the arrow is shot (in degrees) Return value: float: Arrow flight distance (m) (2 decimal places) Execution example: >>> calculate_arrow_distance(50, 45) 255.10 >>>calculate_arrow_distance(30, 30) 79.85 """

g = 9.8 # 定数: 重力加速度（m/s^2） angle_rad = math.radians(angle) distance = (speed ** 2 * math.sin(2 * angle_rad)) / g return round(distance, 2)

def check(candidate): assert candidate(50, 45) == 255.10 assert candidate(30, 30) == 79.53 assert candidate(40, 60) == 141.39 assert candidate(20, 15) == 20.41 assert candidate(100, 45) == 1020.41

calculate_arrow_distance

en/75

def calculate_congestion_rate(max_capacity: int, current_passengers: int) -> float: """ Calculate the congestion rate of the train. argument: max_capacity (int): Train capacity (maximum capacity) current_passengers (int): Number of passengers currently on board Return value: float: Crowding rate (%) example: >>> calculate_congestion_rate(100, 120) 120.0 >>> calculate_congestion_rate(100, 50) 50.0 """

return (current_passengers / max_capacity) * 100

def check(candidate): assert candidate(100, 120) == 120.0 assert candidate(100, 50) == 50.0 assert candidate(150, 150) == 100.0 assert candidate(200, 180) == 90.0 assert candidate(300, 450) == 150.0

calculate_congestion_rate

en/76

def count_votes(votes: list) -> dict: """ Tally the voting results and calculate the number of votes for each candidate. argument: votes (list): List of voting results (list of candidate names) Return value: dict: a dictionary containing the number of votes each candidate received and the name of the winner Usage example: >>> votes = ["A", "B", "A", "C", "B", "A", "C", "B", "C", "C"] >>> count_votes(votes) {'A': 3, 'B': 3, 'C': 4, '勝者': 'C'} """

# 投票結果を集計する辞書を作成 vote_count = {} # 投票を集計 for vote in votes: if vote in vote_count: vote_count[vote] += 1 else: vote_count[vote] = 1 # 勝者を決定（得票数が同じ場合は最初の候補者を勝者とする） winner = max(vote_count, key=vote_count.get) # 結果に勝者を追加 vote_count['勝者'] = winner return vote_count

def check(candidate): assert candidate(["A", "B", "A", "C", "B", "A", "C", "B", "C", "C"]) == {'A': 3, 'B': 3, 'C': 4, '勝者': 'C'} assert candidate(["A", "A", "A", "B", "B", "C"]) == {'A': 3, 'B': 2, 'C': 1, '勝者': 'A'} assert candidate(["A", "B", "B", "C", "C", "C", "C"]) == {'A': 1, 'B': 2, 'C': 4, '勝者': 'C'} assert candidate(["X", "Y", "Y", "X", "Z", "Z", "Z"]) == {'X': 2, 'Y': 2, 'Z': 3, '勝者': 'Z'}

count_votes

en/77

def day_or_night(hour: int, solstice: str) -> str: """ Determines whether the specified time is daytime or nighttime. Consider sunrise and sunset depending on the season. - hour (int): Time (integer from 0 to 23). - solstice (str): One of "summer solstice", "winter solstice", "spring equinox", "autumn equinox". - Return value: "day" or "night". Sunrise/Sunset (hypothetical): 夏至: sunrise at 4 o'clock, sunset at 20 o'clock 冬至: Sunrise 7:00, Sunset 17:00 春分/秋分: Sunrise 6:00, Sunset 18:00 >>> day_or_night(5, "夏至") '昼' >>> day_or_night(21, "夏至") '夜' >>> day_or_night(6, "冬至") '夜' >>> day_or_night(12, "春分") '昼' >>> day_or_night(19, "秋分") '夜' """

if solstice not in ("夏至", "冬至", "春分", "秋分"): raise ValueError("solsticeは'夏至', '冬至', '春分', '秋分'のいずれかを指定してください。") # 季節ごとの日の出・日の入り時刻 if solstice == "夏至": sunrise, sunset = 4, 20 elif solstice == "冬至": sunrise, sunset = 7, 17 elif solstice in ("春分", "秋分"): sunrise, sunset = 6, 18 # 昼間か夜間を判定 return "昼" if sunrise <= hour < sunset else "夜"

def check(candidate): assert candidate(4, "夏至") == "昼" assert candidate(3, "夏至") == "夜" assert candidate(12, "夏至") == "昼" assert candidate(20, "夏至") == "夜" assert candidate(21, "夏至") == "夜" assert candidate(7, "冬至") == "昼" assert candidate(6, "冬至") == "夜" assert candidate(12, "冬至") == "昼" assert candidate(17, "冬至") == "夜" assert candidate(18, "冬至") == "夜" assert candidate(6, "春分") == "昼" assert candidate(5, "春分") == "夜" assert candidate(12, "春分") == "昼" assert candidate(18, "春分") == "夜" assert candidate(19, "春分") == "夜" assert candidate(6, "秋分") == "昼" assert candidate(5, "秋分") == "夜" assert candidate(12, "秋分") == "昼" assert candidate(18, "秋分") == "夜" assert candidate(19, "秋分") == "夜"

day_or_night

en/78

def get_japanese_holiday(month: int) -> list: """ If you enter a month, it will return a list of Japanese holidays in that month. argument: month (int): month (1-12) Return value: list: list of applicable holidays Usage example: >>> get_japanese_holiday(1) ['New Year's Day', 'Coming-of-Age Day'] >>> get_japanese_holiday(11) ['Culture Day', 'Labor Thanksgiving Day'] """

holiday_dict = { 1: ['元日', '成人の日'], # 成人の日は1月の第2月曜日 2: ['建国記念の日'], # 2月11日 3: ['春分の日'], # 春分の日は年によって変動するが、3月20日頃 4: ['昭和の日'], # 4月29日 5: ['憲法記念日', 'みどりの日', 'こどもの日'], # 5月3日, 5月4日, 5月5日 6: [], # 6月は祝日なし 7: ['海の日'], # 海の日は7月の第3月曜日 8: ['山の日'], # 山の日は8月11日 9: ['敬老の日', '秋分の日'], # 敬老の日は9月の第3月曜日、秋分の日は9月23日頃 10: ['スポーツの日'], # 10月の第2月曜日 11: ['文化の日', '勤労感謝の日'], # 11月3日, 11月23日 12: [], # 12月は祝日なし } return holiday_dict.get(month, [])

def check(candidate): assert candidate(1) == ['元日', '成人の日'] # 1月 assert candidate(2) == ['建国記念の日'] # 2月 assert candidate(3) == ['春分の日'] # 3月 assert candidate(4) == ['昭和の日'] # 4月 assert candidate(5) == ['憲法記念日', 'みどりの日', 'こどもの日'] # 5月 assert candidate(7) == ['海の日'] # 7月 assert candidate(8) == ['山の日'] # 8月 assert candidate(9) == ['敬老の日', '秋分の日'] # 9月 assert candidate(10) == ['スポーツの日'] # 10月 assert candidate(11) == ['文化の日', '勤労感謝の日'] # 11月 assert candidate(6) == [] # 6月 assert candidate(12) == [] # 12月

get_japanese_holiday

en/79

def check_yakudoshi(age: int, gender: str) -> str: """ Based on age and gender, it determines whether the age is in bad year, mae-yaku, or after-yaku. argument: age (int): Age to judge gender (str): gender ('male' or 'female') Return value: str: One of the ”厄年”, ”前厄”, ”後厄”, or "厄年ではない" Usage example: >>> check_yakudoshi(25, '女性') '前厄' >>> check_yakudoshi(33, '女性') '厄年' >>> check_yakudoshi(37, '男性') '後厄' >>> check_yakudoshi(40, '男性') '厄年ではない' """

male_yakudoshi = { '前厄': [24, 40, 60], '厄年': [25, 41, 61], '後厄': [26, 42, 62] } female_yakudoshi = { '前厄': [18, 32, 36], '厄年': [19, 33, 37], '後厄': [20, 34, 38] } if gender == '男性': yakudoshi_dict = male_yakudoshi elif gender == '女性': yakudoshi_dict = female_yakudoshi for yakutype, ages in yakudoshi_dict.items(): if age in ages: return yakutype return '厄年ではない'

def check(candidate): # 1. 男性のテスト assert candidate(24, '男性') == '前厄' # 前厄 assert candidate(25, '男性') == '厄年' # 厄年 assert candidate(26, '男性') == '後厄' # 後厄 assert candidate(40, '男性') == '前厄' # 前厄 assert candidate(41, '男性') == '厄年' # 厄年 assert candidate(42, '男性') == '後厄' # 後厄 assert candidate(30, '男性') == '厄年ではない' # どの厄年にも該当しない # 2. 女性のテスト assert candidate(18, '女性') == '前厄' # 前厄 assert candidate(19, '女性') == '厄年' # 厄年 assert candidate(20, '女性') == '後厄' # 後厄 assert candidate(32, '女性') == '前厄' # 前厄 assert candidate(33, '女性') == '厄年' # 厄年 assert candidate(34, '女性') == '後厄' # 後厄 assert candidate(25, '女性') == '厄年ではない' # どの厄年にも該当しない

check_yakudoshi

en/80

def binary_search_count(numbers, x): """ Hanako and Taro are enjoying a number guessing game. Hanako creates a sequence of numbers arranged in ascending order and determines the secret number. Taro guesses the secret number while performing a binary search. Please calculate how many times Taro can guess the secret number. argument: numbers (list): a sequence of numbers arranged in ascending order x (int): secret number Return value: count (int): Number of times it takes Taro to guess the secret number example: >>> binary_search_count([1, 3, 5, 7, 9], 5) 1 >>> binary_search_count([1, 3, 5, 7, 9], 7) 2 >>> binary_search_count([1, 3, 5, 7, 9], 2) 3 """

left, right = 0, len(numbers) - 1 count = 0 while left <= right: count += 1 mid = (left + right) // 2 if numbers[mid] == x: return count elif numbers[mid] < x: left = mid + 1 else: right = mid - 1 return count

def check(candidate): assert candidate([1, 3, 5, 7, 9], 5) == 1 assert candidate([1, 3, 5, 7, 9], 7) == 2 assert candidate([1, 3, 5, 7, 9], 2) == 3 assert candidate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1) == 3 assert candidate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10) == 4

binary_search_count

en/81

def calculate_rice_time(rice_type: str) -> int: """ A function that returns the soaking time (minutes) required to cook rice. Minimum requirements: - rice_type is one of "白米", "玄米", or "無洗米" . - If any other rice_type is specified, -1 is returned. rule: - "白米" requires 30 minutes of soaking time. - "玄米" requires soaking time of 360 minutes (6 hours). - For "無洗米", soaking time is 0 minutes (not required). argument: rice_type (str): Type of rice Return value: int: Immersion time (minutes) Usage example: >>> calculate_rice_time("白米") 30 >>> calculate_rice_time("玄米") 360 >>> calculate_rice_time("無洗米") 0 >>> calculate_rice_time("もち米") -1 """

if rice_type == "白米": return 30 elif rice_type == "玄米": return 360 # 6時間 = 360分 elif rice_type == "無洗米": return 0 else: return -1 # 不明なご飯の種類

def check(candidate): assert candidate("白米") == 30 assert candidate("玄米") == 360 assert candidate("無洗米") == 0 assert candidate("もち米") == -1 assert candidate("黒米") == -1 assert candidate("") == -1 assert candidate("WHITE") == -1 assert candidate("白") == -1 assert candidate("無洗") == -1 assert candidate("玄") == -1

calculate_rice_time

en/82

def is_mobile_phone(number: str) -> bool: """ Determine whether the given phone number is a Japanese mobile phone number. Japanese mobile phone numbers start like this: -090 - 080 -070 argument: number (str): 11-digit phone number (must start with 0) Return value: bool: Returns True if it is a mobile phone number, otherwise returns False. Usage example: >>> is_mobile_phone("09012345678") True >>> is_mobile_phone("08098765432") True >>> is_mobile_phone("07011112222") True >>> is_mobile_phone("0312345678") False >>> is_mobile_phone("0123456789") False """

if number.startswith("090") or number.startswith("080") or number.startswith("070"): return True return False

def check(candidate): # 使用例 assert candidate("09012345678") == True assert candidate("08098765432") == True assert candidate("07011112222") == True assert candidate("0312345678") == False assert candidate("0123456789") == False # 日本の携帯電話番号形式 assert candidate("09012345678") == True assert candidate("08098765432") == True assert candidate("07055556666") == True # 日本の携帯電話番号形式ではない assert candidate("0312345678") == False assert candidate("01201234567") == False assert candidate("05012345678") == False

is_mobile_phone

en/83

def hiragana_to_katakana(name: str) -> str: """ Converts the name entered in hiragana to katakana. argument: name (str): Full name entered in hiragana Return value: str: Full name converted to katakana Usage example: >>> hiragana_to_katakana('たなか たろう') 'タナカ タロウ' >>> hiragana_to_katakana('さとう じろう') 'サトウ ジロウ' >>> hiragana_to_katakana('やまだ はなこ') 'ヤマダ ハナコ' """

hiragana = ( "ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞ" "ただちぢつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽ" "まみむめもゃやゅゆょよらりるれろゎわゐゑをんゔ" ) katakana = ( "ァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾ" "タダチヂツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポ" "マミムメモャヤュユョヨラリルレロヮワヰヱヲンヴ" ) # ひらがなをカタカナに変換 return name.translate(str.maketrans(hiragana, katakana))

def check(candidate): # 基本的な使用例 assert candidate('たなか たろう') == 'タナカ タロウ' assert candidate('さとう じろう') == 'サトウ ジロウ' assert candidate('やまだ はなこ') == 'ヤマダ ハナコ' # 様々なひらがな文字列 assert candidate('きむら みさき') == 'キムラ ミサキ' assert candidate('こばやし まさひろ') == 'コバヤシ マサヒロ' assert candidate('はしもと かいと') == 'ハシモト カイト' assert candidate('まつもと さくら') == 'マツモト サクラ'

hiragana_to_katakana

en/84

def contains_fullwidth_katakana(text: str) -> bool: """ Checks whether the given string contains full-width katakana characters. Returns True if full-width katakana is included. argument: text (str): string to check Return value: bool: True if full-width katakana is included, False if not Usage example: >>> contains_fullwidth_katakana("カタカナ") True >>> contains_fullwidth_katakana("こんにちは") False >>> contains_fullwidth_katakana("Hello") False """

for char in text: if '\u30A0' <= char <= '\u30FF': return True return False

def check(candidate): assert candidate("アイウエオ") == True assert candidate("カキクケコ") == True assert candidate("ハローワールド") == True assert candidate("かたかな") == False assert candidate("カタカナ") == True assert candidate("片仮名") == False assert candidate("KATAKANA") == False assert candidate("katakana") == False

contains_fullwidth_katakana

en/85

def number_to_kanji(number: int) -> str: """ This function converts the given number into Chinese numerals and returns it. argument: number (int): number (0 <= number <= 9999) Return value: str: Numeric value expressed in Chinese numerals example: >>> number_to_kanji(0) '〇' >>> number_to_kanji(21) '二十一' >>> number_to_kanji(105) '百五' >>> number_to_kanji(9999) '九千九百九十九' """

if number == 0: return "〇" kanji_digits = "〇一二三四五六七八九" units = ["", "十", "百", "千"] kanji = "" digits = str(number) length = len(digits) for i, digit in enumerate(digits): d = int(digit) if d == 0: continue unit = units[length - i - 1] if d == 1 and unit in ["十", "百", "千"] and i == 0: kanji += unit else: kanji += kanji_digits[d] + unit return kanji

def check(candidate): assert candidate(0) == "〇" assert candidate(1) == "一" assert candidate(10) == "十" assert candidate(21) == "二十一" assert candidate(105) == "百五" assert candidate(1234) == "千二百三十四" assert candidate(9999) == "九千九百九十九"

number_to_kanji

en/86

def sum_of_kanji_numbers(S: str) -> int: """ A function that calculates the sum of the Chinese digits '1' to '9' in the string S. argument: S (str): A string containing the Chinese numerals '一二三四五六七八九'. Return value: int: Total number obtained by converting kanji numerals. example >>> sum_of_kanji_numbers(”一二三四五六七八九”) 45 """

kanji_to_number = {'一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9} return sum(kanji_to_number[char] for char in S if char in kanji_to_number)

def check(candidate): assert candidate("一二三四五六七八九") == 45 assert candidate("三五七") == 15 assert candidate("一四七") == 12 assert candidate("二二二") == 6 assert candidate("九九") == 18

sum_of_kanji_numbers

en/87

import re def parse_date(date_str: str) -> tuple: """ Converts a date string in 'YYYY年MM月DD日' format to a tuple (year, month, day). argument: date_str (str): Date string in the format 'YYYYYYYYMMMMDDD' Return value: tuple: tuple of (year, month, day) Usage example: >>> parse_japanese_date('2024年11月20日') (2024, 11, 20) """

pattern = r'(\d{4})年(\d{2})月(\d{2})日' match = re.match(pattern, date_str) if match: return tuple(map(int, match.groups()))

def check(candidate): assert candidate('2024年11月20日') == (2024, 11, 20) assert candidate('2000年01月01日') == (2000, 1, 1) assert candidate('1999年12月31日') == (1999, 12, 31)

parse_date

en/88

from typing import List def max_shiritori_chain(words: List[str]) -> int: """ Returns the chain number of how many times Shiritori lasts. Rules: - Match the last letter of the previous word with the first letter of the next word - Ends if the same word appears or if the last letter of the word ends with "n" argument: words (List[str]): list of words Return value: int: longest shiritori chain number Usage example: >>> max_shiritori_chain(["ねこ", "こたつ", "つみき", "きつね", "ねずみ"]) 5 >>> max_shiritori_chain(["りんご", "ごま", "まり", "いぬ", "ぬりえ", "えんぴつ"]) 3 >>> max_shiritori_chain(["さくら", "らいおん", "んま", "まつり"]) 1 """

if not words: return 0 chain_count = 0 seen_words = set() for i in range(len(words)): word = words[i] if word in seen_words or word[-1] == "ん": break seen_words.add(word) if i > 0 and words[i - 1][-1] != word[0]: break chain_count += 1 return chain_count

def check(candidate): assert candidate(["ねこ", "こたつ", "つみき", "きつね", "ねずみ"]) == 5 assert candidate(["りんご", "ごま", "まり", "いぬ", "ぬりえ", "えんぴつ"]) == 3 assert candidate(["りんご", "ごま", "まり", "りんご"]) == 3 assert candidate(["さくら", "らっぱ", "ぱん", "んま", "まつり"]) == 2 assert candidate(["さくら", "らいおん", "んま", "まつり"]) == 1 assert candidate(["たぬき", "きつね", "ねずみ", "みみず", "ずるい"]) == 5

max_shiritori_chain

en/89

def calculate(expression: str) -> int: """ Performs a calculation based on a kanji calculation formula and returns the result. argument: expression (str): Kanji calculation expression (e.g. "和 3 5") Return value: int: calculation result Usage example: >>> calculate("和 3 5") 8 >>> calculate("差 9 4") 5 >>> calculate("積 2 6") 12 >>> calculate("商 8 2") 4 """

# 文字列を分割して、演算の種類と数値を取得 parts = expression.split() operator, a, b = parts[0], int(parts[1]), int(parts[2]) # 漢字に対応する計算を行う if operator == "和": return a + b elif operator == "差": return a - b elif operator == "積": return a * b elif operator == "商": return a // b # 0除算は入力側の責任で防ぐ前提

def check(candidate): assert candidate("和 3 5") == 8 assert candidate("差 9 4") == 5 assert candidate("積 2 6") == 12 assert candidate("商 8 2") == 4 assert candidate("商 7 3") == 2 assert candidate("差 0 5") == -5 assert candidate("和 0 0") == 0 assert candidate("積 5 0") == 0

calculate

en/90

import re from typing import List def extract_numbers_from_text(text: str) -> List[int]: """ Extracts numbers from a given Japanese sentence and returns them as a list of integers. argument: text (str): Japanese text containing numbers. Return value: List[int]: List of extracted numbers. Execution example: >>> extract_numbers_from_text("今年の予算は500万円で、先月の売上は200万円でした。") [500, 200] >>> extract_numbers_from_text("お店には3つのリンゴがあり、4人のお客さんが来ました。") [3, 4] >>> extract_numbers_from_text("2023年は特別な年です。") [2023] >>> extract_numbers_from_text("文章に数値がありません。") [] """

numbers = re.findall(r'\d+', text) return [int(num) for num in numbers]

def check(candidate): assert candidate("今年の予算は500万円で、先月の売上は200万円でした。") == [500, 200] assert candidate("お店には3つのリンゴがあり、4人のお客さんが来ました。") == [3, 4] assert candidate("今日は5月10日で、午後2時30分に始まります。") == [5, 10, 2, 30] assert candidate("2023年は特別な年です。") == [2023] assert candidate("10人の参加者と1000枚のチケットがあります。") == [10, 1000] assert candidate("結果は3-2で勝利しました！") == [3, 2] assert candidate("文章に数値がありません。") == []

extract_numbers_from_text

en/91

def sort_in_japanese_order(words: list) -> list: """ Sorts the input word list in alphabetical order. argument: words (list): word list to be sorted Return value: list: list of words sorted alphabetically Execution example: >>> sort_in_japanese_order(["さくら", "あおい", "きく"]) ['あおい', 'きく', 'さくら'] """

return sorted(words, key=lambda word: ''.join(chr(ord(c)) for c in word))

def check(candidate): assert candidate(["さくら", "あおい", "きく"]) == ["あおい", "きく", "さくら"] assert candidate(["うみ", "えき", "あめ"]) == ["あめ", "うみ", "えき"] assert candidate(["あさひ", "あかり", "あい"]) == ["あい", "あかり", "あさひ"] assert candidate(["カタカナ", "ひらがな", "かんじ"]) == ["かんじ", "ひらがな", "カタカナ"] assert candidate(["あい", "うた", "えのき"]) == ["あい", "うた", "えのき"] assert candidate(["あかり"]) == ["あかり"]

sort_in_japanese_order

en/92

def is_matching_iroha_song(text: str) -> bool: """ A function that determines whether the given string completely matches the Iroha song. Ignore spaces and line breaks in the input string. Full text of the Iroha song (check for matches, ignoring spaces and line breaks): いろはにほへとちりぬるを わかよたれそつねならむ うゐのおくやまけふこえて あさきゆめみしえひもせす example: >>> is_matching_iroha_song("いろはにほへと ちりぬるを わかよたれそ つねならむ うゐのおくやま けふこえて あさきゆめみし えひもせす") True >>> is_matching_iroha_song("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせす") True """

iroha_song = "いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせす" cleaned_text = ''.join(char for char in text if char not in ' \n') return cleaned_text == iroha_song

def check(candidate): # いろは歌と完全に一致するケース assert candidate("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせす") == True # 改行やスペースが含まれるが、いろは歌の順番が正しいケース assert candidate("いろはにほへと ちりぬるを わかよたれそ つねならむ うゐのおくやま けふこえて あさきゆめみし えひもせす") == True assert candidate("いろはにほへと\nちりぬるを\nわかよたれそ\nつねならむ\nうゐのおくやま\nけふこえて\nあさきゆめみし\nえひもせす") == True assert candidate(" いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせす ") == True # 1文字だけ異なるケース assert candidate("いろはにほへとちりぬるをわかよたれそつねならむういのおくやまけふこえてあさきゆめみしえひもせす") == False assert candidate("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせ") == False assert candidate("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせすす") == False # 途中で大きな変更があるケース assert candidate("いろはにほへとちりぬるをわかよたれそあああむうゐのおくやまけふこえてあさきゆめみしえひもせす") == False assert candidate("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしえひもせす123") == False # 完全に異なるケース assert candidate("") == False assert candidate("あいうえおかきくけこ") == False assert candidate("いろはにほへとちりぬるを") == False

is_matching_iroha_song

en/93

def validate_aiueo_poem(prefix: str, poem: list) -> bool: """ A function that determines whether each line of an essay begins with the specified prefix character string. Args: prefix (str): The first character string of the AIUEO composition (any character string). poem (list): A list of Aiueo essays. Returns: bool: True if all lines are correct, False otherwise. example: >>> validate_aiueo_poem("あいうえお", ["あ: あさ", "い: いぬ", "う: うみ", "え: えび", "お: おかし"]) True >>> validate_aiueo_poem("さしすせそ", ["さ: さくら", "し: しろ", "す: すいか", "せ: せみ", "そ: そら"]) True >>> validate_aiueo_poem("あいうえお", ["あ: さくら", "い: いぬ", "う: うみ", "え: えび", "お: おかし"]) False """

if len(prefix) != len(poem): return False for i, line in enumerate(poem): if not line.startswith(f"{prefix[i]}: {prefix[i]}"): return False return True

def check(candidate): # 正しいあいうえお作文のチェック assert candidate("あいうえお", ["あ: あさ", "い: いぬ", "う: うみ", "え: えび", "お: おかし"]) == True assert candidate("さしすせそ", ["さ: さくら", "し: しろ", "す: すいか", "せ: せみ", "そ: そら"]) == True assert candidate("たちつてと", ["た: たぬき", "ち: ちか", "つ: つき", "て: てがみ", "と: とけい"]) == True # 誤ったあいうえお作文のチェック assert candidate("あいうえお", ["あ: さくら", "い: いぬ", "う: うみ", "え: えび", "お: おかし"]) == False assert candidate("かきくけこ", ["か: かわ", "き: きのこ", "く: くも", "け: けいこ", "こ: こねこ"]) == True assert candidate("あいうえお", ["あ: あさ", "い: いぬ", "う: うみ", "え: えび", "お: おもち"]) == True assert candidate("なにぬねの", ["な: なす", "に: にんじん", "ぬ: ぬの", "ね: ねこ", "の: ので"]) == True # 境界ケースのチェック assert candidate("あ", ["あ: あさ"]) == True assert candidate("あ", ["あ: さくら"]) == False assert candidate("あい", ["あ: あさ", "い: いぬ"]) == True assert candidate("あい", ["あ: あさ", "い: いんこ"]) == True assert candidate("あい", ["あ: いんこ", "い: いぬ"]) == False # 異なる長さのチェック assert candidate("あいうえお", ["あ: あさ", "い: いぬ", "う: うみ"]) == False assert candidate("あいう", ["あ: あさ", "い: いぬ", "う: うみ", "え: えび", "お: おかし"]) == False

validate_aiueo_poem

en/94

def contains_major_river(text: str) -> bool: """ Determines whether text contains the name of one of Japan's three major rivers. Japan's three major rivers are "信濃川", "利根川", and "石狩川". argument: text (str): Character string to be evaluated. Return value: bool: True if any of the three major rivers is included, False if not. """

major_rivers = ["信濃川", "利根川", "石狩川"] return any(river in text for river in major_rivers)

def check(candidate): assert candidate("昨日は信濃に行きました。") == False assert candidate("利根の流域は広いですね。") == False assert candidate("石狩地方は雪が多いです。") == False assert candidate("信濃川は日本最長の川です。") == True assert candidate("この地域では利根川が有名です。") == True assert candidate("石狩川が流れる風景は美しい。") == True assert candidate("日本には美しい川が多い。") == False assert candidate("北海道には多くの川が流れています。") == False

contains_major_river

en/95

def extract_repeated_words(words: list) -> list: """ A function that extracts only words in which the same string is repeated twice from a list of strings. Args: words (list): list of strings Returns: list: list containing only words that are repeated twice example: >>> extract_repeated_words(['いろいろ', 'たびたび', 'あかあお', 'abcabc', 'abcd', 'どきどき']) ['いろいろ', 'たびたび', 'abcabc', 'どきどき'] """

result = [word for word in words if len(word) % 2 == 0 and word[:len(word)//2] == word[len(word)//2:]] return result

def check(candidate): assert candidate(['いろいろ', 'たびたび', 'あかあお', 'かきかき', 'どきどき', 'ひるひる', 'ねるねる']) == ['いろいろ', 'たびたび', 'かきかき', 'どきどき', 'ひるひる', 'ねるねる'] assert candidate(['あかあお', 'しろくろ', 'くろしろ', 'あおあお']) == ['あおあお'] assert candidate(['あいあい', 'いいうう', 'うえうえ', 'えおえお', 'かきかき']) == ['あいあい', 'うえうえ', 'えおえお', 'かきかき'] assert candidate(['あさあさ', 'ひるひる', 'よるよる', 'ばんばん']) == ['あさあさ', 'ひるひる', 'よるよる', 'ばんばん'] assert candidate(['ぴかぴか', 'ころころ', 'すべすべ', 'つやつや']) == ['ぴかぴか', 'ころころ', 'すべすべ', 'つやつや'] assert candidate(['ふわふわ', 'もこもこ', 'さらさら', 'つるつる', 'ごろごろ']) == ['ふわふわ', 'もこもこ', 'さらさら', 'つるつる', 'ごろごろ'] assert candidate(['くるくる', 'まるまる', 'ぐるぐる', 'てくてく']) == ['くるくる', 'まるまる', 'ぐるぐる', 'てくてく'] assert candidate(['はらはら', 'どきどき', 'わくわく', 'そわそわ', 'ひやひや']) == ['はらはら', 'どきどき', 'わくわく', 'そわそわ', 'ひやひや']

extract_repeated_words

en/96

def get_hiragana(key: int, presses: int) -> str: """ Returns hiragana depending on the phone's key and number of presses. argument: key (int): Pressed key number (0-9). presses (int): Number of key presses (1 or more). Return value: str: Corresponding Hiragana character. """

key_map = { 1: ["あ", "い", "う", "え", "お"], 2: ["か", "き", "く", "け", "こ"], 3: ["さ", "し", "す", "せ", "そ"], 4: ["た", "ち", "つ", "て", "と"], 5: ["な", "に", "ぬ", "ね", "の"], 6: ["は", "ひ", "ふ", "へ", "ほ"], 7: ["ま", "み", "む", "め", "も"], 8: ["や", "ゆ", "よ"], 9: ["ら", "り", "る", "れ", "ろ"], 0: ["わ", "を", "ん"], } characters = key_map[key] index = (presses - 1) % len(characters) return characters[index]

def check(candidate): key_map = { 1: ["あ", "い", "う", "え", "お"], 2: ["か", "き", "く", "け", "こ"], 3: ["さ", "し", "す", "せ", "そ"], 4: ["た", "ち", "つ", "て", "と"], 5: ["な", "に", "ぬ", "ね", "の"], 6: ["は", "ひ", "ふ", "へ", "ほ"], 7: ["ま", "み", "む", "め", "も"], 8: ["や", "ゆ", "よ"], 9: ["ら", "り", "る", "れ", "ろ"], 0: ["わ", "を", "ん"], } for key, characters in key_map.items(): for presses in range(1, len(characters) * 2 + 1): # 各キーのリスト長の2倍までテスト expected = characters[(presses - 1) % len(characters)] result = get_hiragana(key, presses) assert result == expected

get_hiragana

en/97

def romaji_to_hiragana(romaji: str) -> str: """ Convert Hepburn-style romaji to hiragana. argument: romaji (str): Romaji to be converted (50 sounds only) Return value: str: String converted to hiragana Execution example: >>> romaji_to_hiragana("konnichiha") 'こんにちは' >>> romaji_to_hiragana("sushi") 'すし' """

romaji_map = { "a": "あ", "i": "い", "u": "う", "e": "え", "o": "お", "ka": "か", "ki": "き", "ku": "く", "ke": "け", "ko": "こ", "sa": "さ", "shi": "し", "su": "す", "se": "せ", "so": "そ", "ta": "た", "chi": "ち", "tsu": "つ", "te": "て", "to": "と", "na": "な", "ni": "に", "nu": "ぬ", "ne": "ね", "no": "の", "ha": "は", "hi": "ひ", "fu": "ふ", "he": "へ", "ho": "ほ", "ma": "ま", "mi": "み", "mu": "む", "me": "め", "mo": "も", "ya": "や", "yu": "ゆ", "yo": "よ", "ra": "ら", "ri": "り", "ru": "る", "re": "れ", "ro": "ろ", "wa": "わ", "wo": "を", "n": "ん", } i = 0 result = [] while i < len(romaji): for length in (3, 2, 1): if romaji[i:i+length] in romaji_map: result.append(romaji_map[romaji[i:i+length]]) i += length break else: result.append(romaji[i]) i += 1 return ''.join(result)

def check(candidate): assert candidate("aiueo") == "あいうえお" assert candidate("akasatana") == "あかさたな" assert candidate("hamayarawa") == "はまやらわ" assert candidate("konnichiha") == "こんにちは" assert candidate("sushi") == "すし" assert candidate("satsumaimo") == "さつまいも"

romaji_to_hiragana

en/98

def classify_japanese_characters(text: str) -> dict: """ Classifies the input string into kanji, hiragana, katakana, and other characters and returns the number of each character. argument: text (str): string to process Return value: dict: Classification results for each character type (e.g. {'漢字': 3, 'ひらがな': 5, 'カタカナ': 2, 'その他': 4}) Execution example: >>> classify_japanese_characters("今日は晴れです。") {'漢字': 3, 'ひらがな': 4, 'カタカナ': 0, 'その他': 1} """

result = {'漢字': 0, 'ひらがな': 0, 'カタカナ': 0, 'その他': 0} for char in text: if '\u4e00' <= char <= '\u9fff': result['漢字'] += 1 elif '\u3040' <= char <= '\u309f': result['ひらがな'] += 1 elif '\u30a0' <= char <= '\u30ff': result['カタカナ'] += 1 else: result['その他'] += 1 return result

def check(candidate): assert candidate("今日は晴れです。") == {'漢字': 3, 'ひらがな': 4, 'カタカナ': 0, 'その他': 1} assert candidate("あいうえおアイウエオ") == {'漢字': 0, 'ひらがな': 5, 'カタカナ': 5, 'その他': 0} assert candidate("体育の授業ではサッカーをやります。今日も元気一杯に頑張りましょう。") == {'漢字': 12, 'ひらがな': 15, 'カタカナ': 4, 'その他': 2} assert candidate("ABC123!@#漢字ひらがなカタカナ") == {'漢字': 2, 'ひらがな': 4, 'カタカナ': 4, 'その他': 9}

classify_japanese_characters

en/99

def can_create_henohenomoheji(text: str) -> bool: """ By rearranging the given string `text`, determine whether it is possible to create ``Henohenomoheji''. Returns True if it can be created, False otherwise. >>> can_create_heno_heno_moheji("へのへのもへじ") True >>> can_create_heno_heno_moheji("へへへののもじ") True >>> can_create_heno_heno_moheji("へのへのへのへ") False """

required_characters = {"へ": 3, "の": 2, "も": 1, "じ": 1} for char, count in required_characters.items(): if text.count(char) < count: return False return True

def check(candidate): assert candidate("へのへのもへじ") == True assert candidate("へへへののもじ") == True assert candidate("へのへのへのへ") == False assert candidate("へのへへもじの") == True assert candidate("へへへもももじ") == False assert candidate("はひふへほのほ") == False

can_create_henohenomoheji