open-thought/reasoning-gym
1
0
Fork 0
mirror of https://github.com/open-thought/reasoning-gym.git synced 2026-04-19 12:58:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
reasoning-gym/reasoning_gym/arithmetic/gsm_symbolic/generators_50_99.py

3944 lines
166 KiB
Python
Raw Blame History

from fractions import Fraction
from random import Random
from typing import Any, Dict
from reasoning_gym.utils import format_number, is_integer
def generate_50(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, pieces1: int, pieces2: int) -> dict[str, Any]:
half_pieces1 = pieces1 // 2
total_pieces = half_pieces1 + pieces2
question = f"{name} finished half of a {pieces1} piece puzzle, and then started and finished another {pieces2} piece puzzle within an hour. How many puzzle pieces did {name} place during that hour?"
answer_cot = f"{name} did 1/2 * {pieces1} pieces = {half_pieces1} pieces.\n{name} completed {half_pieces1} pieces + {pieces2} pieces = {total_pieces} pieces.\n#### {total_pieces}"
return {
"question": question,
"answer": format_number(total_pieces),
"answer_cot": answer_cot,
"answer_value": total_pieces,
"variables": {
"name": name,
"puzzle1_pieces": pieces1,
"puzzle2_pieces": pieces2,
"half_puzzle1": half_pieces1,
"total_pieces": total_pieces,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Teddy", "Tommy", "Billy", "Jimmy", "Bobby", "Danny"]
name = rng.choice(names)
# Generate random puzzle sizes that are even numbers
puzzle1 = int(rng.randrange(100, int(500 * difficulty), 2))
puzzle2 = int(rng.randrange(300, int(1000 * difficulty), 2))
result = generate_from_variables(name, puzzle1, puzzle2)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_51(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
parent: str,
activity1: str,
activity2: str,
activity3: str,
cur: str,
times: int,
budget: int,
tokens: int,
cost1: int,
cost2: int,
) -> dict[str, Any]:
cost_per_ride = cost2 * times
cost_per_person = tokens + cost1 + cost_per_ride
total_people = budget // cost_per_person
friends = total_people - 1
question = f"{name}'s {parent} said that she had {cur}{budget} budgeted for her birthday party. She wants to make sure she and her friends all get to play one round of {activity1}, have {cur}{tokens} in {activity2} tokens, and get to ride the {activity3} {times}. A round of {activity1} is {cur}{cost1}. The {activity3} cost {cur}{cost2} a ride. How many friends can she invite?"
answer_cot = (
f"The {activity3} will cost {cur}{cost_per_ride} per person because {cost2} x {times} = {cost_per_ride}\n"
f"Each person costs {cur}{cost_per_person} because {tokens} + {cost1} + {cost_per_ride} = {cost_per_person}\n"
f"{total_people} total people can attend because {budget} / {cost_per_person} = {total_people}\n"
f"She can invite {friends} friends because {total_people} - 1 = {friends}\n"
f"#### {friends}"
)
return {
"question": question,
"answer": format_number(friends),
"answer_cot": answer_cot,
"answer_value": friends,
"variables": {
"name": name,
"parent": parent,
"activity1": activity1,
"activity2": activity2,
"activity3": activity3,
"currency": cur,
"times": times,
"budget": budget,
"tokens": tokens,
"cost1": cost1,
"cost2": cost2,
"cost_per_ride": cost_per_ride,
"cost_per_person": cost_per_person,
"total_people": total_people,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_female = ["Emma", "Olivia", "Sophia", "Isabella", "Mia", "Charlotte"]
parents = ["mom", "dad", "aunt", "uncle"]
activities1 = ["mini-golf", "bowling", "laser tag"]
activities2 = ["arcade", "game room", "pinball"]
activities3 = ["go-karts", "bumper cars", "roller coaster"]
currencies = ["$", "£", "€"]
times_options = [2, 3]
name = rng.choice(names_female)
parent = rng.choice(parents)
activity1 = rng.choice(activities1)
activity2 = rng.choice(activities2)
activity3 = rng.choice(activities3)
cur = rng.choice(currencies)
times = rng.choice(times_options)
tokens = int(rng.randint(3, int(11 * difficulty)))
cost1 = int(rng.randint(3, int(11 * difficulty)))
cost2 = int(rng.randint(5, int(21 * difficulty)))
# Generate budget ensuring conditions are met
cost_per_person = tokens + cost1 + (cost2 * times)
num_people = rng.randint(2, int(10 * difficulty))
budget = cost_per_person * num_people
result = generate_from_variables(
name, parent, activity1, activity2, activity3, cur, times, budget, tokens, cost1, cost2
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_52(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, alphabets: tuple, n1: str, frac: str) -> dict[str, Any]:
alphabet_name, alphabet_count = alphabets
# Calculate intermediate values
full_writes = n1 * alphabet_count
half_write = int(alphabet_count * frac)
subtotal = full_writes + half_write
final_total = subtotal * 2
question = f"{name} is learning to write and decides to keep re-writing the {alphabet_name} until she knows it. She writes it in full {n1}, writes {frac} of it once, then re-writes everything she has already written. How many letters has {name} written in total?"
answer_cot = (
f"{name} has written the {alphabet_name} {n1} time(s) which is a total of {alphabet_count} * {n1} = {full_writes} letters.\n"
f"She then writes {frac} the {alphabet_name}, which is {alphabet_count} * {frac} = {half_write} letters.\n"
f"So far, this is a total of {full_writes} + {half_write} = {subtotal} letters.\n"
f"Writing this again means she has doubled the number of letters she has written, so she has written a total of {subtotal} * 2 = {final_total} letters.\n"
f"#### {final_total}"
)
return {
"question": question,
"answer": format_number(final_total),
"answer_cot": answer_cot,
"answer_value": final_total,
"variables": {
"name": name,
"alphabet_name": alphabet_name,
"alphabet_count": alphabet_count,
"times_written": n1,
"fraction": frac,
"full_writes": full_writes,
"half_write": half_write,
"total": final_total,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_female = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte", "Amelia"]
alphabets = [
("alphabet", 26),
("hiragana (with 48 letters)", 48),
("farsi alphabet (with 32 letters)", 32),
("arabic abjad (with 28 letters)", 28),
]
multi_times = ["twice", "three times", "four times"]
fraction_alnum = ["half", "one-third", "one-fourth"]
name = rng.choice(names_female)
alphabet = rng.choice(alphabets)
n1 = rng.choice(multi_times)
frac = rng.choice(fraction_alnum)
# Convert text numbers to numeric values
n1_map = {"twice": 2, "three times": 3, "four times": 4}
frac_map = {"half": 0.5, "one-third": 1 / 3, "one-fourth": 0.25}
# Ensure division results in integer
while not is_integer(alphabet[1] * frac_map[frac]):
alphabet = rng.choice(alphabets)
result = generate_from_variables(name, alphabet, n1_map[n1], frac_map[frac])
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_53(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, sides: int, target: int, property: str) -> dict[str, Any]:
numbers_above = sides - target
prob_above = (numbers_above / sides) * 100
prob_two_in_row = 25 # probability of two even/odd in a row is always 25%
difference = int(prob_above - prob_two_in_row)
question = f"{name} is rolling a {sides}-sided die. How much more likely is it (expressed as a percentage) that he rolls a number greater than {target} than that he rolls two {property} numbers in a row?"
answer_cot = f"There are {numbers_above} numbers greater than {target} on the dice, so the chances of rolling one of them are {numbers_above} / {sides} = {prob_above}%.\nThe chance of rolling one {property} number is 50%, so the chance of rolling two in a row is 50% * 50% = 25%.\nThe difference between these two probabilities is {prob_above}% - 25% = {difference}%.\n#### {difference}"
return {
"question": question,
"answer": format_number(difference),
"answer_cot": answer_cot,
"answer_value": difference,
"variables": {
"name": name,
"sides": sides,
"target": target,
"property": property,
"numbers_above": numbers_above,
"prob_above": prob_above,
"prob_two_in_row": prob_two_in_row,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"]
properties = ["even", "odd"]
name = rng.choice(names)
property = rng.choice(properties)
dice_options = [4, 6, 8, 10, 12, 20]
sides = rng.choice(dice_options)
# Generate target ensuring conditions are met
while True:
target = rng.randint(1, sides - 1)
prob = ((sides - target) / sides) * 100
if (sides - target) % target == 0 and prob.is_integer() and prob > 25:
break
result = generate_from_variables(name, sides, target, property)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_54(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name1: str,
name2: str,
total_time: int,
library_time: int,
station_time: int,
location1: str,
location2: str,
location3: str,
) -> dict[str, Any]:
time_after_library = total_time - library_time
remaining_time = time_after_library - station_time
question = f"{name1} and {name2} have {total_time} minutes to walk to {location1} together. It takes them {library_time} minutes to get to the corner where the {location2} is. It takes them another {station_time} minutes to get to the {location3}. How much longer do they have to get to {location1} without being late?"
answer_cot = f"{name1} and {name2} arrive at the {location2} with {total_time} - {library_time} = {time_after_library} minutes left to reach the {location1}.\nThey then arrive at the {location3} and have {time_after_library} - {station_time} = {remaining_time} minutes left to get to {location1} without being late.\n#### {remaining_time}"
return {
"question": question,
"answer": format_number(remaining_time),
"answer_cot": answer_cot,
"answer_value": remaining_time,
"variables": {
"name1": name1,
"name2": name2,
"total_time": total_time,
"library_time": library_time,
"station_time": station_time,
"location1": location1,
"location2": location2,
"location3": location3,
"remaining_time": remaining_time,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Jack", "James", "William", "Michael", "David", "Joseph"]
locations = ["cinema", "mall", "library", "park", "gym", "bank", "school"]
name1, name2 = rng.sample(names, 2)
loc1, loc2, loc3 = rng.sample(locations, 3)
# Generate times ensuring they're not divisible by 5
library_time = int(rng.randint(10, int(30 * difficulty)))
while library_time % 5 == 0:
library_time = int(rng.randint(10, int(30 * difficulty)))
station_time = int(rng.randint(10, int(70 * difficulty)))
while station_time % 5 == 0:
station_time = int(rng.randint(10, int(70 * difficulty)))
# Ensure total time is greater than sum of other times
min_total = library_time + station_time + 5
total_time = int(rng.randint(min_total, int(140 * difficulty)))
while total_time % 5 == 0:
total_time = int(rng.randint(min_total, int(140 * difficulty)))
result = generate_from_variables(name1, name2, total_time, library_time, station_time, loc1, loc2, loc3)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_55(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, place: str, fruit: str, location: str, insect1: str, insect2: str, n: int, frac: str
) -> dict[str, Any]:
num_insect1 = int(n * 0.5) # half as many bugs as ants
total_insects = n + num_insect1
question = f"{name} went to their {place} to pick some {fruit} and found {frac} as many {insect1} as {insect2} in the {location}. If there were {n} {insect2}, calculate the total number of insects in the {location}."
answer_cot = f"If there were {n} {insect2}, the total number of {insect1} in the {location} is {frac} * {n} {insect2} = {num_insect1} {insect1}\nThe total number of insects in the {location} is {num_insect1} {insect1} + {n} {insect2} = {total_insects} insects\n#### {total_insects}"
return {
"question": question,
"answer": format_number(total_insects),
"answer_cot": answer_cot,
"answer_value": total_insects,
"variables": {
"name": name,
"place": place,
"fruit": fruit,
"location": location,
"insect1": insect1,
"insect2": insect2,
"n": n,
"frac": frac,
"num_insect1": num_insect1,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Dax", "Alex", "Sam", "Jordan", "Taylor", "Morgan", "Riley"]
places = ["orchard", "backyard", "greenhouse", "allotment"]
fruits = ["strawberries", "cherries", "blueberries", "raspberries"]
locations = ["garden", "field", "plot", "patch"]
insects = ["beetles", "ladybugs", "grasshoppers", "caterpillars", "bees", "wasps"]
name = rng.choice(names)
place = rng.choice(places)
fruit = rng.choice(fruits)
location = rng.choice(locations)
insect1, insect2 = rng.sample(insects, 2)
n = int(rng.randint(20, int(200 * difficulty)))
# Ensure n is even for "half as many"
if n % 2 == 1:
n += 1
result = generate_from_variables(name, place, fruit, location, insect1, insect2, n, "half")
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_56(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
family: str, item: str, total: int, n1: int, n2: int, flavor1: str, flavor2: str, flavor3: str
) -> dict[str, Any]:
n3 = total - (n1 + n2)
question = f"The {family} family is busy making {item}s. So far, they've made {total} {item}s. They have {n1} {flavor1} {item}s, {n2} {flavor2} {item}s, and some {flavor3} {item}s. How many {flavor3} {item}s have they made?"
answer_cot = f"The total number of pieces of {flavor1} and {flavor2} {item}s is {n1} + {n2} = {n1+n2}.\nTherefore, they made {total} - {n1+n2} = {n3} {flavor3} {item}s.\n#### {n3}"
return {
"question": question,
"answer": format_number(n3),
"answer_cot": answer_cot,
"answer_value": n3,
"variables": {
"family": family,
"item": item,
"total": total,
"n1": n1,
"n2": n2,
"n3": n3,
"flavor1": flavor1,
"flavor2": flavor2,
"flavor3": flavor3,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
families = ["Smith", "Johnson", "Williams", "Brown", "Jones"]
items = ["cupcake", "muffin", "brownie", "biscuit"]
flavors = ["vanilla", "strawberry", "blueberry", "lemon", "peanut butter"]
family = rng.choice(families)
item = rng.choice(items)
flavor1, flavor2, flavor3 = rng.sample(flavors, 3)
total = int(rng.randrange(5000, int(10000 * difficulty), 25))
n1 = int(rng.randint(1000, int(3000 * difficulty)))
n2 = int(rng.randint(1000, int(3000 * difficulty)))
while n1 + n2 >= total:
n1 = int(rng.randint(1000, int(3000 * difficulty)))
n2 = int(rng.randint(1000, int(3000 * difficulty)))
result = generate_from_variables(family, item, total, n1, n2, flavor1, flavor2, flavor3)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_57(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
n1: int, sport1: str, sport2: str, sport3: str, n2: int, n3: int, multiplier: int
) -> dict[str, Any]:
n_volleyball = n1 * multiplier
n_soccer = n2 + n3
total = n1 + n_volleyball + n_soccer
question = f"There are {n1} students playing {sport1} and twice that number playing {sport2}. There are {n2} boys and {n3} girls playing {sport3}. If each student only participates in one group, how many students are there in total?"
answer_cot = f"There are {n1} x {multiplier} = {n_volleyball} students playing {sport2}.\nThere are {n2} + {n3} = {n_soccer} students playing {sport3}.\nIn total there are {n1} + {n_volleyball} + {n_soccer} = {total} students.\n#### {total}"
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"tennis_players": n1,
"volleyball_players": n_volleyball,
"soccer_boys": n2,
"soccer_girls": n3,
"total_soccer": n_soccer,
"total_students": total,
"sports": [sport1, sport2, sport3],
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
sports = ["basketball", "badminton", "table tennis", "football", "volleyball"]
sport1, sport2, sport3 = rng.sample(sports, 3)
multiplier = 2 # "twice" that number
# We need: n1 * multiplier + n2 + n3 <= 250
# So: n1 * 2 + n2 + n3 <= 250
# First generate n1 with consideration for leaving room for n2 and n3
# Since n2, n3 >= 10 each, we need: n1 * 2 <= 230
max_n1 = min(int(21 * difficulty), 115) # 115 is floor(230/2)
n1 = rng.randint(4, max_n1)
# Now we know remaining space for n2 + n3
remaining_total = 250 - (n1 * multiplier)
# Calculate maximum for n2, ensuring space left for n3 (minimum 10)
max_n2 = min(int(31 * difficulty), remaining_total - 10)
if max_n2 < 10:
# If ranges are too tight, adjust n1 down and recalculate
n1 = max(4, n1 - 10)
remaining_total = 250 - (n1 * multiplier)
max_n2 = min(int(31 * difficulty), remaining_total - 10)
n2 = rng.randint(10, max(11, max_n2))
# Generate n3 with remaining space
max_n3 = min(int(31 * difficulty), remaining_total - n2)
n3 = rng.randint(10, max(11, max_n3))
result = generate_from_variables(n1, sport1, sport2, sport3, n2, n3, multiplier)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_58(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, container: str, liquid: str, volume: int, unit: str, num_containers: int, calories: int
) -> dict[str, Any]:
total_volume = volume * num_containers
total_calories = total_volume * calories
question = f"A {container} of {liquid} is {volume} {unit}s of {liquid}. {name} drinks {num_containers} {container}s of {liquid}. If {liquid} has {calories} calories per {unit} how many calories did he consume?"
answer_cot = f"He drank {volume}*{num_containers}={total_volume} {unit}s of {liquid}.\nSo he drank {total_volume}*{calories}={total_calories} calories of {liquid}\n#### {total_calories}"
return {
"question": question,
"answer": format_number(total_calories),
"answer_cot": answer_cot,
"answer_value": total_calories,
"variables": {
"name": name,
"container": container,
"liquid": liquid,
"volume": volume,
"unit": unit,
"num_containers": num_containers,
"calories": calories,
"total_volume": total_volume,
"total_calories": total_calories,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Mike", "James", "David", "Robert", "William"]
containers = ["cup", "bottle", "carton"]
liquids = ["juice", "soda", "sparkling water", "tea", "lemonade"]
units = ["ounce", "mL", "cc", "oz"]
name = rng.choice(names)
container = rng.choice(containers)
liquid = rng.choice(liquids)
unit = rng.choice(units)
volume = int(rng.randint(6, int(16 * difficulty)))
num_containers = int(rng.randint(2, int(6 * difficulty)))
calories = int(rng.randint(2, int(10 * difficulty)))
result = generate_from_variables(name, container, liquid, volume, unit, num_containers, calories)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_59(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
time_per_interval: int, distance_per_interval: int, total_distance: int
) -> dict[str, Any]:
intervals = total_distance // distance_per_interval
total_time = intervals * time_per_interval
question = f"A fog bank rolls in from the ocean to cover a city. It takes {time_per_interval} minutes to cover every {distance_per_interval} miles of the city. If the city is {total_distance} miles across from the oceanfront to the opposite inland edge, how many minutes will it take for the fog bank to cover the whole city?"
answer_cot = f"The city will be covered in {total_distance} / {distance_per_interval} = {intervals} intervals of {time_per_interval} minutes.\nThus, it will take {intervals} * {time_per_interval} = {total_time} minutes for the fog to cover the whole city.\n#### {total_time}"
return {
"question": question,
"answer": format_number(total_time),
"answer_cot": answer_cot,
"answer_value": total_time,
"variables": {
"time_per_interval": time_per_interval,
"distance_per_interval": distance_per_interval,
"total_distance": total_distance,
"intervals": intervals,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
# Start with total_distance limit and work backwards
max_total_distance = 100
# Generate num_intervals first
min_intervals = 2
max_intervals = int(20 * difficulty)
# Calculate maximum allowed distance_per_interval based on constraints:
# distance_per_interval * num_intervals <= max_total_distance
min_distance = 2
max_possible_distance = max_total_distance // min_intervals
max_distance = min(int(100 * difficulty), max_possible_distance)
if max_distance < min_distance:
# Fallback if no valid solution exists
distance_per_interval = min_distance
num_intervals = max_total_distance // distance_per_interval
else:
distance_per_interval = rng.randint(min_distance, max_distance)
# Calculate valid range for num_intervals based on chosen distance
max_valid_intervals = min(max_intervals, max_total_distance // distance_per_interval)
num_intervals = rng.randint(min_intervals, max_valid_intervals)
total_distance = distance_per_interval * num_intervals
# Generate time per interval independently since it has no constraints
time_per_interval = int(rng.randint(2, int(500 * difficulty)))
result = generate_from_variables(time_per_interval, distance_per_interval, total_distance)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_60(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, unit: str, total_dist: int, beach_dist: int, sidewalk_dist: int, speed_mult: int, beach_time: int
) -> dict[str, Any]:
beach_rate = Fraction(beach_dist, beach_time)
sidewalk_rate = beach_rate * speed_mult
sidewalk_time = int(sidewalk_dist / sidewalk_rate)
total_time = beach_time + sidewalk_time
question = f"{name} walks {total_dist} {unit}s every day on her favorite walking trail, which includes {beach_dist} {unit}s of walking on the beach and {sidewalk_dist} {unit}s of walking on the sidewalk. On the sidewalk, {name} walks at twice the rate of speed that she does on the beach. If {beach_time} minutes of her walk is spent on the beach, how long does it take for her to complete the entire {total_dist}-{unit} walk, in minutes?"
answer_cot = f"On the beach, {name} walks at a rate of {beach_dist} {unit}s per {beach_time} minutes, or {beach_dist}/{beach_time} = {beach_rate} {unit}s per minute.\nOn the sidewalk, she walks at {speed_mult} times the rate of speed as when she is on the sand, or {speed_mult} * {beach_rate} = {sidewalk_rate} {unit}s per minute.\nTo walk {sidewalk_dist} {unit}s on the sidewalk, it takes her {sidewalk_dist}÷{sidewalk_rate}={sidewalk_time} minutes.\nThus, in total, it takes {name} {beach_time}+{sidewalk_time}={total_time} minutes to walk her favorite route.\n#### {total_time}"
return {
"question": question,
"answer": format_number(total_time),
"answer_cot": answer_cot,
"answer_value": total_time,
"variables": {
"name": name,
"unit": unit,
"total_distance": total_dist,
"beach_distance": beach_dist,
"sidewalk_distance": sidewalk_dist,
"speed_multiplier": speed_mult,
"beach_time": beach_time,
"sidewalk_time": sidewalk_time,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Emma", "Sophia", "Isabella", "Olivia", "Ava", "Mia", "Emily"]
units = ["mile", "kilometer", "block"]
name = rng.choice(names)
unit = rng.choice(units)
speed_mult = 2 # Fixed as "twice" in question
# Start with beach_dist since other values depend on it
beach_dist = rng.randint(10, min(int(20 * difficulty), 15))
# Calculate beach_time to ensure it's:
# 1. Greater than beach_dist
# 2. Greater than speed_mult * beach_dist
# 3. Divisible by beach_dist
min_time = max(40, (speed_mult * beach_dist + 1)) # Must be greater than 2 * beach_dist
max_time = min(int(70 * difficulty), 65)
# Find valid multiples of beach_dist within our range
valid_times = []
for multiplier in range((min_time + beach_dist - 1) // beach_dist, (max_time // beach_dist) + 1):
candidate_time = multiplier * beach_dist
if min_time <= candidate_time <= max_time:
valid_times.append(candidate_time)
if not valid_times:
# Fallback: adjust beach_dist down and recalculate
beach_dist = max(5, beach_dist - 5)
base_multiplier = (min_time + beach_dist - 1) // beach_dist
beach_time = beach_dist * base_multiplier
else:
beach_time = rng.choice(valid_times)
# Generate sidewalk_dist last since it has fewest constraints
sidewalk_dist = rng.randint(10, min(int(20 * difficulty), 15))
total_dist = beach_dist + sidewalk_dist
result = generate_from_variables(name, unit, total_dist, beach_dist, sidewalk_dist, speed_mult, beach_time)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_61(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
location: str,
shop: str,
item1: str,
item2: str,
item3: str,
unit: str,
cur: str,
total: float,
n1: int,
n2: int,
n12: int,
k: int,
n3: int,
p1: float,
p2: float,
p3: float,
discount: float,
) -> dict[str, Any]:
# Calculate costs
item1_cost = n1 * p1 + n2 * (1 - discount) * p1 + k * p1 # Cost of item1 with discount applied
item2_cost = p2 # Cost of item2
item3_cost = n3 * p3 # Cost of item3
total_spent = int(item1_cost + item2_cost + item3_cost)
money_left = total - total_spent
question = f'{name} went to the {location} for vacation. Her parents gave her {cur}{total} to buy whatever she wanted. At the {shop}, {item1} was on sale for "Buy {n1} {unit}s at {cur}{p1} per {unit}, get {n2} {unit}s {discount} off." She scooped up {n12} {unit}s. She also bought a mixed bag of {item2} for {cur}{p2} and {n3} {item3} that were {cur}{p3} each. How much money does {name} have left?'
answer_cot = f"{item1} is {n1} {unit}s for {cur}{p1} and gets {n2} {unit}s {discount} off. So {discount} off of {n2} {unit}s is {cur}{n2*discount}*{p1} = {cur}{n2*discount*p1}. The rest of {k} {unit}s does not have discount and come at {k*p1} so total is {n1}*{p1} + {n2}*{1-discount}*{p1} + {k}*{p1} = {item1_cost}\n{n3} {item3} at {cur}{p3} each is {n3}*{p3}={cur}{n3*p3}\nWhen you add all her purchases, {cur}{item1_cost}+{cur}{p2}+{cur}{n3*p3} = {cur}{total_spent}\nShe had {cur}{total} and spent {cur}{total_spent} so she had {cur}{total}-{cur}{total_spent} = {cur}{money_left} left over\n#### {money_left}"
return {
"question": question,
"answer": format_number(money_left),
"answer_cot": answer_cot,
"answer_value": money_left,
"variables": {
"name": name,
"location": location,
"shop": shop,
"item1": item1,
"item2": item2,
"item3": item3,
"unit": unit,
"currency": cur,
"total_money": total,
"n1": n1,
"n2": n2,
"n12": n12,
"k": k,
"n3": n3,
"p1": p1,
"p2": p2,
"p3": p3,
"discount": discount,
"total_spent": total_spent,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"]
locations = ["beach", "boardwalk", "pier", "coast"]
shops = ["souvenir store", "gift shop", "beach shop", "seaside store"]
items1 = ["fudge", "saltwater taffy", "rock candy", "cotton candy"]
items2 = ["sand dollars", "starfish", "sea glass", "coral pieces"]
items3 = ["postcards", "keychains", "stickers", "pins"]
units = ["pound", "kilogram", "kg"]
currencies = ["$", "£", "€"]
fraction_nums = [0.25, 0.33, 0.5, 0.67, 0.75]
# Choose random values for strings
name = rng.choice(names_female)
location = rng.choice(locations)
shop = rng.choice(shops)
item1 = rng.choice(items1)
item2 = rng.choice(items2)
item3 = rng.choice(items3)
unit = rng.choice(units)
cur = rng.choice(currencies)
discount = rng.choice(fraction_nums[:4])
# Generate fixed prices
p2 = round(rng.uniform(11.25, 12.00), 2)
p3 = round(rng.uniform(20.25, 21.25), 2)
# Generate n1 first as it's the base for other values
n1 = int(rng.randint(15, int(18 * difficulty)))
# Generate n2 ensuring it's less than n1
n2 = int(rng.randint(4, min(n1 - 1, int(10 * difficulty))))
# Generate k ensuring 0 <= k < n1
k = int(rng.randint(2, min(n1 - 1, int(5 * difficulty))))
# Calculate n12
n12 = n1 + n2 + k
# Generate n3
n3 = int(rng.randint(11, int(19 * difficulty)))
# Generate p1 ensuring total cost is less than total budget
min_p1 = 20
max_p1 = int(24 * difficulty)
# Calculate maximum p1 that keeps total cost under budget
total = int(rng.randint(1200, int(1500 * difficulty)))
# Function to calculate total cost
def calc_total_cost(price):
return n1 * price + n2 * (1 - discount) * price + k * price + p2 + n3 * p3
# Find valid p1 values
valid_p1 = []
for p1 in range(min_p1, max_p1 + 1):
cost = calc_total_cost(p1)
if cost == int(cost) and cost < total: # Ensure integer and under budget
valid_p1.append(p1)
if not valid_p1:
# Fallback: adjust values to make it work
p1 = min_p1
# Adjust n values down if needed
while calc_total_cost(p1) >= total:
if n1 > 15:
n1 -= 1
if n2 > 4:
n2 -= 1
if k > 2:
k -= 1
if n3 > 11:
n3 -= 1
n12 = n1 + n2 + k
else:
p1 = rng.choice(valid_p1)
result = generate_from_variables(
name, location, shop, item1, item2, item3, unit, cur, total, n1, n2, n12, k, n3, p1, p2, p3, discount
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_62(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
item: str, num_slices: int, name1: str, name2: str, slices_per_day: int, multiplier: int, unit: str
) -> dict[str, Any]:
second_person_slices = slices_per_day * multiplier
total_daily_slices = slices_per_day + second_person_slices
days_lasting = num_slices // total_daily_slices
question = f"A {item} has {num_slices} {unit}. If {name1} can eat {slices_per_day} {unit} a day while {name2} can eat {multiplier} times as much, how many days will the {item} last?"
answer_cot = f"{name2} can eat {slices_per_day} x {multiplier} = {second_person_slices} {unit} a day.\nTogether, {name1} and {name2} can eat {slices_per_day} + {second_person_slices} = {total_daily_slices} {unit} a day.\nSo, a {item} will last for {num_slices}/{total_daily_slices} = {days_lasting} days.\n#### {days_lasting}"
return {
"question": question,
"answer": format_number(days_lasting),
"answer_cot": answer_cot,
"answer_value": days_lasting,
"variables": {
"item": item,
"num_slices": num_slices,
"name1": name1,
"name2": name2,
"slices_per_day": slices_per_day,
"multiplier": multiplier,
"second_person_slices": second_person_slices,
"total_daily_slices": total_daily_slices,
"unit": unit,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
items = ["pizza", "cake", "pie", "lasagna"]
units = ["pieces", "portions", "servings"]
names = ["Emma", "Liam", "Olivia", "Noah", "Ava", "Elijah", "Charlotte", "James"]
item = rng.choice(items)
unit = rng.choice(units)
name1, name2 = rng.sample(names, 2)
slices_per_day = int(rng.randint(2, int(6 * difficulty)))
multiplier = 2 # Using 'twice' as specified in original
# Ensure total is divisible by daily consumption
daily_total = slices_per_day + (slices_per_day * multiplier)
num_days = rng.randint(2, int(8 * difficulty))
num_slices = daily_total * num_days
result = generate_from_variables(item, num_slices, name1, name2, slices_per_day, multiplier, unit)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_63(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, hours: int, days: int, rate: int, bonus: int, month: str) -> dict[str, Any]:
daily_pay = hours * rate
monthly_days = days * 4
monthly_base = daily_pay * monthly_days
monthly_bonus = bonus * 4
total_pay = monthly_base + monthly_bonus
question = f"{name} works a {hours}-hour shift each day, {days} days a week. He earns ${rate} per hour and gets a ${bonus} bonus each week if the company performs well. How much money did {name} make in {month} if the company performed very well for the whole month?"
answer_cot = (
f"In a day, {name} makes {hours} * {rate} = ${daily_pay}\n"
f"If he works {days} days a week, the total number of days for the whole month is {days} * 4= {monthly_days} days.\n"
f"Since he makes ${daily_pay} per day, the total amount for the whole month is {monthly_days} * {daily_pay}= ${monthly_base}.\n"
f"He also got a {bonus} * 4 = ${monthly_bonus} bonus because the company performed well in all the weeks of {month}.\n"
f"At the end of {month}, he earned {monthly_base} + {monthly_bonus} = ${total_pay}.\n#### {total_pay}"
)
return {
"question": question,
"answer": format_number(total_pay),
"answer_cot": answer_cot,
"answer_value": total_pay,
"variables": {
"name": name,
"hours_per_day": hours,
"days_per_week": days,
"hourly_rate": rate,
"weekly_bonus": bonus,
"month": month,
"daily_pay": daily_pay,
"monthly_base": monthly_base,
"monthly_bonus": monthly_bonus,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"]
months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
]
name = rng.choice(names)
month = rng.choice(months)
hours = int(rng.randint(6, int(13 * difficulty)))
days = int(rng.randint(3, int(7 * difficulty)))
rate = int(rng.randint(8, int(31 * difficulty)))
bonus = int(rng.randint(100, int(601 * difficulty)))
# Ensure rate * hours is an integer
while (hours * rate) % 1 != 0:
rate = int(rng.randint(8, int(31 * difficulty)))
result = generate_from_variables(name, hours, days, rate, bonus, month)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_64(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, n1: int, d1: int, n2: int, d2: int) -> dict[str, Any]:
first_period = n1 * d1
second_period = n2 * d2
total_eggs = first_period + second_period
dozens = total_eggs // 12
question = f"If {name} eats {n1} eggs a day for {d1} days and then increases it to {n2} eggs a day for {d2} days, how many dozens of eggs will {name} need for {d1+d2} days?"
answer_cot = (
f"He starts off eating {n1} eggs a day for {d1} days for a total of {n1}*{d1} = {first_period} eggs\n"
f"Then he increases it to {n2} eggs a day for {d2} days for a total of {n2}*{d2} = {second_period} eggs\n"
f"All total he will eat {first_period}+{second_period} = {total_eggs} eggs\n"
f"There are 12 eggs in 1 dozen and he will eat {total_eggs} eggs which is {total_eggs}/12 = {dozens} dozen eggs\n"
f"#### {dozens}"
)
return {
"question": question,
"answer": format_number(dozens),
"answer_cot": answer_cot,
"answer_value": dozens,
"variables": {
"name": name,
"eggs_per_day_first": n1,
"days_first": d1,
"eggs_per_day_second": n2,
"days_second": d2,
"total_eggs": total_eggs,
"dozens": dozens,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Chester", "James", "John", "Robert", "Michael", "William", "David"]
name = rng.choice(names)
# Generate random values scaled by difficulty
n1 = int(rng.randint(2, int(6 * difficulty)))
n2 = int(rng.randint(4, int(8 * difficulty)))
while n2 <= n1:
n2 = int(rng.randint(4, int(8 * difficulty)))
d1 = int(rng.randint(20, int(110 * difficulty)))
d2 = int(rng.randint(20, int(110 * difficulty)))
# Ensure results are divisible by 12
while (n1 * d1 + n2 * d2) % 12 != 0:
d1 = int(rng.randint(20, int(110 * difficulty)))
d2 = int(rng.randint(20, int(110 * difficulty)))
result = generate_from_variables(name, n1, d1, n2, d2)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_65(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, fish: str, day: str, w1: int, w2: int, w3: int, n: int, unit: str, cur: str, price: float
) -> dict[str, Any]:
total = int((w1 + w2) * price + (n - 2) * w3 * price)
question = f"{name} caught {n} {fish}s last {day}, the first {fish} he caught weighs {w1} {unit}s, the second {fish} he caught weighs {w2} {unit}s, and the last {fish} he caught weighs {w3} {unit}s. If a {unit} of {fish} costs {cur}{price:.2f}, how much will he earn after selling all the {fish}s to the market?"
answer_cot = (
f"{name} will earn {w1} x {cur}{price:.2f} = {cur}{w1*price:.2f} from the first {fish}.\n"
f"He will earn {w2} x {cur}{price:.2f} = {cur}{w2*price:.2f} for the second {fish}.\n"
f"The rest of the {fish}s are {n}-2 = {n-2}. He will earn {w3} x {cur}{price:.2f} = {cur}{w3*price:.2f} per each of them. So he will earn {n-2} * {w3*price:.2f} = {(n-2)*w3*price:.2f}\n"
f"Therefore, the total amount he will earn for all the {fish}s is {cur}{w1*price:.2f} + {cur}{w2*price:.2f} + {cur}{(n-2)*w3*price:.2f}= {cur}{total}.\n#### {total}"
)
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name": name,
"fish": fish,
"day": day,
"weight1": w1,
"weight2": w2,
"weight3": w3,
"num_fish": n,
"unit": unit,
"currency": cur,
"price": price,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"]
fish = ["salmon", "cod", "trout", "steelhead"]
days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
units = ["kilogram", "pound", "kg"]
currencies = ["$", "€", "£"]
name = rng.choice(names)
fish_type = rng.choice(fish)
day = rng.choice(days)
unit = rng.choice(units)
cur = rng.choice(currencies)
w1 = int(rng.randint(40, int(80 * difficulty)))
w2 = int(rng.randint(30, int(60 * difficulty)))
w3 = int(rng.randint(20, int(40 * difficulty)))
n = int(rng.randint(3, int(8 * difficulty)))
price = round(rng.uniform(0.25, 2.5), 2)
# Ensure result is integer
while not ((w1 + w2) * price + (n - 2) * w3 * price).is_integer():
price = round(rng.uniform(0.25, 2.5), 2)
result = generate_from_variables(name, fish_type, day, w1, w2, w3, n, unit, cur, price)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_66(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
weekdays: list,
hour1: int,
hour2: int,
hour3: int,
min1: int,
min2: int,
total_hours: int,
num_wed_episodes: int,
) -> dict[str, Any]:
mon, tue, wed, thu, fri = weekdays
question = f"{name} watches TV after he finishes his homework every night. On {mon} and {tue}, he watched a {hour1}-hour episode of his favorite show each night. On {wed}, he watched a few episodes of a {min1}-minute show. On {thu}, he finished homework early and watched a {hour2}-hour episode and a {min2}-minute show. On {fri}, he got to stay up late for the weekend, so he watched two {hour3}-hour episodes. If he watched {total_hours} hours of TV in all, how many {min1}-minute episodes did he watch on {wed}?"
answer_cot = (
f"Let {wed[0]} be the number of episodes he watched on {wed}.\n"
f"After {mon}, he had {total_hours} - {hour1} = {total_hours-hour1} hours of TV left.\n"
f"After {tue}, he had {total_hours-hour1} - {hour1} = {total_hours-2*hour1} hours of TV left.\n"
f"After {thu}, he had {total_hours-2*hour1} - {hour2} - {Fraction(min2,60)} = {total_hours-2*hour1-hour2-Fraction(min2,60)} hours of TV left.\n"
f"After {fri}, he had {total_hours-2*hour1-hour2-Fraction(min2,60)} - {2*hour3} = {total_hours-2*hour1-hour2-Fraction(min2,60)-2*hour3} hours of TV left.\n"
f"Each {min1}-minute episode is {Fraction(min1,60)} hour.\n"
f"Thus, {wed[0]} = {num_wed_episodes} episodes.\n#### {num_wed_episodes}"
)
return {
"question": question,
"answer": format_number(num_wed_episodes),
"answer_cot": answer_cot,
"answer_value": num_wed_episodes,
"variables": {
"name": name,
"weekdays": weekdays,
"hour1": hour1,
"hour2": hour2,
"hour3": hour3,
"min1": min1,
"min2": min2,
"total_hours": total_hours,
"num_wed_episodes": num_wed_episodes,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"]
weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
name = rng.choice(names)
weekdays_sample = weekdays.copy() # Keep original order for this problem
hour1 = int(rng.randint(3, int(7 * difficulty)))
hour2 = int(rng.randint(2, int(7 * difficulty)))
hour3 = int(rng.randint(2, int(6 * difficulty)))
min1 = int(rng.randint(1, int(12 * difficulty))) * 5 # Ensure divisible by 5
min2 = int(rng.randint(1, int(11 * difficulty))) * 5 # Ensure divisible by 5
# Calculate num_wed_episodes to ensure total_hours works out
num_wed_episodes = int(rng.randint(1, int(8 * difficulty)))
# Calculate total hours from all components
total_hours = 2 * hour1 + hour2 + min2 / 60 + 2 * hour3 + (num_wed_episodes * min1 / 60)
result = generate_from_variables(
name, weekdays_sample, hour1, hour2, hour3, min1, min2, total_hours, num_wed_episodes
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_67(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, fruit: str, n1: int, n2: int, d1: str, d2: str, d3: str, mult: int
) -> dict[str, Any]:
first_two_days = n1 + n2
friday_amount = mult * n1
total = first_two_days + friday_amount
question = f"{name} picks {n1} {fruit}s on {d1}. Then he picks {n2} {fruit}s on {d2}. On {d3}, he picks {mult} times the number of {fruit}s he did on {d1}. How many {fruit}s does {name} have?"
answer_cot = f"Combining {d1} and {d2}, {name} has {n1} {fruit}s + {n2} {fruit}s = {first_two_days} {fruit}s.\nOn {d3}, he picks {mult} * {n1} {fruit}s = {friday_amount} {fruit}s.\nAltogether, {name} has {first_two_days} {fruit}s + {friday_amount} {fruit}s = {total} {fruit}s.\n#### {total}"
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name": name,
"fruit": fruit,
"day1_amount": n1,
"day2_amount": n2,
"day1": d1,
"day2": d2,
"day3": d3,
"multiplier": mult,
"day3_amount": friday_amount,
"total": total,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "James", "William", "Michael", "David", "Robert", "Thomas"]
fruits = ["banana", "apple", "orange", "pear", "peach", "plum"]
weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
multipliers = ["double", "triple", "quadruple"]
mult_values = {"double": 2, "triple": 3, "quadruple": 4}
name = rng.choice(names)
fruit = rng.choice(fruits)
d1, d2, d3 = rng.sample(weekdays, 3)
mult_word = rng.choice(multipliers)
mult = mult_values[mult_word]
n1 = int(rng.randint(30, int(400 * difficulty)))
n2 = int(rng.randint(50, int(400 * difficulty)))
result = generate_from_variables(name, fruit, n1, n2, d1, d2, d3, mult)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_68(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(n0: int, r: int, d: int, disease: str) -> dict[str, Any]:
# Calculate infected people after each day
day1_new = n0 * r
day1_total = n0 + day1_new
day2_new = day1_total * r
day2_total = day1_total + day2_new
day3_new = day2_total * r
day3_total = day2_total + day3_new
question = f"A {disease} infects {n0} people. Every day, each infected person infects {r} others. How many people are infected after {d} days?"
answer_cot = (
f"On the first day, the original {n0} people infect {r} people each, so {n0} * {r} = {day1_new} more people are infected.\n"
f"There are {n0} + {day1_new} = {day1_total} infected people after the first day.\n"
f"On the second day, {day1_total} * {r} = {day2_new} more people are infected.\n"
f"There are {day1_total} + {day2_new} = {day2_total} infected people after the second day.\n"
f"On the third day, {day2_total} * {r} = {day3_new} more people are infected. Therefore, there are {day2_total} + {day3_new} = {day3_total} infected people after three days.\n"
f"#### {day3_total}"
)
return {
"question": question,
"answer": format_number(day3_total),
"answer_cot": answer_cot,
"answer_value": day3_total,
"variables": {"initial_infected": n0, "infection_rate": r, "days": d, "disease_type": disease},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
diseases = ["virus", "bacteria", "parasite", "infection"]
disease = rng.choice(diseases)
d = 3 # Fixed at 3 days
# We need: n0 * (r + 1)**3 < 20000
# Work backwards to find maximum r for given n0
# (r + 1)**3 < 20000/n0
# r + 1 < (20000/n0)**(1/3)
# r < (20000/n0)**(1/3) - 1
# Start with n0 since it has simpler constraints
max_n0 = min(int(21 * difficulty), 20) # Cap at 20 to keep numbers manageable
n0 = rng.randint(5, max_n0)
# Calculate maximum r that satisfies our inequality
max_possible_r = int((20000 / n0) ** (1 / 3) - 1)
max_r = min(int(8 * difficulty), max_possible_r, 7) # Cap at 7 for reasonable numbers
if max_r < 2:
# If range is too tight, adjust n0 down and recalculate
n0 = 5 # Use minimum value
max_possible_r = int((20000 / n0) ** (1 / 3) - 1)
max_r = min(int(8 * difficulty), max_possible_r, 7)
r = rng.randint(2, max(3, max_r)) # Ensure at least one valid choice
result = generate_from_variables(n0, r, d, disease)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_69(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, document: str, total_pages: int, fraction: str) -> dict[str, Any]:
frac_num = eval(fraction)
pages_done = int(total_pages * frac_num)
pages_remaining = total_pages - pages_done
question = f"{name} is required to submit a {total_pages}-page {document}. She already finished writing {fraction} of the {document}. How many pages does she have left to write?"
answer_cot = f"{name} has already written {fraction} of the {document} which is {total_pages} pages x {fraction} = {pages_done} pages.\nSo, she still needs to write {total_pages} pages - {pages_done} pages = {pages_remaining} pages.\n#### {pages_remaining}"
return {
"question": question,
"answer": format_number(pages_remaining),
"answer_cot": answer_cot,
"answer_value": pages_remaining,
"variables": {
"name": name,
"document": document,
"total_pages": total_pages,
"fraction": fraction,
"pages_done": pages_done,
"pages_remaining": pages_remaining,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia", "Harper", "Evelyn"]
documents = ["essay", "report", "thesis", "dissertation", "assignment"]
fractions = ["1/2", "1/3", "1/4", "2/3", "3/4"]
name = rng.choice(names_female)
document = rng.choice(documents)
fraction = rng.choice(fractions)
# Generate total pages ensuring it's divisible by denominator
denominator = int(fraction.split("/")[1])
max_pages = int(325 * difficulty)
total_pages = denominator * rng.randint(1, max_pages // denominator)
result = generate_from_variables(name, document, total_pages, fraction)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_70(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, objects: str, n: int, obstacle: str, frac: float, k: int, fake_num: int, fake_object: str
) -> dict[str, Any]:
dropped = int(n * frac)
remaining = n - dropped
found = k
after_finding = remaining + found
final = after_finding - fake_num
question = f"{name} has a bag of {objects} with {n} inside. He tripped over {obstacle} while carrying it and dropped {dropped} of them. He scrambled to search for them but only came up with {k}. When he went back home, he inspected the {objects} further. {fake_num} of them he picked up wasn't a {objects}, but actually {fake_object} so he got rid of it. How many {objects} did {name} end up with?"
answer_cot = (
f"{name} dropped his {objects} and was left with {n}*{1-frac}={remaining} {objects}.\n"
f"He searched and found some of his lost {objects}, getting him back to {remaining}+{k}={after_finding} {objects}.\n"
f"He went home and removed {fake_object}, leaving him with {after_finding}-{fake_num}={final} {objects}.\n"
f"#### {final}"
)
return {
"question": question,
"answer": format_number(final),
"answer_cot": answer_cot,
"answer_value": final,
"variables": {
"name": name,
"objects": objects,
"initial_count": n,
"obstacle": obstacle,
"fraction_dropped": frac,
"found_count": k,
"fake_count": fake_num,
"fake_object": fake_object,
"remaining": remaining,
"after_finding": after_finding,
"final_count": final,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"]
objects = ["marbles", "coins", "buttons", "beads", "pebbles"]
obstacles = ["rock", "stick", "toy", "root"]
fake_objects = ["buttons", "coins", "pebbles", "beads"]
fractions = [0.5, 0.25, 0.75]
name = rng.choice(names)
obj = rng.choice(objects)
obstacle = rng.choice(obstacles)
fake_object = rng.choice([x for x in fake_objects if x != obj])
frac = rng.choice(fractions)
# Start with n that's divisible by denominator of fraction
# For 0.5: need multiple of 2
# For 0.25: need multiple of 4
# For 0.75: need multiple of 4
if frac == 0.5:
step = 2
else: # 0.25 or 0.75
step = 4
# Generate n as valid multiple
min_n = 10
max_n = int(101 * difficulty)
valid_n = list(range(min_n + (step - min_n % step) % step, max_n, step))
n = rng.choice(valid_n) if valid_n else min_n
# Calculate n * frac (guaranteed to be integer due to our n selection)
n_frac = int(n * frac)
# Generate fake_num first (2 to min(10, n_frac))
fake_num = int(rng.randint(2, min(10, n_frac)))
# Generate k ensuring fake_num < k < n_frac
if fake_num + 1 < n_frac:
k = int(rng.randint(fake_num + 1, min(n_frac, int(20 * difficulty))))
else:
# If no valid range, adjust values to make it work
k = fake_num + 1
# Ensure n is large enough
required_n = int((k + 1) / frac)
n = required_n + (step - required_n % step) % step # Round up to valid multiple
n_frac = int(n * frac)
result = generate_from_variables(name, obj, n, obstacle, frac, k, fake_num, fake_object)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_71(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
shop: str,
item: str,
item1: str,
item2: str,
item3: str,
n1: int,
n2: int,
n3: int,
p1: int,
p2: int,
p3: int,
) -> dict[str, Any]:
cost1 = n1 * p1
cost2 = n2 * p2
cost3 = n3 * p3
total_cost = cost1 + cost2 + cost3
question = f"{name} went to the {shop} and bought various types of {item}. She bought {n1} dozen {item1} which cost ${p1} per dozen, {n2} dozen {item2} which cost ${p2} per dozen, and {n3} dozen {item3} for ${p3} per dozen. How much was the total cost?"
answer_cot = f"The total charge for the {item1} was {n1} x ${p1} = ${cost1}.\nThe total charge for the {item2} was {n2} x ${p2} = ${cost2}.\nThe total charge for the {item3} was {n3} x ${p3} = ${p3*n3}.\nTherefore the total amount {name} paid for the {item} was ${cost1} + ${cost2} + ${cost3} = ${total_cost}.\n#### {total_cost}"
return {
"question": question,
"answer": format_number(total_cost),
"answer_cot": answer_cot,
"answer_value": total_cost,
"variables": {
"name": name,
"shop": shop,
"item": item,
"item1": item1,
"item2": item2,
"item3": item3,
"n1": n1,
"n2": n2,
"n3": n3,
"p1": p1,
"p2": p2,
"p3": p3,
"cost1": cost1,
"cost2": cost2,
"cost3": cost3,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Charlotte", "Mia", "Amelia"]
shops = ["bakery", "patisserie", "confectionery", "cafe"]
items = ["pastries", "baked goods", "desserts", "treats"]
item1_options = ["donuts", "croissants", "eclairs", "danishes"]
item2_options = ["mini cupcakes", "macarons", "cookies", "tarts"]
item3_options = ["mini cheesecakes", "brownies", "muffins", "scones"]
name = rng.choice(names_female)
shop = rng.choice(shops)
item = rng.choice(items)
item1 = rng.choice(item1_options)
item2 = rng.choice(item2_options)
item3 = rng.choice(item3_options)
n1 = int(rng.randint(1, int(10 * difficulty)))
n2 = int(rng.randint(4, int(10 * difficulty)))
n3 = int(rng.randint(2, int(10 * difficulty)))
p1 = int(rng.randint(11, int(21 * difficulty)))
p2 = int(rng.randint(73, int(90 * difficulty)))
p3 = int(rng.randint(112, int(120 * difficulty)))
result = generate_from_variables(name, shop, item, item1, item2, item3, n1, n2, n3, p1, p2, p3)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_72(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
structure: str, n1: int, color1: str, color2: str, color3: str, obj: str, mult: int, total: int
) -> dict[str, Any]:
n2 = n1 * mult
n3 = total - n1 - n2
question = f"A {structure} is made out of {n1} {color1} {obj}s, {mult} times as many {color2} {obj}s, and an unknown number of {color3} {obj}s. If there are {total} {obj}s in the {structure} in total, how many {color3} {obj}s are there?"
answer_cot = f"There are {n1}*{mult} = {n2} {color2} {obj}s in the {structure}.\nThere are {total}-{n1}-{n2} = {n3} {color3} {obj}s in the {structure}.\n#### {n3}"
return {
"question": question,
"answer": format_number(n3),
"answer_cot": answer_cot,
"answer_value": n3,
"variables": {
"structure": structure,
"n1": n1,
"n2": n2,
"n3": n3,
"color1": color1,
"color2": color2,
"color3": color3,
"obj": obj,
"mult": mult,
"total": total,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
structures = ["building", "pyramid", "stack", "tower"]
objects = ["brick", "cube", "tile", "block"]
colors = ["green", "purple", "orange", "pink", "white", "black"]
structure = rng.choice(structures)
obj = rng.choice(objects)
color1, color2, color3 = rng.sample(colors, 3)
n1 = int(rng.randint(2, int(10 * difficulty)))
mult = 2 # "twice" as specified in original
n2 = n1 * mult
# Ensure total is greater than n1 + n2
min_total = n1 + n2 + 1
total = int(rng.randint(min_total, min_total + int(20 * difficulty)))
result = generate_from_variables(structure, n1, color1, color2, color3, obj, mult, total)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_73(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
fruit: str,
food: str,
d1: str,
d2: str,
n1: int,
n2: int,
m1: int,
m2: int,
cn: int,
cm: int,
currency: str,
) -> dict[str, Any]:
gingerbread_sunday = n1 + n2
total_gingerbread = n1 + gingerbread_sunday
gingerbread_revenue = total_gingerbread * cn
apple_pie_saturday = m2 - m1
total_apple_pie = m2 + apple_pie_saturday
apple_pie_revenue = total_apple_pie * cm
total_revenue = gingerbread_revenue + apple_pie_revenue
question = f"{name} is selling {food} and {fruit} pie for a fundraiser. On {d1}, he sold {n1} boxes of {food} and {m1} fewer boxes of {fruit} pie, than on {d2}. On {d2}, he sold {n2} more boxes of {food} than on {d1} and {m2} boxes of {fruit} pie. If the {food} cost {currency}{cn} and the {fruit} pie cost {currency}{cm}, how much did {name} earn for two days?"
answer_cot = f"He sold {n1} + {n2} = {gingerbread_sunday} boxes of {food} on {d2}.\nThe total number of boxes of {food}s that {name} sold is {n1} + {gingerbread_sunday} = {total_gingerbread}.\n{name} earned {total_gingerbread} x {currency}{cn} = {currency}{gingerbread_revenue} for selling {food}s.\nHe sold {m2} - {m1} = {apple_pie_saturday} boxes of {fruit} pie on {d1}.\nThe total number of boxes of {fruit} pie that {name} sold is {m2} + {apple_pie_saturday} = {total_apple_pie}.\nHe earned {total_apple_pie} x {currency}{cm} = {currency}{apple_pie_revenue} for selling {fruit} pie.\nSo, {name} earned {currency}{gingerbread_revenue} + {currency}{apple_pie_revenue} = {currency}{total_revenue} for two days.\n#### {total_revenue}"
return {
"question": question,
"answer": format_number(total_revenue),
"answer_cot": answer_cot,
"answer_value": total_revenue,
"variables": {
"name": name,
"fruit": fruit,
"food": food,
"day1": d1,
"day2": d2,
"gingerbread_day1": n1,
"gingerbread_increase": n2,
"apple_pie_difference": m1,
"apple_pie_day2": m2,
"gingerbread_price": cn,
"apple_pie_price": cm,
"currency": currency,
"total_revenue": total_revenue,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Michael", "David", "James", "William", "Robert"]
fruits = ["apple", "cherry", "blueberry", "peach"]
foods = ["cookie", "brownie", "muffin", "cupcake"]
weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
currencies = ["$", "£", "€"]
name = rng.choice(names)
fruit = rng.choice(fruits)
food = rng.choice(foods)
d1, d2 = rng.sample(weekdays, 2)
currency = rng.choice(currencies)
n1 = int(rng.randint(21, int(30 * difficulty)))
n2 = int(rng.randint(11, int(15 * difficulty)))
m2 = int(rng.randint(21, int(30 * difficulty)))
m1 = int(rng.randint(11, int(min(20, m2) * difficulty)))
cn = int(rng.randint(7, int(13 * difficulty)))
cm = int(rng.randint(20, int(33 * difficulty)))
result = generate_from_variables(name, fruit, food, d1, d2, n1, n2, m1, m2, cn, cm, currency)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_74(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, big_fish: str, length: int, num_remoras: int, remora_length: int
) -> dict[str, Any]:
total_remora_length_inches = num_remoras * remora_length
total_remora_length_feet = total_remora_length_inches / 12
percentage = int((total_remora_length_feet / length) * 100)
question = f"{name} saw a {length}-foot {big_fish} with {num_remoras} {remora_length}-inch remoras attached to it. What percentage of the {big_fish}'s body length is the combined length of the remoras?"
answer_cot = f"First, find the combined length of the remoras in inches: {remora_length} inches/remora * {num_remoras} remoras = {total_remora_length_inches} inches\nThen divide that number by 12 to convert it to feet: {total_remora_length_inches} inches / 12 inches/foot = {total_remora_length_feet} foot\nThen divide the combined remora length in feet by the {big_fish}'s length and multiply by 100% to express the answer as a percentage: {total_remora_length_feet} foot / {length} feet * 100% = {percentage}%\n#### {percentage}"
return {
"question": question,
"answer": format_number(percentage),
"answer_cot": answer_cot,
"answer_value": percentage,
"variables": {
"name": name,
"big_fish": big_fish,
"length_feet": length,
"num_remoras": num_remoras,
"remora_length_inches": remora_length,
"total_remora_length_inches": total_remora_length_inches,
"total_remora_length_feet": total_remora_length_feet,
"percentage": percentage,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Benny", "Tommy", "Jimmy", "Billy", "Johnny", "Bobby"]
big_fish = ["dolphin", "whale", "shark"]
name = rng.choice(names)
fish = rng.choice(big_fish)
# Start with remoras since they have the most constraints
min_remoras = 2
max_remoras = int(10 * difficulty)
num_remoras = int(rng.randint(min_remoras, max_remoras))
# Generate remora_length ensuring product will be divisible by 12
# We need (num_remoras * remora_length) % 12 == 0
min_remora_length = 2
max_remora_length = int(100 * difficulty)
# Find valid remora lengths that make the product divisible by 12
valid_lengths = [l for l in range(min_remora_length, max_remora_length + 1) if (num_remoras * l) % 12 == 0]
if not valid_lengths:
# Adjust num_remoras to make it work with minimum length
num_remoras = 12 # This ensures divisibility by 12
remora_length = min_remora_length
else:
remora_length = rng.choice(valid_lengths)
# Calculate total remora length
total_remora_length = num_remoras * remora_length
# Generate host fish length ensuring all conditions are met
# We need:
# 1. length * 12 > total_remora_length
# 2. (length * 12) must be divisible by total_remora_length
# 3. The ratio must give a percentage that divides 100
min_length = max(10, (total_remora_length + 11) // 12) # Round up division
max_length = int(500 * difficulty)
# Generate lengths that satisfy conditions
valid_host_lengths = []
for l in range(min_length, max_length + 1, 10): # Step by 10 as per original
if (l * 12) % total_remora_length == 0: # Ensure clean division
ratio = (total_remora_length * 100) // (l * 12) # Calculate percentage
if ratio > 0 and 100 % ratio == 0: # Check if percentage divides 100
valid_host_lengths.append(l)
if not valid_host_lengths:
# Fallback: adjust values to make it work
length = total_remora_length # This ensures ratio is 1:1
else:
length = rng.choice(valid_host_lengths)
result = generate_from_variables(name, fish, length, num_remoras, remora_length)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_75(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name1: str, name2: str, color1: str, color2: str, n1: int, n2: int, frac1: float, mult1: float
) -> dict[str, Any]:
n1_result = int(n1 * frac1)
n2_result = int(n2 * mult1)
total = n1_result + n2_result
question = f"{name1} has {n1} tubes of {color1} paint and {n2} tubes of {color2} paint. {name2} has half as many tubes of {color1} paint as {name1}, and three times as many tubes of {color2} paint as {name1}. How many tubes of paint does {name2} have?"
answer_cot = (
f"{name2} has {n1}*{frac1}={n1_result} tubes of {color1} paint\n"
f"{name2} has {n2}*{mult1}={n2_result} tubes of {color2} paint\n"
f"{name2} has a total of {n1_result}+{n2_result}={total} tubes of paint\n"
f"#### {total}"
)
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name1": name1,
"name2": name2,
"color1": color1,
"color2": color2,
"n1": n1,
"n2": n2,
"frac1": frac1,
"mult1": mult1,
"n1_result": n1_result,
"n2_result": n2_result,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Ben", "James", "John", "Michael", "William", "David", "Richard", "Joseph"]
colors = ["blue", "red", "green", "yellow", "purple", "orange"]
name1, name2 = rng.sample(names, 2)
color1, color2 = rng.sample(colors, 2)
# Generate numbers that ensure integer results
n1 = int(rng.randint(2, int(20 * difficulty)))
n2 = int(rng.randint(2, int(20 * difficulty)))
frac1 = 0.5 # half
mult1 = 3.0 # three times
result = generate_from_variables(name1, name2, color1, color2, n1, n2, frac1, mult1)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_76(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(n: int, p1: int, p2: int, company: str, frac: float) -> dict[str, Any]:
interviews = int(n * (p1 / 100))
offers = int(interviews * (p2 / 100))
accepts = int(offers * frac)
question = f"{n} people apply for a job at {company}. Of the people that apply, only {p1}% receive interviews. Of those who receive interviews, {p2}% receive a job offer. Of those who receive a job offer, {frac:.2%} of the people accept the position. How many people accept the position?"
answer_cot = (
f"The number of people that receive interviews is {n} * {p1/100} = {interviews} people\n"
f"The number of people that receive a job offer is {interviews} * {p2/100} = {offers} people\n"
f"The number of people that accept the position is {offers} * {frac} = {accepts} people\n"
f"#### {accepts}"
)
return {
"question": question,
"answer": format_number(accepts),
"answer_cot": answer_cot,
"answer_value": accepts,
"variables": {
"total_applicants": n,
"interview_percent": p1,
"offer_percent": p2,
"company": company,
"acceptance_fraction": frac,
"num_interviews": interviews,
"num_offers": offers,
"num_accepts": accepts,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
companies = ["Microsoft", "Apple", "Amazon", "Facebook", "Netflix", "Tesla", "Google"]
fractions = {"a third": 1 / 3, "half": 1 / 2, "a quarter": 1 / 4, "two thirds": 2 / 3}
company = rng.choice(companies)
frac_name = rng.choice(list(fractions.keys()))
frac = fractions[frac_name]
# To ensure integer results for all calculations:
# 1. We need n * (p1/100) to be integer -> n should be multiple of 100
# 2. We need that result * (p2/100) to be integer -> p1,p2 should be multiples of 5
# 3. We need final result * frac to be integer -> scale n to work with fraction denominator
# First determine base multiples based on fraction
if frac == 1 / 3 or frac == 2 / 3:
base_multiple = 300 # Works for thirds
elif frac == 1 / 4:
base_multiple = 400 # Works for quarters
else: # frac == 1/2
base_multiple = 200 # Works for halves
# Generate n as a multiple of our base to ensure clean division
n_multiplier = rng.randint(1, min(int(3 * difficulty), 4))
n = n_multiplier * base_multiple
# Generate percentages as multiples of 5 to ensure clean division
p1 = 5 * rng.randint(2, min(int(10 * difficulty), 10)) # 10 to 50 in steps of 5
p2 = 5 * rng.randint(2, min(int(10 * difficulty), 10)) # 10 to 50 in steps of 5
# These numbers guarantee:
# 1. n * (p1/100) is integer (since n is multiple of 100 and p1 is multiple of 5)
# 2. n * (p1/100) * (p2/100) is integer (same reason)
# 3. n * (p1/100) * (p2/100) * frac is integer (due to base_multiple construction)
result = generate_from_variables(n, p1, p2, company, frac)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_77(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
event: str, m: int, w: int, t: str, frac: float, m_left: int, group1: str, group2: str
) -> dict[str, Any]:
total = m + w
left_count = int(total * frac)
stayed = total - left_count
w_left = stayed - m_left
question = f"At the beginning of the {event}, there were {m} {group1} and {w} {group2}. After {t}, {frac} of the total number of people left. How many {group2} are left if {m_left} {group1} stayed at the {event}?"
answer_cot = (
f"There were a total of {m} {group1} + {w} {group2} = {total} people who attended the {event}.\n"
f"After {t}, {total} people * {frac} = {left_count} people left the {event}.\n"
f"This means {total} people - {left_count} people = {stayed} people stayed.\n"
f"Out of the {stayed} who stayed, {stayed} people - {m_left} {group1} = {w_left} were {group2}.\n"
f"#### {w_left}"
)
return {
"question": question,
"answer": format_number(w_left),
"answer_cot": answer_cot,
"answer_value": w_left,
"variables": {
"event": event,
"men": m,
"women": w,
"time": t,
"fraction_left": frac,
"men_stayed": m_left,
"women_stayed": w_left,
"group1": group1,
"group2": group2,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
events = ["party", "meeting", "conference", "gathering", "celebration"]
groups = ["teachers", "doctors", "engineers", "nurses", "artists", "lawyers"]
times = ["an hour", "two hours", "half an hour", "45 minutes"]
fractions = [0.25, 0.5, 0.75, 0.33, 0.67]
event = rng.choice(events)
group1, group2 = rng.sample(groups, 2)
t = rng.choice(times)
frac = rng.choice(fractions)
# Calculate minimum total needed based on fraction and m_left requirements
min_m_left = 15
min_stayed = min_m_left + 1 # Need at least min_m_left + 1 people staying
min_total = int(min_stayed / (1 - frac)) # Round up
# Ensure min_total is large enough for m and w requirements
min_total = max(min_total, 30) # m >= 20 and w >= 10
# Round up min_total to work with fraction
if min_total * frac != int(min_total * frac):
min_total = int((min_total + (1 / frac)) // (1 / frac) * (1 / frac))
# Generate valid total
max_total = int(155 * difficulty) # max possible m + w
valid_totals = [t for t in range(min_total, max_total + 1) if (t * frac).is_integer()]
if not valid_totals:
total = min_total
else:
total = rng.choice(valid_totals)
# Calculate stayed amount
stayed = total - int(total * frac)
# Generate m_left first
max_m_left = min(stayed - 1, int(35 * difficulty))
m_left = rng.randint(15, max(15, max_m_left))
# Now generate m ensuring it's at least m_left + int(total * frac)
min_m = max(20, m_left + int(total * frac))
max_m = min(int(75 * difficulty), total - 10) # ensure w >= 10
if min_m <= max_m:
m = rng.randint(min_m, max_m)
else:
# Fallback case
m = min_m
total = m + 10 # minimum valid total
w = total - m
result = generate_from_variables(event, m, w, t, frac, m_left, group1, group2)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_78(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name1: str, name2: str, age_diff: int, age1: int) -> dict[str, Any]:
age2 = age1 + age_diff
avg_age = (age1 + age2) // 2
question = f"{name1} and {name2} are currently {age_diff} years apart in age. If {name1}, who is younger than {name2}, is {age1} years old, what's the average of their ages?"
answer_cot = (
f"If {name1} is {age1} years old, {name2} is {age1}+{age_diff} = {age2} years old.\n"
f"The sum of their ages is {age2}+{age1} = {age1+age2} years\n"
f"The average age of the two is {age1+age2}/2 = {avg_age} years\n"
f"#### {avg_age}"
)
return {
"question": question,
"answer": format_number(avg_age),
"answer_cot": answer_cot,
"answer_value": avg_age,
"variables": {
"name1": name1,
"name2": name2,
"age_diff": age_diff,
"age1": age1,
"age2": age2,
"avg_age": avg_age,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"]
name1, name2 = rng.sample(names, 2)
# Generate age difference - ensure it's even to guarantee integer average
age_diff = int(rng.randint(5, int(30 * difficulty)))
if age_diff % 2 != 0:
age_diff += 1 # Make it even if it's odd
age1 = int(rng.randint(15, int(75 * difficulty)))
result = generate_from_variables(name1, name2, age_diff, age1)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_79(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
vehicle: str,
start_time: int,
end_time: int,
free_hours: int,
currency: str,
first_hour_cost: int,
multiplier: int,
) -> dict[str, Any]:
total_hours = end_time - start_time
paid_hours = total_hours - free_hours
other_hours = paid_hours - 1
hourly_rate = first_hour_cost * multiplier
other_hours_cost = other_hours * hourly_rate
total_cost = first_hour_cost + other_hours_cost
question = f"{name} hires a {vehicle} from {start_time} PM to {end_time} PM. He gets {free_hours} hour free. The first paid hour is {currency}{first_hour_cost} and each hour after that is {multiplier} times the cost. How much did he pay?"
answer_cot = (
f"He got it for {end_time}-{start_time}={total_hours} hours\n"
f"He pays for {total_hours}-{free_hours}={paid_hours} hours\n"
f"The first hour cost 1*{first_hour_cost}={currency}{first_hour_cost}\n"
f"The other {paid_hours}-1={other_hours} hours are more expensive\n"
f"They cost {first_hour_cost}*{multiplier}={currency}{hourly_rate} per hour\n"
f"So those {other_hours} hours cost {other_hours}*{hourly_rate}={currency}{other_hours_cost}\n"
f"So he pays {other_hours_cost}+{first_hour_cost}={currency}{total_cost}\n"
f"#### {total_cost}"
)
return {
"question": question,
"answer": format_number(total_cost),
"answer_cot": answer_cot,
"answer_value": total_cost,
"variables": {
"name": name,
"vehicle": vehicle,
"start_time": start_time,
"end_time": end_time,
"free_hours": free_hours,
"currency": currency,
"first_hour_cost": first_hour_cost,
"multiplier": multiplier,
"total_hours": total_hours,
"paid_hours": paid_hours,
"total_cost": total_cost,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard"]
vehicles = ["limousine", "party bus", "boat", "luxury car"]
currencies = ["$", "€", "£"]
name = rng.choice(names)
vehicle = rng.choice(vehicles)
currency = rng.choice(currencies)
start_time = int(rng.randint(1, int(8 * difficulty)))
end_time = int(rng.randint(start_time + 2, int(12 * difficulty)))
free_hours = int(rng.randint(1, min(3, end_time - start_time - 1)))
first_hour_cost = int(rng.randint(10, int(51 * difficulty)))
multiplier = 2
# Verify conditions
while not (
(end_time - start_time > free_hours + 1)
and is_integer((end_time - start_time - free_hours - 1) * first_hour_cost * multiplier)
):
start_time = int(rng.randint(1, int(8 * difficulty)))
end_time = int(rng.randint(start_time + 2, int(12 * difficulty)))
free_hours = int(rng.randint(1, min(3, end_time - start_time - 1)))
first_hour_cost = int(rng.randint(10, int(51 * difficulty)))
result = generate_from_variables(
name, vehicle, start_time, end_time, free_hours, currency, first_hour_cost, multiplier
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_80(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, color1: str, color2: str, n1: int, n2: int, n3: int, n4: int
) -> dict[str, Any]:
blue_spools = n1 + n2
total_spools = n1 + n2 + n3 + n4
percent_blue = int(100 * blue_spools / total_spools)
question = f"{name} has {n1} light {color1} spools of thread, {n2} dark {color1} spools of thread, {n3} light {color2} spools of thread, and {n4} dark {color2} spools of thread. What percent of her spools are {color1}?"
answer_cot = f"First find the number of {color1} spools: {n1} spools + {n2} spools = {blue_spools} spools\nThen find the total number of spools: {n3} spools + {n4} spools + {blue_spools} spools = {total_spools} spools\nThen divide the number of {color1} spools by the total number of spools and multiply by 100% to express the answer as a percentage: {blue_spools} spools / {total_spools} spools * 100% = {percent_blue}%\n#### {percent_blue}"
return {
"question": question,
"answer": format_number(percent_blue),
"answer_cot": answer_cot,
"answer_value": percent_blue,
"variables": {
"name": name,
"color1": color1,
"color2": color2,
"light_color1_spools": n1,
"dark_color1_spools": n2,
"light_color2_spools": n3,
"dark_color2_spools": n4,
"total_color1_spools": blue_spools,
"total_spools": total_spools,
"percent_color1": percent_blue,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Candy", "Sarah", "Emma", "Olivia", "Isabella", "Sophia", "Mia", "Charlotte"]
colors = ["blue", "red", "green", "yellow", "purple", "orange"]
name = rng.choice(names)
color1, color2 = rng.sample(colors, 2)
# Generate numbers ensuring integer percentage result
n1 = int(rng.randint(15, int(45 * difficulty)))
n2 = int(rng.randint(45, int(100 * difficulty)))
n3 = int(rng.randint(20, int(80 * difficulty)))
n4 = int(rng.randint(50, int(100 * difficulty)))
# Ensure percentage is integer
total = n1 + n2 + n3 + n4
while ((n1 + n2) * 100) % total != 0:
n4 += 1
total = n1 + n2 + n3 + n4
result = generate_from_variables(name, color1, color2, n1, n2, n3, n4)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_81(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
occupation: str, weeks_per_month: int, days_per_week: int, pay_per_day: int, currency: str
) -> dict[str, Any]:
days_per_month = days_per_week * weeks_per_month
monthly_pay = days_per_month * pay_per_day
yearly_pay = monthly_pay * 12
question = f"A {occupation} works for {weeks_per_month} weeks every month and for {days_per_week} days every week. If he gets paid {currency}{pay_per_day} every day, how much does he earn if he works for a year?"
answer_cot = f"The {occupation} works for {days_per_week} days every week and works for {weeks_per_month} weeks every month so he works for {days_per_week} days/week * {weeks_per_month} weeks/month = {days_per_month} days/month\nIf he earns {currency}{pay_per_day} every day he then earns {currency}{pay_per_day}/day * {days_per_month} days/month = {currency}{monthly_pay}/month\nA year is equal to 12 months so every year he earns {currency}{monthly_pay}/month * 12 months/year = {currency}{yearly_pay}\n#### {yearly_pay}"
return {
"question": question,
"answer": format_number(yearly_pay),
"answer_cot": answer_cot,
"answer_value": yearly_pay,
"variables": {
"occupation": occupation,
"weeks_per_month": weeks_per_month,
"days_per_week": days_per_week,
"pay_per_day": pay_per_day,
"currency": currency,
"days_per_month": days_per_month,
"monthly_pay": monthly_pay,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
occupations = ["plumber", "electrician", "painter", "carpenter", "landscaper"]
currencies = ["$", "£", "€"]
occupation = rng.choice(occupations)
currency = rng.choice(currencies)
weeks_per_month = int(rng.randint(2, int(5 * difficulty)))
days_per_week = int(rng.randint(4, int(7 * difficulty)))
pay_per_day = int(rng.randrange(40, int(200 * difficulty), 5))
result = generate_from_variables(occupation, weeks_per_month, days_per_week, pay_per_day, currency)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_82(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name: str, num_emails: int, no_response_percent: int, workdays: int) -> dict[str, Any]:
no_response = num_emails * no_response_percent // 100
responds_to = num_emails - no_response
total_responses = responds_to * workdays
question = f"{name} gets {num_emails} emails a day. {no_response_percent}% of those emails don't require any response. {name} responds to the rest of them. How many emails does {name} respond to in a {workdays} day work week?"
answer_cot = (
f"{name} receives {no_response}={no_response} emails that don't require a response\n"
f"So {name} responds to {num_emails}-{no_response}={responds_to} emails per day\n"
f"In a {workdays} day work week, {name} responds to {responds_to}*{workdays}={total_responses} emails\n"
f"#### {total_responses}"
)
return {
"question": question,
"answer": format_number(total_responses),
"answer_cot": answer_cot,
"answer_value": total_responses,
"variables": {
"name": name,
"num_emails": num_emails,
"no_response_percent": no_response_percent,
"workdays": workdays,
"no_response": no_response,
"responds_to": responds_to,
"total_responses": total_responses,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph"]
name = rng.choice(names)
# Generate random values scaled by difficulty
num_emails = int(rng.randint(50, int(200 * difficulty)))
no_response_percent = int(rng.randint(5, int(40 * difficulty)))
workdays = int(rng.randint(3, int(7 * difficulty)))
# Ensure conditions are met
while not (num_emails * no_response_percent % 100 == 0 and num_emails * (100 - no_response_percent) % 100 == 0):
num_emails = int(rng.randint(50, int(200 * difficulty)))
no_response_percent = int(rng.randint(5, int(40 * difficulty)))
result = generate_from_variables(name, num_emails, no_response_percent, workdays)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_83(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(name1: str, name2: str, total: int, diff: int, unit: str) -> dict[str, Any]:
amount1 = (total - diff) // 2 # Sam's amount
amount2 = amount1 + diff # Harry's amount
question = f"If {name1} and {name2} have {total} {unit} of fence between them, and they agree to split it with {name2} getting {diff} {unit} more than {name1}, how much is left over for {name1}?"
answer_cot = f"Let x be the amount of fence {name1} gets and y be the amount {name2} gets. We know that y = x + {diff}, and y + x = {total}.\nSubstituting the first equation into the second equation, we get 2x+{diff}={total}\nSubtracting the {diff} from both sides, we get 2x={total-diff}\nWe divide each side by two, leaving x={amount1}. This means {name1} has {amount1} {unit} of fence left over.\n#### {amount1}"
return {
"question": question,
"answer": format_number(amount1),
"answer_cot": answer_cot,
"answer_value": amount1,
"variables": {
"name1": name1,
"name2": name2,
"total_fence": total,
"difference": diff,
"unit": unit,
"amount1": amount1,
"amount2": amount2,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Sam", "Harry", "Tom", "John", "Mike", "Dave", "Steve", "Bob"]
units = ["feet", "yards", "meters"]
name1, name2 = rng.sample(names, 2)
unit = rng.choice(units)
# Start with the difference - must be divisible by 10 and between 20 and 180
max_diff = min(int(200 * difficulty), 180)
diff = 10 * rng.randint(2, max_diff // 10) # This ensures diff is multiple of 10 between 20 and max_diff
# For total: we need total > diff + 20 and (total - diff) must be even
# Let's work backwards from our constraints
min_total = diff + 22 # Adding 22 ensures total-diff > 10 and gives room for even adjustment
max_total = min(int(1000 * difficulty), min_total + 200) # Cap the maximum to avoid too large numbers
# Ensure max_total is larger than min_total and generate valid number
if max_total <= min_total:
total = min_total
else:
# Generate total as min_total plus an even number
total = min_total + (2 * rng.randint(0, (max_total - min_total) // 2))
result = generate_from_variables(name1, name2, total, diff, unit)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_84(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, miles: str, time_cold: int, extra_time: int, multiplier: float, distance: int
) -> dict[str, Any]:
time_warm = extra_time + multiplier * time_cold
time_cold_total = distance * time_cold
time_warm_total = distance * time_warm
time_difference = time_warm_total - time_cold_total
question = f"When the water is cold {name} swims a {miles} in {time_cold} minutes. When the water is warm {name} swims a {miles} in {extra_time} minutes more than {multiplier:.0f} times as long. How much longer does {name} take to swim {distance} {miles}s on a hot day than a cold day?"
answer_cot = (
f"Cold water {miles} = {time_cold} minutes\n"
f"Warm water {miles} = {extra_time}+{multiplier:.0f}({time_cold})={time_warm} minutes\n"
f"{distance} {miles}s in cold water: {distance}({time_cold})={time_cold_total} minutes\n"
f"{distance} {miles}s in warm water: {distance}({time_warm})={time_warm_total} minutes\n"
f"{name} takes {time_warm_total}-{time_cold_total}={time_difference} minutes longer\n"
f"#### {time_difference}"
)
return {
"question": question,
"answer": format_number(time_difference),
"answer_cot": answer_cot,
"answer_value": time_difference,
"variables": {
"name": name,
"unit": miles,
"time_cold": time_cold,
"extra_time": extra_time,
"multiplier": multiplier,
"distance": distance,
"time_warm": time_warm,
"time_cold_total": time_cold_total,
"time_warm_total": time_warm_total,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Ray", "Jim", "Bob", "Tom", "Mike", "John", "Steve"]
units = ["mile", "kilometer"]
name = rng.choice(names)
unit = rng.choice(units)
# First generate time_cold ensuring it's < 60 and reasonable with multiplier
# Since multiplier is 2.0, time_cold needs to be < 30 to avoid total >= 60
max_time_cold = min(25, int(50 * difficulty), 29) # Cap at 29 to ensure multiplier works
time_cold = rng.randint(10, max_time_cold)
# Calculate maximum extra_time that keeps total under 60
# extra_time + 2 * time_cold < 60
# extra_time < 60 - 2 * time_cold
max_extra = min(int(10 * difficulty), 60 - 2 * time_cold - 1)
if max_extra < 1:
# If we can't find valid extra_time, adjust time_cold down
time_cold = 20 # Reset to safe value
max_extra = 19 # 60 - 2*20 - 1
extra_time = rng.randint(1, max_extra)
# Fixed multiplier
multiplier = 2.0
# Calculate minimum distance needed to make the difference positive
# distance * (extra_time + 2 * time_cold) - distance * time_cold > 0
# distance * (extra_time + time_cold) > 0
# Since extra_time is positive, this is always true for positive distance
min_distance = 2
max_distance = min(int(10 * difficulty), 8) # Cap at 8 for reasonable numbers
distance = rng.randint(min_distance, max_distance)
result = generate_from_variables(name, unit, time_cold, extra_time, multiplier, distance)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_85(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, room_type: str, area: int, length: int, unit1: str, unit2: str
) -> dict[str, Any]:
conversion = 3 if unit1 == "feet" and unit2 == "yards" else 1
length_converted = length * conversion
width = area // length_converted
perimeter = 2 * (width + length_converted)
question = f"The area of {name}'s rectangular {room_type} is {area} square {unit1}. If the length of his room is {length} {unit2}, what is the perimeter of the room in {unit1}?"
answer_cot = (
f"The length of the room is {length} {unit2} * ({conversion} {unit1} / 1 {unit2}) = {length_converted} {unit1}.\n"
f"The width of the room is {area} square {unit1} / {length_converted} {unit1} = {width} {unit1}.\n"
f"The room's perimeter is 2({width}+{length_converted}) = {perimeter}\n#### {perimeter}"
)
return {
"question": question,
"answer": format_number(perimeter),
"answer_cot": answer_cot,
"answer_value": perimeter,
"variables": {
"name": name,
"room_type": room_type,
"area": area,
"length": length,
"unit1": unit1,
"unit2": unit2,
"width": width,
"length_converted": length_converted,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def calculate_max_width(difficulty: float, length: int, conversion: int) -> int:
# Cap the maximum width to avoid numbers getting too large
theoretical_max = int(100 * difficulty)
# Ensure we have room for at least length * conversion + 1
min_required = length * conversion + 1
return max(min_required + 1, min(theoretical_max, min_required + 50))
names = ["William", "James", "John", "Michael", "David", "Robert", "Thomas"]
room_types = ["living room", "study", "office", "kitchen"]
units = ["feet", "meters"]
name = rng.choice(names)
room_type = rng.choice(room_types)
unit1 = rng.choice(units)
unit2 = "yards" if unit1 == "feet" else "meters"
# First determine length, capped to avoid too large numbers
max_length = min(int(44 * difficulty), 40) # Cap at 40 to ensure room for width
length = rng.randint(5, max_length)
# Calculate conversion factor
conversion = 3 if unit1 == "feet" and unit2 == "yards" else 1
# Calculate width bounds
min_width = length * conversion + 1
max_width = calculate_max_width(difficulty, length, conversion)
# If ranges are too tight, adjust length down
if max_width <= min_width:
length = max(5, length - 5)
min_width = length * conversion + 1
max_width = calculate_max_width(difficulty, length, conversion)
# Generate width ensuring we have valid range
width = rng.randint(min_width, max_width)
area = width * (length * conversion)
result = generate_from_variables(name, room_type, area, length, unit1, unit2)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_86(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
animals: str,
unit: str,
o1: str,
o2: str,
o3: str,
o4: str,
n1: int,
n2: int,
n3: int,
n4: int,
w1: int,
w2: int,
w3: int,
w4: int,
total: int,
) -> dict[str, Any]:
# Calculate weights
sugar_weight = n4 * w4
carrot_weight = n3 * w3
hay_weight = n1 * w1
oat_weight = n2 * w2
total_weight = sugar_weight + carrot_weight + hay_weight + oat_weight
trips = total_weight // total
question = f"A farmer is buying feed for his {animals}. He buys a variety of {o1}, {o2}, {o3} and {o4}. Since {o4} are a rare treat, he only buys {n4} {w4}-{unit} boxes of them for the whole stable. He only wants enough {o3} to feed the {animals} while the vegetables are fresh, so he buys {n3} {w3}-{unit} bags. {o1} is the main diet of his {animals}, so he buys {n1} {w1}-{unit} bales. {o2} are a staple to supplement the {o1}, so he buys {n2} {w2}-{unit} sacks. If his farm truck can carry {total} {unit}s at a time, how many trips does the farmer need to transport all the feed?"
answer_cot = f"The farmer is buying {n4} * {w4} = {sugar_weight} {unit}s of {o4}.\nHe is buying {n3} * {w3} = {carrot_weight} {unit}s of {o3}.\nHe is buying {n1} * {w1} = {hay_weight} {unit}s of {o1}.\nHe is buying {n2} * {w2} = {oat_weight} {unit}s of {o2}.\nThe weight of all the feed is {sugar_weight} + {carrot_weight} + {hay_weight} + {oat_weight} = {total_weight} {unit}s.\nThus, the farmer needs {total_weight} / {total} = {trips} trips to transport all the feed in his farm truck.\n#### {trips}"
return {
"question": question,
"answer": format_number(trips),
"answer_cot": answer_cot,
"answer_value": trips,
"variables": {
"animals": animals,
"unit": unit,
"feed_types": [o1, o2, o3, o4],
"quantities": [n1, n2, n3, n4],
"weights": [w1, w2, w3, w4],
"truck_capacity": total,
"total_weight": total_weight,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
animals = rng.choice(["horses", "cows", "sheep", "pigs", "alpacas"])
unit = rng.choice(["pound", "kilogram"])
feed_options = ["hay", "corn", "oats", "apples", "wheat"]
o1, o2, o4 = rng.sample(feed_options, 3)
o3 = rng.choice(["carrots", "beets", "cucumbers"])
# Scale ranges by difficulty
n4 = int(rng.randint(4, int(8 * difficulty)))
n3 = int(rng.randint(11, int(15 * difficulty)))
n2 = int(rng.randint(15, int(20 * difficulty)))
n1 = int(rng.randint(31, int(35 * difficulty)))
w4 = int(rng.randint(3, int(8 * difficulty)))
w3 = int(rng.randint(5, int(10 * difficulty)))
w2 = int(rng.randint(15, int(20 * difficulty)))
w1 = int(rng.randint(35, int(45 * difficulty)))
# Ensure weight conditions are met
while not (w4 * n4 < w3 * n3 < w2 * n2 < w1 * n1):
w4 = int(rng.randint(3, int(8 * difficulty)))
w3 = int(rng.randint(5, int(10 * difficulty)))
w2 = int(rng.randint(15, int(20 * difficulty)))
w1 = int(rng.randint(35, int(45 * difficulty)))
total_weight = n1 * w1 + n2 * w2 + n3 * w3 + n4 * w4
# Find truck capacity that divides total weight
total = total_weight // rng.randint(2, 4)
result = generate_from_variables(animals, unit, o1, o2, o3, o4, n1, n2, n3, n4, w1, w2, w3, w4, total)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_87(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
unit: str,
weight_large: int,
weight_medium: int,
weight_small: Fraction,
num_large: int,
num_medium: int,
num_small: int,
total_amount: int,
) -> dict[str, Any]:
large_used = num_large * weight_large
medium_used = num_medium * weight_medium
small_used = float(num_small * weight_small)
total_used = large_used + medium_used + small_used
remaining = total_amount - total_used
question = f"{name} wants to make different sized ice cubes with {total_amount} {unit}s of water. He can make giant cubes that use {weight_large} {unit}s per cube, medium cubes that use {weight_medium} {unit}s, and small cubes that use {weight_small} an {unit}. If he makes {num_large} giant cubes, {num_medium} medium cubes, and {num_small} small cubes, how many {unit}s of water does he have left?"
answer_cot = (
f"The giant cubes used up {large_used} {unit}s of water because {num_large} times {weight_large} equals {large_used}.\n"
f"The medium cubes used up {medium_used} {unit}s of water because {num_medium} times {weight_medium} equals {medium_used}.\n"
f"The small cubes used up {int(small_used)} {unit}s of water because {num_small} times {weight_small} equals {int(small_used)}.\n"
f"This means that {name} has used up {int(total_used)} {unit}s of water because {large_used} plus {medium_used} plus {int(small_used)} equals {int(total_used)}.\n"
f"{name} has {int(remaining)} {unit}s of water left because {total_amount} minus {int(total_used)} equals {int(remaining)}.\n"
f"#### {int(remaining)}"
)
return {
"question": question,
"answer": format_number(int(remaining)),
"answer_cot": answer_cot,
"answer_value": int(remaining),
"variables": {
"name": name,
"unit": unit,
"weight_large": weight_large,
"weight_medium": weight_medium,
"weight_small": weight_small,
"num_large": num_large,
"num_medium": num_medium,
"num_small": num_small,
"total_amount": total_amount,
"remaining": remaining,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"]
units = ["ounce", "gram", "milliliter"]
name = rng.choice(names)
unit = rng.choice(units)
weight_large = int(rng.randint(7, int(14 * difficulty)))
weight_medium = int(rng.randint(3, weight_large - 1))
weight_small = Fraction(1, 2)
num_large = int(rng.randint(2, int(8 * difficulty)))
num_medium = int(rng.randint(4, int(12 * difficulty)))
num_small = rng.choice([14, 24, 15])
# Calculate needed total to ensure positive remainder
used = num_large * weight_large + num_medium * weight_medium + float(num_small * weight_small)
total_amount = int(used + rng.randint(1, int(10 * difficulty)))
result = generate_from_variables(
name, unit, weight_large, weight_medium, weight_small, num_large, num_medium, num_small, total_amount
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_88(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(school: str, venue: str, total: int, graduates: int, faculty: int) -> dict[str, Any]:
remaining_seats = total - (graduates + faculty)
tickets_per_graduate = remaining_seats // graduates
question = f"{school} is holding graduation in their {venue} this year which has space for {total} people. After accounting for {graduates} seats for graduates and {faculty} seats for faculty attending, how many tickets would each graduate receive to give to their friends and family if the tickets are split equally?"
answer_cot = f"Add graduate and faculty seats together. {graduates} + {faculty} = {graduates+faculty} seats for faculty and graduates\nMinus seats for faculty and graduates from total seats allowed. {total} - {graduates+faculty} = {remaining_seats} remaining seats.\nDivide remaining seats by the number of graduates. {remaining_seats}/{graduates} = {tickets_per_graduate} tickets\n#### {tickets_per_graduate}"
return {
"question": question,
"answer": format_number(tickets_per_graduate),
"answer_cot": answer_cot,
"answer_value": tickets_per_graduate,
"variables": {
"school": school,
"venue": venue,
"total_seats": total,
"graduate_seats": graduates,
"faculty_seats": faculty,
"remaining_seats": remaining_seats,
"tickets_per_graduate": tickets_per_graduate,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
schools = ["Oakwood High School", "Riverside Academy", "Sunnyside High", "Greenville High School"]
venues = ["Auditorium", "Gymnasium", "Sports Arena", "Convention Center"]
school = rng.choice(schools)
venue = rng.choice(venues)
graduates = int(rng.randrange(500, int(1500 * difficulty), 50))
faculty = int(rng.randrange(100, int(500 * difficulty), 50))
# Ensure total seats allow for integer division of remaining seats
remaining_seats = rng.randint(2, int(10 * difficulty)) * graduates
total = remaining_seats + graduates + faculty
result = generate_from_variables(school, venue, total, graduates, faculty)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_89(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name1: str,
name2: str,
name3: str,
name4: str,
name5: str,
num_dozen: int,
found_first: int,
multiplier: float,
less_amount: int,
fraction: float,
) -> dict[str, Any]:
total_eggs = num_dozen * 12
found_second = found_first * multiplier
found_third = found_second - less_amount
found_fourth = found_third * fraction
total_found = found_first + found_second + found_third + found_fourth
remaining = total_eggs - total_found
question = f"{name1} hid {num_dozen} dozen eggs in the yard for the Easter egg hunt. {name2} finds {found_first} eggs. {name3} finds {multiplier:.0f} times as many as {name2}. {name4} finds {less_amount} less than {name3}, and {name5} finds {fraction:.1f} as many as {name4}. How many eggs are still hidden in the yard?"
answer_cot = f"{name1} hides {num_dozen} x 12 = {total_eggs} eggs.\n"
answer_cot += f"{name2} finds {found_first} eggs.\n"
answer_cot += f"{name3} finds {found_first} x {multiplier:.0f} = {found_second} eggs.\n"
answer_cot += f"{name4} finds {found_second} - {less_amount} = {found_third} eggs.\n"
answer_cot += f"{name5} finds {found_third} x {fraction:.1f} = {found_fourth} eggs.\n"
answer_cot += f"The children find a total of {found_first} + {found_second} + {found_third} + {found_fourth} = {total_found} eggs.\n"
answer_cot += f"The total number of hidden eggs still in the yard is {total_eggs} - {total_found} = {remaining} eggs.\n#### {remaining}"
return {
"question": question,
"answer": format_number(remaining),
"answer_cot": answer_cot,
"answer_value": remaining,
"variables": {
"name1": name1,
"name2": name2,
"name3": name3,
"name4": name4,
"name5": name5,
"num_dozen": num_dozen,
"found_first": found_first,
"multiplier": multiplier,
"less_amount": less_amount,
"fraction": fraction,
"total_eggs": total_eggs,
"total_found": total_found,
"remaining": remaining,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = [
"Emma",
"Liam",
"Olivia",
"Noah",
"Ava",
"Oliver",
"Isabella",
"William",
"Sophia",
"James",
"Charlotte",
"Benjamin",
"Mia",
"Lucas",
"Harper",
]
name1, name2, name3, name4, name5 = rng.sample(names, 5)
num_dozen = int(rng.randint(2, int(10 * difficulty)))
found_first = int(rng.randint(3, int(15 * difficulty)))
multiplier = 2.0 # Using 'twice' as specified
less_amount = int(rng.randint(1, int(5 * difficulty)))
fraction = 0.5 # Using 'half' as specified
# Ensure all conditions are met
total = num_dozen * 12
found_second = found_first * multiplier
found_third = found_second - less_amount
found_fourth = found_third * fraction
total_found = found_first + found_second + found_third + found_fourth
# Regenerate if conditions not met
while not found_third > 0 or not total > total_found or not float(found_fourth).is_integer():
num_dozen = int(rng.randint(2, int(10 * difficulty)))
found_first = int(rng.randint(3, int(15 * difficulty)))
less_amount = int(rng.randint(1, int(5 * difficulty)))
total = num_dozen * 12
found_second = found_first * multiplier
found_third = found_second - less_amount
found_fourth = found_third * fraction
total_found = found_first + found_second + found_third + found_fourth
result = generate_from_variables(
name1, name2, name3, name4, name5, num_dozen, found_first, multiplier, less_amount, fraction
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_90(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
device: str, currency: str, rate1: float, rate2: float, threshold: int, total_mins: int
) -> dict[str, Any]:
first_period = threshold
second_period = total_mins - threshold
cost1 = first_period * rate1
cost2 = second_period * rate2
total_cost = int(cost1 + cost2)
question = f"To make a call from a {device}, you must pay {currency}{rate1} for each minute of your call. After {threshold} minutes, that price drops to {currency}{rate2} per minute. How much would a {total_mins}-minute call cost?"
answer_cot = f"First {threshold} minutes would be a cost of {threshold} * {rate1} = {currency}{int(cost1)}.\nAfter that, there are {total_mins} - {threshold} = {second_period} minutes of the call left.\nAnd these {second_period} minutes cost {second_period} * {rate2} = {currency}{int(cost2)}.\nSo in total, the {total_mins}-minute call would cost {int(cost1)} + {int(cost2)} = {currency}{total_cost}.\n#### {total_cost}"
return {
"question": question,
"answer": format_number(total_cost),
"answer_cot": answer_cot,
"answer_value": total_cost,
"variables": {
"device": device,
"currency": currency,
"rate1": rate1,
"rate2": rate2,
"threshold": threshold,
"total_mins": total_mins,
"first_period_cost": int(cost1),
"second_period_cost": int(cost2),
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
devices = ["payphone", "phone booth", "hotel room phone"]
currencies = ["$", "£", "€"]
device = rng.choice(devices)
currency = rng.choice(currencies)
# First generate threshold and total minutes
threshold = int(rng.randint(10, min(int(50 * difficulty), 40))) # Cap threshold
total_mins = threshold + int(rng.randint(10, min(int(50 * difficulty), 30))) # Generate relative to threshold
# Generate rates working backwards from whole numbers
# We'll generate integers first, then divide to get our rates
rate1_base = rng.randint(20, min(int(50 * difficulty), 40)) # Will become 0.20 to 0.50
rate2_base = rng.randint(10, rate1_base - 5) # Will become 0.10 to rate1-0.05
# Convert to actual rates ensuring they'll produce integer results
rate1 = rate1_base / 100 # Convert to dollars
rate2 = rate2_base / 100
# These rates are guaranteed to:
# 1. Be in the correct range (rate2 < rate1)
# 2. Produce integer results when multiplied by threshold
# 3. Be rounded to 2 decimal places
rate1 = round(rate1, 2)
rate2 = round(rate2, 2)
result = generate_from_variables(device, currency, rate1, rate2, threshold, total_mins)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_91(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, fruit: str, area: str, field_size: int, density: int, months: int
) -> dict[str, Any]:
fruits_per_harvest = field_size * density
harvests_per_year = 12 // months
total_fruits = fruits_per_harvest * harvests_per_year
question = f"{name} has {field_size} {area}s of a {fruit} field. There are {density} {fruit}s per {area}. {name} can harvest his {fruit}s every {months} months. How many {fruit}s can {name} harvest within a year?"
answer_cot = f"{name} has {density} x {field_size}= {fruits_per_harvest} {fruit}s on his field.\n{name} can harvest his {fruit}s 12 ÷ {months} = {harvests_per_year} times per year\nTherefore {name} can harvest {fruits_per_harvest} x {harvests_per_year} = {total_fruits} {fruit}s per year.\n#### {total_fruits}"
return {
"question": question,
"answer": format_number(total_fruits),
"answer_cot": answer_cot,
"answer_value": total_fruits,
"variables": {
"name": name,
"fruit": fruit,
"area": area,
"field_size": field_size,
"density": density,
"months_per_harvest": months,
"fruits_per_harvest": fruits_per_harvest,
"harvests_per_year": harvests_per_year,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"]
fruits = ["pineapple", "mango", "banana", "papaya", "coconut"]
areas = ["hectare", "square yard", "square meter"]
name = rng.choice(names)
fruit = rng.choice(fruits)
area = rng.choice(areas)
field_size = int(rng.randrange(5, int(100 * difficulty), 5))
density = int(rng.randint(2, int(101 * difficulty)))
months = rng.choice([1, 2, 3, 4, 6, 12])
result = generate_from_variables(name, fruit, area, field_size, density, months)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_92(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
product: str,
location: str,
item1: str,
item2: str,
item3: str,
price1: float,
price2: float,
price3: float,
num1: int,
num2: int,
num3: int,
unit: str,
currency: str,
) -> dict[str, Any]:
round_p1 = round(price1)
round_p2 = round(price2)
round_p3 = round(price3)
total = num1 * round_p1 + num2 * round_p2 + num3 * round_p3
question = f"{name} has a {product} stand at the {location}. He sells three kinds of {product}s: {item1}, {item2} and {item3}. He usually sells {item1} for {currency}{price1:.2f} per {unit}, {item2} for {currency}{price2:.2f} per {unit} and {item3} for {currency}{price3:.2f} per {unit}. {name} has no change today, so he has decided to round all his prices to the nearest dollar. If {name} sells {num1} {unit}s of {item1}, {num2} {unit}s of {item2} and {num3} {unit}s of {item3}, how much will he make?"
answer_cot = f"{name} will round his {item1} {'up' if round_p1 > price1 else 'down'} from {currency}{price1:.2f} to {currency}{round_p1}, since the number following the {int(price1)} is {'5 or higher' if round_p1 > price1 else 'less than 5'}.\n"
answer_cot += f"{name} will round his {item2} {'up' if round_p2 > price2 else 'down'} from {currency}{price2:.2f} to {currency}{round_p2}, since the number following the {int(price2)} is {'5 or higher' if round_p2 > price2 else 'less than 5'}.\n"
answer_cot += f"{name} will round his {item3} {'up' if round_p3 > price3 else 'down'} from {currency}{price3:.2f} to {currency}{round_p3}, since the number following the {int(price3)} is {'5 or higher' if round_p3 > price3 else 'less than 5'}.\n"
answer_cot += f"{name} sells {num1} {item1} x {currency}{round_p1} = {currency}{num1*round_p1}\n"
answer_cot += f"{name} sells {num2} {item2} x {currency}{round_p2} = {currency}{num2*round_p2}\n"
answer_cot += f"{name} sells {num3} {item3} x {currency}{round_p3} = {currency}{num3*round_p3}\n"
answer_cot += f"Altogether, {name} will make {currency}{num1*round_p1} + {currency}{num2*round_p2} + {currency}{num3*round_p3} = {currency}{total}\n#### {total}"
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name": name,
"product": product,
"location": location,
"items": [item1, item2, item3],
"original_prices": [price1, price2, price3],
"rounded_prices": [round_p1, round_p2, round_p3],
"quantities": [num1, num2, num3],
"unit": unit,
"currency": currency,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Mike", "David", "James", "Robert", "William", "Richard"]
products = ["vegetable", "flower", "herb", "plant"]
locations = ["local fair", "community market", "street bazaar", "town square"]
items = ["roses", "daisies", "tulips", "lilies", "sunflowers", "orchids"]
units = ["bunch", "basket", "bouquet", "bundle"]
currencies = ["$", "£", "€"]
name = rng.choice(names)
product = rng.choice(products)
location = rng.choice(locations)
item1, item2, item3 = rng.sample(items, 3)
unit = rng.choice(units)
currency = rng.choice(currencies)
# Scale prices by difficulty
price1 = round(rng.uniform(1.26, 3.53 * difficulty), 2)
price2 = round(rng.uniform(2.27, 5.53 * difficulty), 2)
price3 = round(rng.uniform(4.85, 6.53 * difficulty), 2)
num1 = int(rng.randint(5, int(21 * difficulty)))
num2 = int(rng.randint(15, int(31 * difficulty)))
num3 = int(rng.randint(35, int(41 * difficulty)))
result = generate_from_variables(
name, product, location, item1, item2, item3, price1, price2, price3, num1, num2, num3, unit, currency
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_93(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name1: str,
name2: str,
name3: str,
name4: str,
creature: str,
weapon1: str,
weapon2: str,
weapon3: str,
weapon4: str,
weapon5: str,
n1: int,
frac1: float,
mult1: int,
frac2: float,
) -> dict[str, Any]:
kills_arthur = int(n1 * frac1)
kills_walter = int(kills_arthur * mult1)
kills_bruce = int(kills_walter * frac2)
question = f"{name1} slew {n1} {creature} with his mighty {weapon1}, while {name2}, using a {weapon2}, slew {frac1} as many {creature} as {name1}. Using a {weapon3}, {name3} slew {mult1} as many {creature} as {name2}. But {name4}, having forgot his {weapon4} at home, slew {frac2} as many {creature} as {name3} using a {weapon5}. How many {creature} has {name4} slain?"
answer_cot = f"{name2} slew {frac1} as many {creature} as {name1}, or {n1}*{frac1}={kills_arthur} {creature}.\n{name3} slew {mult1} as many {creature} as {name2}, or {mult1}*{kills_arthur}={kills_walter} {creature}.\n{name4} slew {frac2} as many {creature} as {name3}, or {kills_walter}*{frac2}={kills_bruce} {creature}.\n#### {kills_bruce}"
return {
"question": question,
"answer": format_number(kills_bruce),
"answer_cot": answer_cot,
"answer_value": kills_bruce,
"variables": {
"name1": name1,
"name2": name2,
"name3": name3,
"name4": name4,
"creature": creature,
"weapon1": weapon1,
"weapon2": weapon2,
"weapon3": weapon3,
"weapon4": weapon4,
"weapon5": weapon5,
"initial_kills": n1,
"fraction1": frac1,
"multiplier": mult1,
"fraction2": frac2,
"kills_arthur": kills_arthur,
"kills_walter": kills_walter,
"kills_bruce": kills_bruce,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names_male = ["Arthur", "Bruce", "Charles", "David", "Edward", "Frederick", "George", "Henry"]
creatures = ["ogres", "trolls", "goblins", "orcs", "giants"]
weapons1 = ["sword", "mace", "battle axe", "war hammer"]
weapons2 = ["spear", "lance", "javelin", "halberd"]
weapons3 = ["rusty iron axe", "wooden club", "stone hammer", "bone dagger"]
weapons4 = ["sword", "axe", "mace", "hammer"]
weapons5 = ["nail file", "butter knife", "wooden spoon", "feather"]
fractions = [0.25, 0.5, 0.75]
multipliers = [2, 3, 4]
name1, name2, name3, name4 = rng.sample(names_male, 4)
creature = rng.choice(creatures)
weapon1 = rng.choice(weapons1)
weapon2 = rng.choice(weapons2)
weapon3 = rng.choice(weapons3)
weapon4 = rng.choice(weapons4)
weapon5 = rng.choice(weapons5)
# Scale numbers by difficulty but ensure integer results
n1 = int(rng.randrange(50, int(500 * difficulty), 50))
frac1 = rng.choice(fractions)
mult1 = rng.choice(multipliers)
frac2 = rng.choice(fractions)
# Ensure all divisions result in integers
while (
not (n1 * frac1).is_integer()
or not (n1 * frac1 * mult1).is_integer()
or not (n1 * frac1 * mult1 * frac2).is_integer()
):
n1 = int(rng.randrange(50, int(500 * difficulty), 50))
result = generate_from_variables(
name1, name2, name3, name4, creature, weapon1, weapon2, weapon3, weapon4, weapon5, n1, frac1, mult1, frac2
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_94(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, num_shares: int, price_per_share: int, increase_pct: int, decrease_pct: int
) -> dict[str, Any]:
initial_value = num_shares * price_per_share
first_increase = initial_value * increase_pct / 100
value_after_increase = initial_value + first_increase
second_decrease = value_after_increase * decrease_pct / 100
final_value = value_after_increase - second_decrease
question = f"{name} buys {num_shares} shares of a stock for ${price_per_share} each. The stock price increases {increase_pct}% the first year {name} holds it, then decreases {decrease_pct}% in the second year. What is the final value of all {name}'s shares?"
answer_cot = (
f"First find the initial total value of {name}'s purchase: {num_shares} shares * ${price_per_share}/share = ${initial_value}\n"
f"Then find the amount of the first price increase: ${initial_value} * {increase_pct/100} = ${int(first_increase)}\n"
f"Add that amount to the initial value to find the value after the first year: ${initial_value} + ${int(first_increase)} = ${int(value_after_increase)}\n"
f"Then multiply that amount by {decrease_pct}% to find the amount of the decrease in the second year: ${int(value_after_increase)} * {decrease_pct}% = ${int(second_decrease)}\n"
f"Then subtract that amount from the value after the first year to find the final value: ${int(value_after_increase)} - ${int(second_decrease)} = ${int(final_value)}\n"
f"#### {int(final_value)}"
)
return {
"question": question,
"answer": format_number(int(final_value)),
"answer_cot": answer_cot,
"answer_value": int(final_value),
"variables": {
"name": name,
"num_shares": num_shares,
"price_per_share": price_per_share,
"increase_pct": increase_pct,
"decrease_pct": decrease_pct,
"initial_value": initial_value,
"final_value": int(final_value),
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Maria", "Sarah", "Emma", "Isabella", "Sophia", "Mia", "Charlotte"]
name = rng.choice(names)
num_shares = int(rng.randint(5, int(20 * difficulty)))
price_per_share = int(rng.randint(5, int(100 * difficulty)))
increase_pct = int(rng.randrange(10, int(100 * difficulty), 5))
decrease_pct = int(rng.randrange(5, int(50 * difficulty), 5))
# Ensure integer results
while (
not (num_shares * price_per_share * increase_pct / 100).is_integer()
or not (num_shares * price_per_share * (1 + increase_pct / 100) * (1 - decrease_pct / 100)).is_integer()
):
num_shares = int(rng.randint(5, int(20 * difficulty)))
price_per_share = int(rng.randint(5, int(100 * difficulty)))
increase_pct = int(rng.randrange(10, int(100 * difficulty), 5))
decrease_pct = int(rng.randrange(5, int(50 * difficulty), 5))
result = generate_from_variables(name, num_shares, price_per_share, increase_pct, decrease_pct)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_95(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name1: str, name2: str, relation: str, food: str, n1: int, n2: int, n3: int, time_unit: str, time_period: str
) -> dict[str, Any]:
daily_total = n1 + n2 + n3
total = daily_total * (7 if time_period == "week" else 30)
question = f"{name1} eats {n1} {food} per {time_unit}, {name2} eats {n2} {food} per {time_unit}, and their {relation} eats {n3} {food} per {time_unit}. How many {food} does this family eat in one {time_period}?"
answer_cot = f"The number of {food} they eat in one {time_unit} is {n1} + {n2} + {n3} = {daily_total} {food}.\nThe number of {food} they eat in a {time_period} is {daily_total} * {7 if time_period == 'week' else 30} = {total} {food}.\n#### {total}"
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name1": name1,
"name2": name2,
"relation": relation,
"food": food,
"daily_servings1": n1,
"daily_servings2": n2,
"daily_servings3": n3,
"daily_total": daily_total,
"time_unit": time_unit,
"time_period": time_period,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
name1_options = ["A father", "A grandfather", "An uncle"]
name2_options = ["his wife", "his partner", "his spouse"]
relation_options = ["daughter", "son", "grandchild"]
food_options = ["pizzas", "burritos", "tacos", "sushi rolls", "hamburgers"]
name1 = rng.choice(name1_options)
name2 = rng.choice(name2_options)
relation = rng.choice(relation_options)
food = rng.choice(food_options)
n1 = int(rng.randint(2, int(9 * difficulty)))
n2 = int(rng.randint(2, int(9 * difficulty)))
n3 = int(rng.randint(2, int(9 * difficulty)))
time_unit = "day"
time_period = rng.choice(["week", "month"])
result = generate_from_variables(name1, name2, relation, food, n1, n2, n3, time_unit, time_period)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_96(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, food: str, animal1: str, animal2: str, n1: int, n2: int, k1: int, k2: int, unit: str
) -> dict[str, Any]:
animal2_amount = 2 * n1 - n2 # Amount per sheep
animal2_total = k2 * animal2_amount # Total for sheep
animal1_total = k1 * n1 # Total for goats
total = animal1_total + animal2_total
question = f"{name} is feeding his livestock {food}. Each {animal1} needs {n1} {unit}, and each {animal2} needs {n2} {unit} less than twice the amount each {animal1} needs. If there are {k1} {animal1}s and {k2} {animal2}s, how many {unit} of {food} does {name} need?"
answer_cot = (
f"First figure out how much {food} each {animal2} needs: {n1} {unit} * 2 - {n2} = {animal2_amount} {unit}/{animal2}\n"
f"Now figure out how much {food} total the {animal2}s need: {animal2_amount} {unit}/{animal2} * {k2} {animal2} = {animal2_total} {unit}\n"
f"Now figure out how much {food} total the {animal1}s need: {n1} {unit}/{animal1} * {k1} {animal1}s = {animal1_total} {unit}\n"
f"Now add the two amounts of {food} to find the total: {animal2_total} {unit} + {animal1_total} {unit} = {total} {unit}\n#### {total}"
)
return {
"question": question,
"answer": format_number(total),
"answer_cot": answer_cot,
"answer_value": total,
"variables": {
"name": name,
"food": food,
"animal1": animal1,
"animal2": animal2,
"n1": n1,
"n2": n2,
"k1": k1,
"k2": k2,
"unit": unit,
"animal2_amount": animal2_amount,
"animal2_total": animal2_total,
"animal1_total": animal1_total,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"]
foods = ["hay", "grain", "feed", "silage"]
animals = ["goat", "cow", "horse", "donkey", "llama", "alpaca", "pig", "turkey", "duck"]
units = ["pounds", "kilograms", "kg"]
name = rng.choice(names)
food = rng.choice(foods)
animal1, animal2 = rng.sample(animals, 2)
unit = rng.choice(units)
n1 = int(rng.randint(3, int(15 * difficulty)))
n2 = int(rng.randint(1, int(10 * difficulty)))
# Ensure 2*n1 - n2 > 0
while 2 * n1 - n2 <= 0:
n1 = int(rng.randint(3, int(15 * difficulty)))
n2 = int(rng.randint(1, int(10 * difficulty)))
k1 = int(rng.randint(10, int(50 * difficulty)))
k2 = int(rng.randint(10, int(50 * difficulty)))
result = generate_from_variables(name, food, animal1, animal2, n1, n2, k1, k2, unit)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_97(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, mult_run: int, frac_skip: float, skip_speed: int, total_time: int, frac_run: float, frac_walk: float
) -> dict[str, Any]:
run_speed = skip_speed / frac_skip
walk_speed = run_speed / mult_run
walk_hours = total_time * frac_walk
run_hours = total_time * frac_run
run_dist = run_hours * run_speed
walk_dist = walk_hours * walk_speed
total_dist = int(run_dist + walk_dist)
question = f"{name} can run {mult_run} times faster than she can walk, but she can skip at a rate of speed that is {frac_skip:.1f} as fast as she can run. If she can skip at {skip_speed} miles per hour, how many miles can she travel in {total_time} hours if she spends {frac_run:.2f} of the time running and {frac_walk:.2f} of the time walking?"
answer_cot = f"""If {name} can skip at {frac_skip:.1f} the speed she can run, then she can run at {skip_speed}*{1/frac_skip:.1f}={run_speed} miles per hour.
And since she can run at a speed that is {mult_run} times faster than she can walk, this means she can walk at {run_speed}/{mult_run}={walk_speed} miles per hour.
If {frac_walk:.2f} of the time is spent walking, then she walks for {total_time}*{frac_walk:.2f}={walk_hours} hours.
If {frac_run:.2f} of the time is spent running, then she runs for {total_time}-{walk_hours}={run_hours} hours.
Thus, she runs for {run_hours} hours at {run_speed} miles per hour, or {run_hours}*{run_speed}={run_dist} miles.
She walks for {walk_hours} hours at {walk_speed} miles per hour, or {walk_hours}*{walk_speed}={walk_dist} miles.
Thus, altogether, she travels {run_dist}+{walk_dist}={total_dist} miles.
#### {total_dist}"""
return {
"question": question,
"answer": format_number(total_dist),
"answer_cot": answer_cot,
"answer_value": total_dist,
"variables": {
"name": name,
"mult_run": mult_run,
"frac_skip": frac_skip,
"skip_speed": skip_speed,
"total_time": total_time,
"frac_run": frac_run,
"frac_walk": frac_walk,
"run_speed": run_speed,
"walk_speed": walk_speed,
"total_dist": total_dist,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["Dana", "Emma", "Sarah", "Julia", "Sophie", "Maria"]
name = rng.choice(names)
# Keep simple fractions constant
frac_skip = 0.5
frac_run = 1 / 3
frac_walk = 2 / 3
# First generate skip_speed that ensures skip_speed/frac_skip is integer and < 13
# Since frac_skip is 0.5, skip_speed should be a multiple of 0.5 and < 6.5
valid_skip_speeds = [2, 3, 4, 5, 6]
skip_speed = rng.choice(valid_skip_speeds)
# Calculate skip_rate = skip_speed/frac_skip (will be integer and < 13)
skip_rate = skip_speed / frac_skip
# Generate multiplier that will create valid divisions
mult_run = rng.randint(2, min(int(6 * difficulty), 5))
# For total_time, we need:
# - total_time * frac_run (1/3) to be integer
# - total_time * frac_walk (2/3) to be integer
# - total_time * frac_walk * (skip_rate/mult_run) to be integer
# So total_time should be multiple of 6 to handle fractions
# and should make the skip calculation work
base_time = 6 # Multiple of both 3 and 2 for fractions
max_time = min(int(12 * difficulty), 12)
valid_times = [
t
for t in range(base_time, max_time + 1, base_time)
if (t * frac_walk * (skip_rate / mult_run)).is_integer()
]
if not valid_times:
valid_times = [6] # Fallback to smallest valid time
total_time = rng.choice(valid_times)
result = generate_from_variables(name, mult_run, frac_skip, skip_speed, total_time, frac_run, frac_walk)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_98(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str,
vehicle: str,
weight_vehicle: int,
item: str,
weight_item: int,
passenger_type: str,
num_passengers: int,
weight_passenger: int,
unit: str,
force_percent: int,
) -> dict[str, Any]:
total_passenger_weight = num_passengers * weight_passenger
total_weight = weight_vehicle + weight_item + total_passenger_weight
force_needed = int((total_weight * force_percent) / 100)
question = f"{name}'s {vehicle} breaks down. The {vehicle} weighs {weight_vehicle} {unit} and he has {item} in it weighing {weight_item} {unit}. He also has his {num_passengers} young {passenger_type} who weigh {weight_passenger} {unit} each in it. If the force to move the {vehicle} is {force_percent}% of the weight, how much force does he need to push the {vehicle}?"
answer_cot = f"His {num_passengers} {passenger_type} weigh {weight_passenger}*{num_passengers}={total_passenger_weight} {unit}\nSo the total weight of the {vehicle} and everything is {weight_vehicle}+{weight_item}+{total_passenger_weight}={total_weight} {unit}\nSo he needs to generate {total_weight}*{force_percent/100}={force_needed} {unit}\n#### {force_needed}"
return {
"question": question,
"answer": format_number(force_needed),
"answer_cot": answer_cot,
"answer_value": force_needed,
"variables": {
"name": name,
"vehicle": vehicle,
"weight_vehicle": weight_vehicle,
"item": item,
"weight_item": weight_item,
"passenger_type": passenger_type,
"num_passengers": num_passengers,
"weight_passenger": weight_passenger,
"unit": unit,
"force_percent": force_percent,
"total_weight": total_weight,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["John", "Michael", "David", "James", "Robert", "William", "Richard"]
vehicles = ["car", "van", "truck", "SUV"]
items = ["luggage", "groceries", "equipment", "furniture"]
passenger_types = ["children", "friends", "colleagues", "teammates"]
units = ["pounds", "kilograms"]
name = rng.choice(names)
vehicle = rng.choice(vehicles)
item = rng.choice(items)
passenger_type = rng.choice(passenger_types)
unit = rng.choice(units)
# Generate weights that are multiples of 100 to make force calculations easier
# This ensures any percentage will result in integers
weight_vehicle = int(rng.randrange(10, min(int(30 * difficulty), 25)) * 100) # 1000-2500 in steps of 100
weight_item = int(rng.randrange(1, min(int(5 * difficulty), 4)) * 100) # 100-400 in steps of 100
weight_passenger = int(rng.randrange(10, min(int(20 * difficulty), 15)) * 5) # 50-75 in steps of 5
num_passengers = int(rng.randint(2, min(int(5 * difficulty), 4)))
# Calculate total weight - will be multiple of 5 due to construction
total_weight = weight_vehicle + weight_item + (num_passengers * weight_passenger)
# Since total_weight is multiple of 5, we can choose force_percent that guarantees integer result
# We'll use multiples of 5 for force_percent to ensure clean division
force_percent = 5 * rng.randint(1, min(int(1.2 * difficulty), 3)) # Will give 5%, 10%, 15%
result = generate_from_variables(
name,
vehicle,
weight_vehicle,
item,
weight_item,
passenger_type,
num_passengers,
weight_passenger,
unit,
force_percent,
)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
def generate_99(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
def generate_from_variables(
name: str, currency: str, initial_amount: float, quantity: int, item: str, store_type: str, unit_price: float
) -> dict[str, Any]:
total_cost = quantity * unit_price
remaining = initial_amount - total_cost
question = f"{name} has {currency}{initial_amount:.2f} and wants to buy {quantity} {item}s from a bin at the {store_type} store. Each {item} costs {currency}{unit_price:.2f}. How much money does {name} have left after paying for the {item}s?"
answer_cot = f"{name} paid {quantity} * {currency}{unit_price:.2f} = {currency}{total_cost:.2f} for the {item}s.\n{name} has {currency}{initial_amount:.2f} - {currency}{total_cost:.2f} = {currency}{int(remaining)} left.\n#### {int(remaining)}"
return {
"question": question,
"answer": format_number(int(remaining)),
"answer_cot": answer_cot,
"answer_value": int(remaining),
"variables": {
"name": name,
"currency": currency,
"initial_amount": initial_amount,
"quantity": quantity,
"item": item,
"store_type": store_type,
"unit_price": unit_price,
"total_cost": total_cost,
"remaining": remaining,
},
}
def generate_example(rng: Random, difficulty: float = 1.0) -> dict[str, Any]:
names = ["David", "John", "Michael", "James", "William", "Robert"]
currencies = ["$", "€", "£"]
items = ["screw", "nail", "washer", "nut", "anchor"]
store_types = ["hardware", "home improvement", "construction supply"]
name = rng.choice(names)
currency = rng.choice(currencies)
item = rng.choice(items)
store_type = rng.choice(store_types)
# Generate values ensuring conditions are met
quantity = int(rng.randint(15, int(60 * difficulty)))
unit_price = round(rng.uniform(0.01, min(1.0, 1.0 * difficulty)), 2)
# Ensure initial amount is sufficient and result is integer
total_cost = quantity * unit_price
remaining = rng.randint(1, int(100 * difficulty))
initial_amount = total_cost + remaining
result = generate_from_variables(name, currency, initial_amount, quantity, item, store_type, unit_price)
return {
"question": result["question"],
"answer": result["answer"],
"metadata": {
"difficulty": difficulty,
"answer_value": result["answer_value"],
"answer_cot": result["answer_cot"],
"variables": result["variables"],
},
}
return generate_example(rng, difficulty)
Reference in a new issue View git blame Copy permalink