task_id stringlengths 4 6 | category stringclasses 8
values | prompt stringlengths 152 1.03k | canonical_solution stringlengths 18 1.32k | test stringlengths 135 1.21k | entry_point stringlengths 2 37 |
|---|---|---|---|---|---|
EN/0 | 文化 | 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)... | eto_from_year |
EN/1 | 文化 | 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(mon... | 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 ca... | create_monthly_message |
EN/2 | 文化 | 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) == "先勝"
asser... | get_rokuyou |
EN/3 | 文化 | 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... | 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: ['山の日'], # 山... | 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... | get_japanese_holiday |
EN/4 | 文化 | def check_season(seasons: list, target: str) -> str:
"""
Determines whether the given season is included in the given list.
argument:
seasons (list): list of seasons (e.g. ['Spring', 'Summer', 'Autumn', 'Winter'])
target (str): Season to judge (e.g. 'summer')
Return value:
str: Returns "含ま... | if target in seasons:
return '含まれている'
return '含まれていない'
| def check(candidate):
assert candidate(['春', '夏', '秋', '冬'], '夏') == '含まれている'
assert candidate(['春', '秋'], '秋') == '含まれている'
assert candidate(['夏'], '夏') == '含まれている'
assert candidate(['春', '秋'], '夏') == '含まれていない'
assert candidate(['冬'], '秋') == '含まれていない'
assert candidate(['あ', 'い', 'う', 'え', '... | check_season |
EN/5 | 文化 | def count_particles(text: str) -> int:
"""
Create a function that counts the number of occurrences of particles (``ga'', ``no'', ``ha'', ``wo'', and ``ni'') in Japanese sentences.
argument:
text (str): Japanese text
Return value:
int: Number of particle occurrences
Usage example:
>>> ... | particles = ['が', 'の', 'は', 'を', 'に']
count = 0
for particle in particles:
count += text.count(particle)
return count
| def check(candidate):
assert candidate("私は学校に行きます。") == 2
assert candidate("今日の天気は良いです。") == 2
assert candidate("AIは世界を変える。") == 2
assert candidate("がががののははをを") == 9
assert candidate("これは助詞が含まれていません。") == 2
| count_particles |
EN/6 | 文化 | from typing import List, Dict
def count_emoji_occurrences(text: str, emoji_list: List[str]) -> Dict[str, int]:
"""
Counts the number of occurrences of an emoji in the given text, based on the specified list of emoji.
argument:
text (str): input text
emoji_list (List[str]): List of emojis to count
... | emoji_counts = {emoji: 0 for emoji in emoji_list} # 指定された絵文字をすべて0で初期化
for char in text:
if char in emoji_counts:
emoji_counts[char] += 1
return emoji_counts
| def check(candidate):
assert candidate("🍎🍏🍎🍇🍉🍉🍎", ["🍎", "🍉", "🍇"]) == {'🍎': 3, '🍉': 2, '🍇': 1}
assert candidate("🎉🎉🎉🎂🎂🎂🎂", ["🎉", "🎂", "🎈"]) == {'🎉': 3, '🎂': 4, '🎈': 0}
assert candidate("🌟✨💫🌟🌟✨", ["🌟", "✨", "💫"]) == {'🌟': 3, '✨': 2, '💫': 1}
assert candidate("", ["🎉", "�... | count_emoji_occurrences |
EN/7 | 文化 | from typing import List
def parse_taiko_rhythm(rhythm_string: str) -> List[int]:
"""
Parses the string representing the Japanese drum rhythm, converts each rhythm symbol to the corresponding number of beats, and returns it as a list.
The Japanese drum rhythm consists of the following symbols:
- 'ドン': ... | # リズム記号と拍数の対応辞書
note_durations = {
'ドン': 4,
'ドコ': 2,
'ツク': 1
}
# 入力文字列を空白で分割し、対応する拍数をリストにする
beats = [note_durations[note] for note in rhythm_string.split()]
return beats
| def check(candidate):
assert candidate('ドン ドコ ツク ドコ ドン') == [4, 2, 1, 2, 4]
assert candidate('ドコ ドコ ドン ツク ツク ドン') == [2, 2, 4, 1, 1, 4]
assert candidate('ドン ドン ドン') == [4, 4, 4]
assert candidate('ツク ツク ツク ツク') == [1, 1, 1, 1]
assert candidate('ドコ ドン') == [2, 4]
assert candidate('ドン') == [4]
| parse_taiko_rhythm |
EN/8 | 文化 | def count_dango(s: str) -> int:
"""
Count the dango "o" contained in the string s.
argument:
s (str): string to check
Return value:
int: number of dumplings
Execution example:
>>> count_dango("oo-oo-oo-o-")
7
>>> count_dango("oo-o-o-oo-")
6
... | return s.count('o')
| def check(candidate):
assert candidate("oo-oo-oo-o-") == 7
assert candidate("oo-o-o-oo-") == 6
assert candidate("o-o-o-o-o-") == 5
assert candidate("ooo-ooo-o-") == 7
assert candidate("o-oo-o-o-") == 5
| count_dango |
EN/9 | 文化 | import re
def is_haiku(haiku: str) -> bool:
"""
Determines whether the given string is in 5-7-5 haiku form.
Note:
Inputs other than hiragana do not need to be considered.
Also, one hiragana character is counted as one sound.
argument:
haiku (str): Hiragana string separ... | parts = haiku.split()
if len(parts) != 3:
return False
syllable_count = [len(re.findall(r'[ぁ-ん]', part)) for part in parts]
return syllable_count == [5, 7, 5]
| def check(candidate):
assert candidate("はるかぜや どこかへとんだ ふうせんが") == True
assert candidate("ふるいけや かわずとびこむ みずのおと") == True
assert candidate("しずけさや いわにしみいる せみのこえ") == True
assert candidate("なつくさや つわものどもが ゆめのあと") == True
assert candidate("ふるいけ かわず みず") == False
assert candidate("はる かぜや どこ かへとん だふうせ んが"... | is_haiku |
EN/10 | 文化 | 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 = ["投... | 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(ca... | missing_positions |
EN/11 | 文化 | 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 (... | # 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... | 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},
... | judo_match_winner |
EN/12 | 文化 | 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_gea... | 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 can... | check_kendo_gear |
EN/13 | 文化 | 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")
'月曜日... | 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")... | get_weekday |
EN/14 | 文化 | def weight_needed_for_sumo(height: int, current_weight: int) -> tuple:
"""
From your height and current weight, calculate the amount of weight gain needed to reach the average BMI of a sumo wrestler.
If the sumo wrestler's average BMI is 33, returns the target weight and required weight gain.
argument:... | 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)... | weight_needed_for_sumo |
EN/15 | 文化 | 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... | 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(... | calculate_mission_success |
EN/16 | 文化 | 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 ("砂糖", "塩", "酢", "醤油", "mis... | condiments = {
"さ": "砂糖",
"し": "塩",
"す": "酢",
"せ": "醤油",
"そ": "味噌"
}
return condiments.get(hiragana)
| def check(candidate):
assert candidate("さ") == "砂糖"
assert candidate("し") == "塩"
assert candidate("す") == "酢"
assert candidate("せ") == "醤油"
assert candidate("そ") == "味噌"
| get_condiment_by_hiragana |
EN/17 | 文化 | 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 ... | 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(["うに", "いくら", "いくら", "たこ", "た... | rank_sushi_ingredients |
EN/18 | 文化 | 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:... | 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/19 | 文化 | 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).... | 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/20 | 文化 | 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
ass... | is_seven_gods |
EN/21 | 文化 | 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)... | 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(
... | def check(candidate):
# 横方向の勝利
board1 = [
["黒", "黒", "黒", "", ""],
["", "白", "", "", ""],
["", "", "", "白", ""],
["", "", "", "", ""],
["", "", "", "", ""]
]
assert candidate(board1) == "黒"
# 縦方向の勝利
board2 = [
["", "", "", "", ""],
["白", "... | sanmoku_winner |
EN/22 | 文化 | 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_str... | 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/23 | 文化 | 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/24 | 文化 | 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", "aut... | if solstice not in ("夏至", "冬至", "春分", "秋分"):
raise ValueError("solsticeは'夏至', '冬至', '春分', '秋分'のいずれかを指定してください。")
# 季節ごとの日の出・日の入り時刻
if solstice == "夏至":
sunrise, sunset = 4, 20
elif solstice == "冬至":
sunrise, sunset = 7, 17
elif solstice in ("春分", "秋分"):
sunrise, s... | 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, "冬至") == "昼... | day_or_night |
EN/25 | 文化 | from typing import List
def are_all_kites_high_enough(heights: List[float], threshold: float) -> bool:
"""
Determine whether the height of all kites is greater than or equal to a threshold.
argument:
heights (List[float]): Current height of each kite (m)
threshold (float): Threshold for fl... | return all(height >= threshold for height in heights)
| def check(candidate):
assert candidate([10.0, 12.5, 9.0], 5.0) == True
assert candidate([3.0, 6.0, 2.0], 5.0) == False
assert candidate([7.0, 8.0, 9.0], 6.0) == True
assert candidate([3.0, 5.0], 5.0) == False
assert candidate([10.0, 10.5, 11.0], 10.0) == True
| are_all_kites_high_enough |
EN/26 | 文化 | from typing import List
def karaoke_score_with_grade(target: List[int], actual: List[int]) -> str:
"""
Calculates the pitch accuracy score in karaoke and assigns grades.
Compare the ideal pitch list (target) and the pitch list for singing (actual),
Returns a score according to the proportion of matchin... | # 一致している音程の数をカウント
match_count = sum(1 for t, a in zip(target, actual) if t == a)
# スコアをパーセンテージで計算
score_percentage = (match_count / len(target)) * 100
# 成績を判定
if score_percentage >= 90:
grade = "S"
elif score_percentage >= 80:
grade = "A"
elif score_percentage >= 70:
... | def check(candidate):
assert candidate([60, 62, 64, 65, 67], [60, 62, 64, 65, 67]) == "S"
assert candidate([60, 62, 64, 65, 67], [60, 62, 63, 65, 67]) == "A"
assert candidate([60, 62, 64, 65, 67, 68, 69], [60, 61, 64, 64, 67, 68, 69]) == "B"
assert candidate([60, 62, 64, 65, 67], [60, 61, 64, 65, 66]) =... | karaoke_score_with_grade |
EN/27 | 文化 | def translate_thank_you(language_code):
"""
Translate "ありがとう" by specifying the language code.
Args:
language_code (str): ISO 639-1 language code
(Example: "ja", "en", "ru", "fr", "ko", "es", "de", "it", "zh", "ar")
Returns:
str: Translation of "ありがとう" into the specified langua... | translations = {
"ja": "ありがとう", # 日本語
"en": "Thank you", # 英語
"ru": "Спасибо", # ロシア語
"fr": "Merci", # フランス語
"ko": "감사합니다", # 韓国語
"es": "Gracias", # スペイン語
"de": "Danke", # ドイツ語
"it": "Grazie", ... | def check(candidate):
assert candidate("ja") == "ありがとう"
assert candidate("en") == "Thank you"
assert candidate("es") == "Gracias"
assert candidate("fr") == "Merci"
assert candidate("de") == "Danke"
assert candidate("it") == "Grazie"
assert candidate("zh") == "谢谢"
assert candidate("ko") =... | translate_thank_you |
EN/28 | 文化 | def check_ichiju_sansai(menu):
"""
Determine whether the menu satisfies the format of one soup and three dishes.
argument:
menu (dict): menu
{"汁物": list of str, "主菜": list of str, "副菜": list of str}
Return:
bool: True if it satisfies the format of one soup and three dishes,... | if set(menu.keys()) != {"汁物", "主菜", "副菜"}:
return False
if len(menu["汁物"]) == 1 and len(menu["主菜"]) == 1 and len(menu["副菜"]) == 2:
return True
return False
| def check(candidate):
assert candidate({"汁物": ["味噌汁"], "主菜": ["焼き魚"], "副菜": ["おひたし", "漬物"]}) == True
assert candidate({"汁物": ["豚汁"], "主菜": ["煮物"], "副菜": ["おひたし", "ポテトサラダ"]}) == True
assert candidate({"汁物": ["味噌汁"], "主菜": ["焼き魚"], "副菜": ["おひたし"]}) == False
assert candidate({"汁物": ["味噌汁"], "主菜": ["焼き魚"]})... | check_ichiju_sansai |
EN/29 | 文化 | 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:... | def check(candidate):
key_map = {
1: ["あ", "い", "う", "え", "お"],
2: ["か", "き", "く", "け", "こ"],
3: ["さ", "し", "す", "せ", "そ"],
4: ["た", "ち", "つ", "て", "と"],
5: ["な", "に", "ぬ", "ね", "の"],
6: ["は", "ひ", "ふ", "へ", "ほ"],
7: ["ま", "み", "む", "め", "も"],
8: ["や",... | get_hiragana |
EN/30 | 文化 | def calculate_congestion_rate(max_capacity: int, current_passengers: int) -> float:
"""
Calculate the congestion rate of the train.
Arguments:
max_capacity (int): Train capacity (maximum capacity)
current_passengers (int): Number of passengers currently on board
Return:
float: ... | 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/31 | 風習 | 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 ... | 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) == "長月"
asser... | get_izumo_traditional_month_name |
EN/32 | 風習 | def calculate_remaining_bill(total_bill: int, boss_bills: list, other_members_count: int) -> int:
"""
A function that splits the 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
... | 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) == ... | calculate_remaining_bill |
EN/33 | 風習 | 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 whethe... | 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/34 | 風習 | 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 Fals... | 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/35 | 風習 | 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): ... | 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):
... | def check(candidate):
assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすまで") == 0
assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすまだ") == 1
assert candidate("君が代は千代に百千代に細石の巌となりて苔のむすまで") == 1
assert candidate("君が代は千代に八千代に細石の巌となり苔のむすまで") == 1
assert candidate("君が代は千代に八千代に細石の巌となりて苔のむすま") == 1
assert candidate("君が代... | corrections_needed |
EN/36 | 風習 | def is_correct_hinamatsuri_order(dolls: list) -> bool:
"""
Given the correct order of the dolls for Hinamatsuri, create a function to determine whether the input order is correct.
Argument:
- dolls (list): the order of the dolls
Return:
- bool: True if correct, False if incorrect
Example:... | correct_order = ["お内裏様", "お雛様", "三人官女", "五人囃子", "随身", "仕丁"]
return dolls == correct_order
| def check(candidate):
assert candidate(["お内裏様", "お雛様", "三人官女", "五人囃子", "随身", "仕丁"]) == True
assert candidate(["お雛様", "お内裏様", "三人官女", "五人囃子", "仕丁", "随身"]) == False
assert candidate(["お雛様", "お内裏様", "三人官女", "五人囃子", "随身", "仕丁"]) == False
assert candidate(["お内裏様", "お雛様", "随身", "三人官女", "五人囃子", "仕丁"]) == False... | is_correct_hinamatsuri_order |
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
Usa... | 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... | get_ehou_direction |
EN/38 | 風習 | def is_keigo(text: str) -> bool:
"""
A function that determines whether the input sentence is honorific language (ending in "ます" or "です").
argument:
text (str): Japanese text
Return value:
bool: Returns True if the sentence is honorific (ending with "ます" or "です"), otherwise returns false.
... | if text.endswith('ます。') or text.endswith('です。'):
return True
return False
| def check(candidate):
assert candidate("私は学校に行きます。") == True
assert candidate("今日はいい天気だね。") == False
assert candidate("お手伝いさせていただきます。") == True
assert candidate("昨日の天気は悪かった。") == False
assert candidate("今日は天気がいいです。") == True
assert candidate("彼は走るのが早い。") == False
assert candidate("AIは進化しています... | is_keigo |
EN/39 | 風習 | def count_hashi_pair(s: str) -> int:
"""
Counts the number of chopsticks (two chopsticks make a set) in the string s.
Args.
s (str): string
Return.
int: Number of chopsticks
Ex.
>>> count_hashi_pair(""||-|-|||-"")
3
"""
| count = s.count("|")
return count // 2
| def check(candidate):
assert candidate("||-|-|||-") == 3
assert candidate("|||-|-|") == 2
assert candidate("-|---|") == 1
assert candidate("|-||-|") == 2
assert candidate("|||||") == 2
| count_hashi_pair |
EN/40 | 風習 | from typing import List
def calculate_total_beans(ages: List[int]) -> int:
"""
Calculate the number of beans that the whole family will eat.
Assume that each family member eats as many beans as their age.
argument:
ages (List[int]): List of ages of each family member.
Return value:
... | return sum(ages)
| def check(candidate):
assert candidate([10, 15, 20]) == 45
assert candidate([5, 8, 13]) == 26
assert candidate([1, 2, 3, 4]) == 10
assert candidate([30, 25, 15]) == 70
assert candidate([7, 6, 5, 4]) == 22
| calculate_total_beans |
EN/41 | 風習 | 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)... | 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/42 | 風習 | 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 ("グー",... |
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 ... | judge_janken |
EN/43 | 風習 | def convert_to_japanese_time(hour: int, minute: int) -> str:
"""
A function that converts the time (hour, minute) in 24-hour notation to Japanese notation for AM/PM.
argument:
hour (int): Time in 24-hour notation (0 <= hour < 24)
minute (int): minute (0 <= minute < 60)
Return value:
str: J... | if 0 <= hour < 12: # 午前
meridian = "午前"
display_hour = hour if hour != 0 else 0 # 0時はそのまま0時
else: # 午後
meridian = "午後"
display_hour = hour - 12 if hour != 12 else 12 # 12時はそのまま12時
return f"{meridian}{display_hour}時{minute}分"
| def check(candidate):
assert candidate(0, 0) == '午前0時0分'
assert candidate(0, 15) == '午前0時15分'
assert candidate(11, 59) == '午前11時59分'
assert candidate(12, 0) == '午後12時0分'
assert candidate(12, 30) == '午後12時30分'
assert candidate(23, 59) == '午後11時59分'
assert candidate(14, 30) == '午後2時30分'
as... | convert_to_japanese_time |
EN/44 | 風習 | 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:
- ... | # 春の七草のリスト
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
a... | identify_nanakusa |
EN/45 | 風習 | 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, ... | 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/46 | 風習 | 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, ... | 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 ca... | sort_koinobori |
EN/47 | 風習 | 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):
大吉 > 中吉 > 小吉 > 吉 > 末吉 > 凶 > 大凶
... | 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 '良い... | def check(candidate):
assert candidate("吉", "大吉") == '良い'
assert candidate("大吉", "小吉") == '悪い'
assert candidate("中吉", "中吉") == '変化なし'
assert candidate("凶", "吉") == '良い'
assert candidate("大凶", "大吉") == '良い'
assert candidate("大吉", "大凶") == '悪い'
assert candidate("末吉", "末吉") == '変化なし'
assert... | compare_fortunes |
EN/48 | 風習 | 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:
>>> de... | 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]) == '引き分け'
asser... | determine_winner |
EN/49 | 風習 | 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_seiji... | # 指定された年の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/50 | 風習 | 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 "厄年ではない"
... |
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 == '女性':
... | def check(candidate):
# 1. 男性のテスト
assert candidate(24, '男性') == '前厄' # 前厄
assert candidate(25, '男性') == '厄年' # 厄年
assert candidate(26, '男性') == '後厄' # 後厄
assert candidate(40, '男性') == '前厄' # 前厄
assert candidate(41, '男性') == '厄年' # 厄年
assert candidate(42, '男性') == '後厄' # 後厄
assert c... | check_yakudoshi |
EN/51 | 風習 | 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 soaki... | 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... | calculate_rice_time |
EN/52 | 風習 | 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, ... | # 食材の揚げ時間をソート（短い順）
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... | 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/53 | 風習 | from datetime import datetime
def generate_work_message(start_time: str, end_time: str) -> str:
"""
A function that generates a message after work based on the start and end times.
Arguments:
start_time (str): Start time of work (HH:MM format)
end_time (str): End time of work (HH:MM format)
R... | start = datetime.strptime(start_time, "%H:%M")
end = datetime.strptime(end_time, "%H:%M")
work_duration = (end - start).seconds / 3600 # 勤務時間（時間単位）
if work_duration >= 8:
return "お疲れ様でした。ゆっくり休んでください。"
else:
return "お疲れ様でした。明日もがんばりましょう。"
| def check(candidate):
assert candidate("09:00", "18:00") == "お疲れ様でした。ゆっくり休んでください。"
assert candidate("09:00", "16:30") == "お疲れ様でした。明日もがんばりましょう。"
assert candidate("08:00", "16:00") == "お疲れ様でした。ゆっくり休んでください。"
assert candidate("10:00", "15:00") == "お疲れ様でした。明日もがんばりましょう。"
assert candidate("11:00", "19:00")... | generate_work_message |
EN/54 | 風習 | from datetime import datetime, timedelta
def calculate_bedtime(wake_up_time: str, sleep_duration: str) -> str:
"""
Calculates the time you should go to bed to get the desired amount of sleep.
Arguments:
- wake_up_time (str): Time you want to wake up in the morning (e.g. ‘07:30’)
- sleep_durati... | wake_up_time_obj = datetime.strptime(wake_up_time, "%H:%M")
sleep_hours, sleep_minutes = map(int, sleep_duration.split(':'))
sleep_duration_obj = timedelta(hours=sleep_hours, minutes=sleep_minutes)
bed_time_obj = wake_up_time_obj - sleep_duration_obj
return bed_time_obj.strftime("%H:%M")
| def check(candidate):
assert candidate("07:30", "8:00") == "23:30"
assert candidate("07:30", "8:30") == "23:00"
assert candidate("18:00", "7:30") == "10:30"
assert candidate("18:15", "7:30") == "10:45"
assert candidate("09:00", "7:00") == "02:00"
assert candidate("10:00", "7:00") == "03:00"
... | calculate_bedtime |
EN/55 | 風習 | def can_all_family_wait(times, num_people):
"""
A function to determine whether the Aoki family can all wait in line at a restaurant.
The waiting time is (number of people until they enter the restaurant) * 30 minutes.
Arguments:
- times (list): List of acceptable waiting times (in minutes... | wait_time = num_people * 30
for time in times:
if time < wait_time:
return False
return True
| def check(candidate):
assert candidate([60, 90, 120], 1) == True
assert candidate([60, 90, 120], 2) == True
assert candidate([60, 90, 120], 3) == False
assert candidate([60, 90, 120], 4) == False
assert candidate([120, 120, 120], 4) == True
assert candidate([120, 150, 150], 4) == True
assert... | can_all_family_wait |
EN/56 | 風習 | def evaluate_score(score: int) -> str:
"""
Grades will be evaluated based on the points given.
Performance evaluation criteria:
- 80 points or more: "良"
- 60 points or more but less than 80 points: "可"
- Less than 60 points: "不可"
argument:
score (int): Input score (0-100)
Retu... | if score >= 80:
return "良"
elif score >= 60:
return "可"
else:
return "不可"
| def check(candidate):
assert candidate(85) == "良"
assert candidate(75) == "可"
assert candidate(45) == "不可"
assert candidate(60) == "可"
assert candidate(80) == "良"
assert candidate(59) == "不可"
assert candidate(100) == "良"
assert candidate(0) == "不可"
| evaluate_score |
EN/57 | 日本地理 | 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 L... | 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 can... | calculate_yamanote_distance |
EN/58 | 日本地理 | 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 i... | japan_prefectures = [
'北海道', '青森県', '岩手県', '宮城県', '秋田県', '山形県', '福島県',
'茨城県', '栃木県', '群馬県', '埼玉県', '千葉県', '東京都', '神奈川県',
'新潟県', '富山県', '石川県', '福井県', '山梨県', '長野県',
'岐阜県', '静岡県', '愛知県', '三重県',
'滋賀県', '京都府', '大阪府', '兵庫県', '奈良県', '和歌山県',
'鳥取県', '島根県', '岡山県', '広島県', '山口県',... | def check(candidate):
true_prefectures = [
'東京都', '大阪府', '北海道', '福岡県', '沖縄県', '青森県',
'岩手県', '宮城県', '秋田県', '山形県', '福島県', '茨城県',
'栃木県', '群馬県', '埼玉県', '千葉県', '神奈川県',
'新潟県', '富山県', '石川県', '福井県', '山梨県',
'長野県', '岐阜県', '静岡県', '愛知県', '三重県',
'滋賀県', '京都府', '兵庫県', '奈良県', '和歌... | is_japan_prefecture |
EN/59 | 日本地理 | 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 = ["信濃川", "利根川", "石狩川"]
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 candidat... | contains_major_river |
EN/60 | 日本地理 | def get_region(prefecture: str) -> str:
"""
Accepts a Japanese prefecture name as input and returns the corresponding region name.
If a prefecture that does not exist is entered, "Unknown" is returned.
>>> get_region('北海道')
'北海道地方'
>>> get_region('秋田県')
'東北地方'
"""
| regions = {
"北海道地方": ["北海道"],
"東北地方": ["青森県", "岩手県", "宮城県", "秋田県", "山形県", "福島県"],
"関東地方": ["茨城県", "栃木県", "群馬県", "埼玉県", "千葉県", "東京都", "神奈川県"],
"中部地方": ["新潟県", "富山県", "石川県", "福井県", "山梨県", "長野県", "岐阜県", "静岡県", "愛知県"],
"近畿地方": ["三重県", "滋賀県", "京都府", "大阪府", "兵庫県", "奈良県", "和歌山県"],
... | def check(candidate):
assert candidate("北海道") == "北海道地方"
assert candidate("秋田県") == "東北地方"
assert candidate("福島県") == "東北地方"
assert candidate("東京都") == "関東地方"
assert candidate("茨城県") == "関東地方"
assert candidate("愛知県") == "中部地方"
assert candidate("石川県") == "中部地方"
assert candidate("大阪府") == ... | get_region |
EN/61 | 日本地理 | def is_in_tokyo(ward: str) -> bool:
"""
A function that determines whether it is in Tokyo's 23 wards.
argument:
ward (str): Ward name to be judged.
Return value:
bool: True if the argument is the name of Tokyo's 23 wards, False otherwise.
example:
>>> is_in_tokyo("新宿区")
True
>... | tokyo_23_wards = {
"千代田区", "中央区", "港区", "新宿区", "文京区", "台東区", "墨田区", "江東区",
"品川区", "目黒区", "大田区", "世田谷区", "渋谷区", "中野区", "杉並区",
"豊島区", "北区", "荒川区", "板橋区", "練馬区", "足立区", "葛飾区", "江戸川区"
}
return ward in tokyo_23_wards
| def check(candidate):
assert candidate("新宿区") == True
assert candidate("渋谷区") == True
assert candidate("港区") == True
assert candidate("千代田区") == True
assert candidate("江戸川区") == True
assert candidate("横浜市") == False
assert candidate("大阪市") == False
assert candidate("札幌市") == False
as... | is_in_tokyo |
EN/62 | 日本地理 | def get_hottest_location(temperature_data):
"""
Given city and temperature data, returns the city with the highest temperature.
argument:
temperature_data (dict): Dictionary of cities and their temperature data.
Return value:
str: Name of the city with the highest temperature.
Exe... | return max(temperature_data, key=lambda location: temperature_data[location])
| def check(candidate):
assert candidate({"新宿区": 35.5, "大阪市": 34.0, "福岡市": 36.2}) == "福岡市"
assert candidate({"横浜市": 29.8, "京都市": 33.1, "神戸市": 32.7}) == "京都市"
assert candidate({"仙台市": 25.3, "長野市": 24.1, "高松市": 26.0}) == "高松市"
assert candidate({"金沢市": 31.2}) == "金沢市"
assert candidate({"富山市": -5.0, "秋田市"... | get_hottest_location |
EN/63 | 日本地理 | 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
... | 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("新潟") == "新潟県"
ass... | append_administrative_unit |
EN/64 | 日本地理 | def is_tokaido_shinkansen_nobori(stations: list) -> str:
"""
Determines whether the specified station on the Tokaido Shinkansen is an '上り' (東京-bound) or '下り' (新大阪-bound) station.
This function takes a list of stations, which consists of different stations for the departure and arrival stations.
It retur... | tokaido_shinkansen_stations = [
"東京", "品川", "新横浜", "小田原", "熱海", "三島", "新富士", "静岡", "掛川", "浜松",
"豊橋", "三河安城", "名古屋", "岐阜羽島", "米原", "京都", "新大阪"
]
start_station, end_station = stations[0], stations[1]
if start_station not in tokaido_shinkansen_stations or end_station not in tokaido_shi... | def check(candidate):
assert candidate(["新大阪", "東京"]) == "上り"
assert candidate(["東京", "新大阪"]) == "下り"
assert candidate(["名古屋", "東京"]) == "上り"
assert candidate(["静岡", "名古屋"]) == "下り"
assert candidate(["京都", "新大阪"]) == "下り"
assert candidate(["品川", "新横浜"]) == "下り"
assert candidate(["掛川", "豊橋"])... | is_tokaido_shinkansen_nobori |
EN/65 | 日本地理 | def is_japan_three_views(place: str) -> bool:
"""
Determine whether the specified place name is one of the three most scenic places in Japan.
>>> is_japan_three_views(""松島"")
True
>>> is_japan_three_views(""天橋立"")
True
>>> is_japan_three_views(""宮島"")
True
>>> is_japan_three_views("... | japan_three_views = {"松島", "天橋立", "宮島"}
return place in japan_three_views
| def check(candidate):
assert candidate("松島") == True
assert candidate("天橋立") == True
assert candidate("宮島") == True
assert candidate("富士山") == False
assert candidate("東京タワー") == False
assert candidate("琵琶湖") == False
assert candidate("屋久島") == False
assert candidate("沖縄") == False
| is_japan_three_views |
EN/66 | 日本地理 | def is_prefectural_capital(city: str) -> bool:
"""
Determines whether the specified city is the capital of the prefecture.
Argument:
city (str): City name
Return:
bool: True if the capital of the prefecture, False otherwise
Ex:
>>> is_prefectural_capital("東京")
True
>>> is_pref... | prefectural_capitals = {
"札幌", "青森", "盛岡", "仙台", "秋田", "山形", "福島", "水戸", "宇都宮", "前橋",
"さいたま", "千葉", "東京", "横浜", "新潟", "富山", "金沢", "福井", "甲府", "長野",
"岐阜", "静岡", "名古屋", "津", "大津", "京都", "大阪", "神戸", "奈良", "和歌山",
"鳥取", "松江", "岡山", "広島", "山口", "徳島", "高松", "松山", "高知", "福岡",
"佐賀", "... | def check(candidate):
assert candidate("東京") == True
assert candidate("渋谷") == False
assert candidate("北海道") == False
assert candidate("札幌") == True
assert candidate("津") == True
assert candidate("大津") == True
assert candidate("高松") == True
assert candidate("埼玉") == False
assert cand... | is_prefectural_capital |
EN/67 | 文化 | def check_olympic_year(year: int) -> bool:
"""
A function that checks whether it 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:
... | 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/68 | 文化 | 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/69 | 文化 | 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
... | 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... | convert_wareki_to_seireki |
EN/70 | 日本語処理 | def convert_to_manyo_gana(text: str) -> str:
"""
A function that converts a given string to Manyogana.
Convert each Hiragana character to its Manyogana counterpart. Here, we will perform a temporary and simple conversion.
For example, 「あ」is「安」、「い」is「以」、「う」is「宇」.
argument:
text (str... | hira_to_manyo = {
'あ': '安', 'い': '以', 'う': '宇', 'え': '衣', 'お': '於',
'か': '加', 'き': '幾', 'く': '久', 'け': '計', 'こ': '己',
'さ': '左', 'し': '之', 'す': '須', 'せ': '世', 'そ': '曽',
'た': '多', 'ち': '知', 'つ': '川', 'て': '天', 'と': '止',
'な': '奈', 'に': '仁', 'ぬ': '奴', 'ね': '祢', 'の': '乃',
... | def check(candidate):
assert candidate("あいう") == '安以宇'
assert candidate("かきくけこ") == '加幾久計己'
assert candidate("さしすせそ") == '左之須世曽'
assert candidate("たちつてと") == '多知川天止'
assert candidate("なにぬねの") == '奈仁奴祢乃'
assert candidate("はひふへほ") == '波比布部保'
assert candidate("まみむめも") == '末美武女毛'
assert cand... | convert_to_manyo_gana |
EN/71 | 風習 | 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):
いろはにほへとちりぬるを
わかよたれそつねならむ... | 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あさき... | is_matching_iroha_song |
EN/72 | 日本語処理 | 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... | 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("kataka... | contains_fullwidth_katakana |
EN/73 | 日本語処理 | def next_katakana(char: str) -> str:
"""
A function that returns the character following the specified character in a katakana table.
If the specified character is the last character ('ン'), it will return to the first character ('a').
argument:
char (str): 1 character katakana
Return value:
... | katakana_list = ['ア', 'イ', 'ウ', 'エ', 'オ',
'カ', 'キ', 'ク', 'ケ', 'コ',
'サ', 'シ', 'ス', 'セ', 'ソ',
'タ', 'チ', 'ツ', 'テ', 'ト',
'ナ', 'ニ', 'ヌ', 'ネ', 'ノ',
'ハ', 'ヒ', 'フ', 'ヘ', 'ホ',
'マ', 'ミ', 'ム', 'メ... | def check(candidate):
assert candidate("ア") == 'イ'
assert candidate("カ") == 'キ'
assert candidate("ヲ") == 'ン'
assert candidate("ン") == 'ア'
assert candidate("ソ") == 'タ'
assert candidate("ヨ") == 'ラ'
assert candidate("ン") == 'ア'
assert candidate("ホ") == 'マ'
assert candidate("ワ") == 'ヲ'
| next_katakana |
EN/74 | 日本語処理 | def replace_katakana(s, replacement):
"""
Replaces katakana characters in the given string s with the specified string replacement.
argument:
s (str): Target string.
replacement (str): String used for replacement.
Return value:
str: String resulting from replacing katakana.
... | return "".join(replacement if "ァ" <= char <= "ン" or char == "ヴ" else char for char in s)
| def check(candidate):
assert candidate("カタカナとひらがな", "*") == "****とひらがな"
assert candidate("カタカナ", "!") == "!!!!"
assert candidate("ひらがなと漢字", "?") == "ひらがなと漢字"
assert candidate("漢字とカタカナ", "#") == "漢字と####"
assert candidate("あアイいうウえエオお", "+") == "あ++いう+え++お"
| replace_katakana |
EN/75 | 日本語処理 | def calculate_katakana_percentage(text: str) -> float:
"""
A function that calculates the percentage of katakana in a text.
Arguments:
text (str): Japanese text
Return value:
float: Percentage of katakana (to one decimal place)
Example:
>>> calculate_katakana_percentage("コンピュータ")
... | if len(text) == 0:
return 0.0
total_chars = len(text)
katakana_count = sum(1 for char in text if '\u30a0' <= char <= '\u30ff')
percentage = (katakana_count / total_chars) * 100
return round(percentage, 1)
| def check(candidate):
assert candidate("コンピュータ") == 100.0
assert candidate("カタカナとひらがな") == 44.4
assert candidate("カタカナと漢字") == 57.1
assert candidate("あア阿んン") == 40.0
assert candidate("カタカナトひらがなト漢字") == 50.0
assert candidate("漢字のみ") == 0.0
| calculate_katakana_percentage |
EN/76 | 日本語処理 | def convert_katakana_to_halfwidth(text: str) -> str:
"""
You are given a text (text) composed of hiragana and katakana syllabary characters.
Create a function that converts all katakana characters in the text to half-width characters.
Rules:
- Keep hiragana and already half-width katakana chara... |
fullwidth = "アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン"
halfwidth = "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜｦﾝ"
return text.translate(str.maketrans(fullwidth, halfwidth))
| def check(candidate):
assert candidate("あいうえおアイウエオ") == "あいうえおｱｲｳｴｵ"
assert candidate("ワヲンわをん") == "ﾜｦﾝわをん"
assert candidate("カタカナ ひらがな") == "ｶﾀｶﾅ ひらがな"
assert candidate("アイウエオ アイウエオ") == "ｱｲｳｴｵ ｱｲｳｴｵ"
assert candidate("ワヲン ワヲン") == "ﾜｦﾝ ﾜｦﾝ"
assert candidate("ｱｲｳｴｵ") == "ｱｲｳｴｵ"
assert candi... | convert_katakana_to_halfwidth |
EN/77 | 日本語処理 | def is_two_char_shiritori_valid_katakana(words: list) -> bool:
"""
A function that determines whether or not the rules for two-character shiritori using katakana are satisfied.
Returns True if the two-character shiritori is valid, and False otherwise.
Rules:
- The “last two characters” of each word... | for i in range(len(words) - 1):
if len(words[i]) < 2 or len(words[i + 1]) < 2:
return False
if words[i][-2:] != words[i + 1][:2]:
return False
return True
| def check(candidate):
assert candidate(["シリトリ", "トリクチ", "クチバシ", "バショ"]) == True
assert candidate(["トマト", "マトリョーシカ", "シカイ", "カイガラ"]) == True
assert candidate(["キツツキ", "ツキアカリ", "カリモノ", "モノオキ"]) == True
assert candidate(["タヌキ", "キツネ", "ネコ", "コイヌ"]) == False
assert candidate(["ネコ", "コタツ", "ツミキ", "キノコ"])... | is_two_char_shiritori_valid_katakana |
EN/78 | 日本語処理 | def katakana_to_romaji(name: str) -> str:
"""
This function takes the furigana for the name ‘name’ and converts it to full-width capital letters.
Ex:
>>> katakana_to_romaji("タナカ")
'TANAKA'
"""
| katakana_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... | def check(candidate):
assert candidate("アオキ") == "AOKI"
assert candidate("カネコ") == "KANEKO"
assert candidate("スズキ") == "SUZUKI"
assert candidate("タナカ") == "TANAKA"
assert candidate("ニシダ") == "NISHIDA"
assert candidate("フジモト") == "FUJIMOTO"
assert candidate("ミウラ") == "MIURA"
assert candid... | katakana_to_romaji |
EN/79 | 日本語処理 | def encode_shift(s: str):
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
This function takes a string encoded with the encode_shift function as an argument and returns the decoded string.
"""
| return "".join([chr(((ord(ch) - ord("a") - 5) % 26) + ord("a")) for ch in s]) | from random import randint, choice
import string
import copy
def check(candidate):
letters = string.ascii_lowercase
for _ in range(50):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_shift(str)
assert candidate(copy.deepcopy(encoded_str)) == str
| decode_shift |
EN/80 | 日本語処理 | from collections import Counter
def most_frequent_katakana(text: str) -> str:
"""
A function that returns the most frequent katakana character in a string.
It ignores hiragana and kanji characters in the string and only counts katakana.
Arguments:
text (str): A string containing hiragana, katakana ... | katakana = [ch for ch in text if 'ア' <= ch <= 'ン']
if not katakana:
return ""
counter = Counter(katakana)
most_frequent = counter.most_common(1)[0][0]
return most_frequent
| def check(candidate):
assert candidate("ひらがな") == ""
assert candidate("カタカナ") == "カ"
assert candidate("漢字") == ""
assert candidate("アアイアイウアイウエアイウエオ") == "ア"
assert candidate("アイイウウエエオ") == "イ"
assert candidate("ひらがなやカタカナや漢字を含む") == "カ"
assert candidate("ヒラガナヤ片仮名ヤカンジヲフクム") == "ヤ"
| most_frequent_katakana |
EN/81 | 日本語処理 | def determine_winner(names: list) -> str:
"""
In a game involving 佐藤, 鈴木, and 高橋, calculate the score for each player from the given list of names,
and return the player with the highest score.
Calculation method for score:
- Total number of katakana + (total number of unique katakana * 10) - (... | katakana = "アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン"
def calculate_score(name: str) -> int:
""" 名前から得点を計算する """
count_katakana = sum(1 for char in name if char in katakana) # 片仮名の総数
unique_katakana = len(set(char for char in name if char in katakana)) # 重複なしの片仮名の総数
... | def check(candidate):
assert candidate(['アイウエオ', 'アアアアアア', 'あアいイウエオ']) == '佐藤'
assert candidate(['アアウウオオ', 'アイウエオ', 'アアアアアア']) == '鈴木'
assert candidate(['アイウエオ', 'アアアアアア', 'アイウエオアイウエオ']) == '高橋'
| determine_winner |
EN/82 | 日本語処理 | 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_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": "ね",... | 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/83 | 日本語処理 | def extract_hiragana(text: str) -> str:
"""
A function that extracts and returns only hiragana from a string `text`.
argument:
text (str): input string
Return value:
str: String with only hiragana extracted
Example:
>>> extract_hiragana("こんにちは。")
'こんにちは'
>>> extract_hiragana("... | return ''.join(char for char in text if 'ぁ' <= char <= 'ん')
| def check(candidate):
assert candidate("") == ''
assert candidate("こんにちは。") == 'こんにちは'
assert candidate("今日はいい天気ですね。") == 'はいいですね'
assert candidate("こんにちは。今日はいい天気ですね。") == 'こんにちははいいですね'
assert candidate("ひらがなカタカナ漢字") == 'ひらがな'
assert candidate("ひらがな、Hiragana、hiragana") == 'ひらがな'
| extract_hiragana |
EN/84 | 日本語処理 | from typing import List
def all_prefixes(string: str) -> List[str]:
"""
Returns a list of all prefixes, from shortest to longest, for the string given as an argument.
However, it is assumed that all character strings are in hiragana.
example:
>>> all_prefixes('Aiu')
['A', 'Ai', 'Aiu']
"""... | result = []
for i in range(len(string)):
result.append(string[:i+1])
return result
| def check(candidate):
assert candidate('') == []
assert candidate('あいうえお') == ['あ', 'あい', 'あいう', 'あいうえ', 'あいうえお']
assert candidate('ひらがな') == ['ひ', 'ひら', 'ひらが', 'ひらがな']
| all_prefixes |
EN/85 | 日本語処理 | 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(["あい", ... | sort_in_japanese_order |
EN/86 | 日本語処理 | 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(["あい", ... | sort_in_japanese_order |
EN/87 | 日本語処理 | 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("へへへのの... | 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 |
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 ... | 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_c... | def check(candidate):
assert candidate(["ねこ", "こたつ", "つみき", "きつね", "ねずみ"]) == 5
assert candidate(["りんご", "ごま", "まり", "いぬ", "ぬりえ", "えんぴつ"]) == 3
assert candidate(["りんご", "ごま", "まり", "りんご"]) == 3
assert candidate(["さくら", "らっぱ", "ぱん", "んま", "まつり"]) == 2
assert candidate(["さくら", "らいおん", "んま", "まつり"]) ==... | max_shiritori_chain |
EN/89 | 日本語処理 | 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 essa... | 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
# 誤ったあいうえお... | validate_aiueo_poem |
EN/90 | 日本語処理 | def is_valid_reverse_shiritori(words: list) -> bool:
"""
A function that determines whether a list of hiragana satisfies the reverse shiritori rules.
Gyaku-shiritori places the first letter of the previous word at the end of the next word.
argument:
words (list): list of hiragana words
Return ... | for i in range(1, len(words)):
if words[i-1][0] != words[i][-1]:
return False
return True
| def check(candidate):
assert candidate(["りんご", "ちり", "しゃち", "かし"]) == True
assert candidate(["ごりら", "りんご", "くり", "きく", "かき"]) == True
assert candidate(["らっぱ", "さら", "ささ", "せんさ"]) == True
assert candidate(["りんご", "ごりら", "らっぱ", "ぱせり"]) == False
assert candidate(["ごりら", "らっこ", "こども", "もも"]) == False
| is_valid_reverse_shiritori |
EN/91 | 日本語処理 | def hiragana_ascii_sum(s: str) -> int:
"""Takes a string of hiragana as an argument and returns the sum of the ASCII codes (Unicode code points) for hiragana characters only."""
| total_sum = 0
for char in s:
if 'ぁ' <= char <= 'ん':
total_sum += ord(char)
return total_sum
| def check(candidate):
assert candidate("あい") == 24710
assert candidate("さしすせそ") == 61885
assert candidate("あかさたな") == 61867
assert candidate("あabcい") == 24710
assert candidate("12345あい") == 24710
assert candidate("わをん") == 37300
| hiragana_ascii_sum |
EN/92 | 日本語処理 | 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_repeat... | 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(['あいあい', 'いいうう', 'うえうえ', 'えおえお', 'かきかき']) == ['あいあい', 'うえうえ', 'えおえお', 'かきかき']
... | extract_repeated_words |
EN/93 | 日本語処理 | 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('たなか たろう')
'タナカ タロウ'
>>> hi... | hiragana = (
"ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞ"
"ただちぢつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽ"
"まみむめもゃやゅゆょよらりるれろゎわゐゑをんゔ"
)
katakana = (
"ァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾ"
"タダチヂツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポ"
"マミムメモャヤュユョヨラリルレロヮワヰヱヲンヴ"
)
# ひらがなをカタカナに変換
return name.tr... | def check(candidate):
# 基本的な使用例
assert candidate('たなか たろう') == 'タナカ タロウ'
assert candidate('さとう じろう') == 'サトウ ジロウ'
assert candidate('やまだ はなこ') == 'ヤマダ ハナコ'
# 様々なひらがな文字列
assert candidate('きむら みさき') == 'キムラ ミサキ'
assert candidate('こばやし まさひろ') == 'コバヤシ マサヒロ'
assert candidate('はしもと かいと') == '... | hiragana_to_katakana |
EN/94 | 日本語処理 | 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... | 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:
... | def check(candidate):
assert candidate("今日は晴れです。") == {'漢字': 3, 'ひらがな': 4, 'カタカナ': 0, 'その他': 1}
assert candidate("あいうえおアイウエオ") == {'漢字': 0, 'ひらがな': 5, 'カタカナ': 5, 'その他': 0}
assert candidate("体育の授業ではサッカーをやります。今日も元気一杯に頑張りましょう。") == {'漢字': 12, 'ひらがな': 15, 'カタカナ': 4, 'その他': 2}
assert candidate("ABC123!@#漢字ひら... | classify_japanese_characters |
EN/95 | 日本語処理 | def sort_japanese_characters(text: str) -> str:
"""
A function that receives a string, sorts and combines hiragana, katakana, kanji, and alphabets.
argument:
text (str): input string
Return value:
str: string of characters arranged in hiragana, katakana, kanji, alphabetical order
Usage ex... | hiragana = sorted([char for char in text if 'ぁ' <= char <= 'ん'])
katakana = sorted([char for char in text if 'ァ' <= char <= 'ヶ'])
kanji = sorted([char for char in text if '一' <= char <= '龯'])
alphabet = sorted([char for char in text if 'A' <= char <= 'Z' or 'a' <= char <= 'z'])
return ''.join(hiraga... | def check(candidate):
assert candidate("ひらがな") == "がなひら"
assert candidate("カタカナ") == "カカタナ"
assert candidate("漢字") == "字漢"
assert candidate("Alphabet") == "Aabehlpt"
assert candidate("ひらがなカタカナ漢字Alphabet") == "がなひらカカタナ字漢Aabehlpt"
| sort_japanese_characters |
EN/96 | 日本語処理 | def solve(s):
"""
A string s is given.
If s[i] is hiragana or katakana, convert that character (hiragana to katakana, katakana to hiragana).
If it contains other characters, leave it as is.
If the string does not contain any hiragana or katakana characters, reverse the entire string.
The functio... | flg = 0
idx = 0
new_str = list(s)
for i in s:
if 'ぁ' <= i <= 'ん': # ひらがなをカタカナに変換
new_str[idx] = chr(ord(i) - ord('ぁ') + ord('ァ'))
flg = 1
elif 'ァ' <= i <= 'ン': # カタカナをひらがなに変換
new_str[idx] = chr(ord(i) - ord('ァ') + ord('ぁ'))
flg = 1
... | def check(candidate):
# 簡単なケースをチェック
assert candidate("あい") == "アイ"
assert candidate("1234") == "4321"
assert candidate("アカ") == "あか"
assert candidate("#あ@イ") == "#ア@い"
assert candidate("#あいウエ^45") == "#アイうえ^45"
assert candidate("#6@2") == "2@6#"
# 境界ケースをチェック
assert candidate("#$あ^カ... | solve |
EN/97 | 日本語処理 | def count_sentences(text: str) -> int:
"""
A function that counts how many Japanese sentences there are.
Sentences are defined to be separated by one of "。", "！", or "？".
argument:
text (str): input Japanese text
Return value:
int: number of sentences
Usage example:
>>> count_sent... | if not text:
return 0
sentences = [sentence for sentence in text.split('。') if sentence] # 「。」で分割
temp_sentences = []
for sentence in sentences:
temp_sentences.extend([s for s in sentence.split('！') if s]) # 「！」でさらに分割
final_sentences = []
for sentence in temp_sentences:
... | def check(candidate):
assert candidate("") == 0
assert candidate("おはようございます。") == 1
assert candidate("今日はいい天気ですね。明日も晴れるといいですね！") == 2
assert candidate("おはよう！今日は何から始めようか？") == 2
assert candidate("おはようございます。今日はいい天気ですね！明日の天気はいかがでしょうか？") == 3
| count_sentences |
EN/98 | 日本語処理 | def count_onsen_symbols(text: str) -> int:
"""
Counts and returns the number of hot spring symbols "♨️" from the input string.
Args:
text (str): input string
Returns:
int: Number of hot spring symbols “♨️”
"""
| return text.count('♨️')
| def check(candidate):
assert candidate("♨️") == 1
assert candidate("♨️♨️♨️♨️♨️") == 5
assert candidate("♨️あ♨️い♨️う♨️え♨️お♨️") == 6
assert candidate("♨️温泉に入りましょう♨️") == 2
| count_onsen_symbols |
EN/99 | 日本語処理 | def check_katakana_hiragana_match(katakana: str, hiragana: str) -> bool:
"""
A function that checks whether katakana and hiragana match.
Arguments:
katakana (str): katakana string
hiragana (str): hiragana string
Return value:
bool: True if katakana and hiragana match, False otherwi... | def katakana_to_hiragana(katakana: str) -> str:
katakana_map = {
'ア': 'あ', 'イ': 'い', 'ウ': 'う', 'エ': 'え', 'オ': 'お',
'カ': 'か', 'キ': 'き', 'ク': 'く', 'ケ': 'け', 'コ': 'こ',
'サ': 'さ', 'シ': 'し', 'ス': 'す', 'セ': 'せ', 'ソ': 'そ',
'タ': 'た', 'チ': 'ち', 'ツ': 'つ', 'テ': 'て', 'ト': ... | def check(candidate):
assert candidate("タナカ", "たなか") == True
assert candidate("スズキ", "すずき") == True
assert candidate("カッパ", "かっぱ") == True
assert candidate("タカハシ", "たかはし") == True
assert candidate("タナカ", "なかた") == False
assert candidate("サトウ", "すずき") == False
assert candidate("ガッコウ", "かっぱ") ... | check_katakana_hiragana_match |
End of preview. Expand in Data Studio
SakuraEval
Dataset Description
SakuraEval is a Japan-specific code generation benchmark dataset. It is designed independently and does not rely on translation from English benchmarks such as HumanEval or JHumanEval. The dataset is currently being reviewed for official release.
Dataset Structure
from datasets import load_dataset
load_dataset("kogi-jwu/sakuraeval", "ja")
DatasetDict({
test: Dataset({
features: ['task_id', 'category', 'prompt', 'canonical_solution', 'test', 'entry_point'],
num_rows: 164
})
})
Data Fields
- task_id: Identifier for the data sample.
- category: Task category.
- prompt: Input for the model, including the function header and docstring that describes the task.
- canonical_solution: Solution to the problem presented in the prompt.
- test: Function(s) to test the generated code for correctness.
- entry_point: Entry point function to begin testing.
Category Breakdown
| Category | Number of Tasks |
|---|---|
| 文化（Culture） | 34 |
| 風習（Customs） | 27 |
| 日本地理（Japanese Geography） | 10 |
| 公民・法律（Law and Civics） | 11 |
| 数学・科学（Math and Science） | 21 |
| 単位変換（Unit Conversion） | 11 |
| 日本語処理（Japanese Language） | 43 |
| その他（Other） | 7 |
Languages
The dataset contains coding problems in 2 natural languages: English and Japanese.
- Downloads last month
- 13