diff --git a/GALLERY.md b/GALLERY.md index 67cbebbc..eeec0119 100644 --- a/GALLERY.md +++ b/GALLERY.md @@ -18,6 +18,7 @@ This gallery shows examples from all available datasets using their default conf - [fraction_simplification](#fraction_simplification) - [game_of_life](#game_of_life) - [gcd](#gcd) +- [gsm_symbolic](#gsm_symbolic) - [intermediate_integration](#intermediate_integration) - [lcm](#lcm) - [leg_counting](#leg_counting) @@ -842,6 +843,32 @@ Metadata: {'numbers': [297, 30], 'result': 3} ```` +### gsm_symbolic +Default configuration: +```python +seed = 42 +size = 500 +``` + +Example tasks: +```` +Example 1: +Question: There are currently 16 orange balls, 12 yellow balls, and 44 blue balls in the shop. orange balls cost $13, yellow balls cost $10 and blue balls cost $6. How much will the shop have received after all the balls are sold? +Answer: 592 +Metadata: {'difficulty': 1.0, 'answer_value': 592, 'answer_cot': 'For the orange balls, 16 balls * $13/ball = $208.\nFor the yellow balls, 12 balls * $10/ball = $120.\nFor the blue balls, 44 balls * $6/ball = $264.\nFor all balls, $208 + $120 + $264 = $592.\n#### 592', 'variables': {'store': 'shop', 'colors': ['orange', 'yellow', 'blue'], 'quantities': [16, 12, 44], 'prices': [13, 10, 6], 'currency': '$', 'subtotals': [208, 120, 264], 'total': 592}} + +Example 2: +Question: A plumber works for 3 weeks every month and for 4 days every week. If he gets paid £150 every day, how much does he earn if he works for a year? +Answer: 21600 +Metadata: {'difficulty': 1.0, 'answer_value': 21600, 'answer_cot': 'The plumber works for 4 days every week and works for 3 weeks every month so he works for 4 days/week * 3 weeks/month = 12 days/month\nIf he earns £150 every day he then earns £150/day * 12 days/month = £1800/month\nA year is equal to 12 months so every year he earns £1800/month * 12 months/year = £21600\n#### 21600', 'variables': {'occupation': 'plumber', 'weeks_per_month': 3, 'days_per_week': 4, 'pay_per_day': 150, 'currency': '£', 'days_per_month': 12, 'monthly_pay': 1800}} + +Example 3: +Question: Ava sliced an mango into 33 pieces. She ate 5 slice, her cousin ate 7 more than her, and her brother ate 4 more than her cousin. How many slices of mango did they all eat? +Answer: 33 +Metadata: {'difficulty': 1.0, 'answer_value': 33, 'answer_cot': 'Her cousin ate 5 + 7 = 12 slices.\nHer brother ate 12 + 4 = 16 slices.\nThey ate a total of 5 + 12 + 16 = 33 slices.\n#### 33', 'variables': {'name': 'Ava', 'fruit': 'mango', 'total_slices': 33, 'first_person_slices': 5, 'second_person_extra': 7, 'third_person_extra': 4, 'sibling1': 'cousin', 'sibling2': 'brother', 'total_eaten': 33}} + +```` + ### intermediate_integration Generates intermediate integration problem - either by substitution or by parts @@ -2034,7 +2061,7 @@ Example tasks: ```` Example 1: Question: Transform the word ladder 'HAND' to 'GLEE' by changing one letter at a time. -Answer: HAND,RAND,REND,REED,FEED,FLED,FLEE,GLEE +Answer: HAND,RAND,REND,FEND,FEED,FLED,FLEE,GLEE Metadata: {'start_word': 'HAND', 'end_word': 'GLEE', 'word_length': 4, 'chain_length': 8} Example 2: @@ -2044,7 +2071,7 @@ Metadata: {'start_word': 'JAZZ', 'end_word': 'DORM', 'word_length': 4, 'chain_le Example 3: Question: Transform the word ladder 'SNOG' to 'SUQS' by changing one letter at a time. -Answer: SNOG,SNAG,SAAG,SANG,SUNG,SUNS,SUQS +Answer: SNOG,SNAG,SAAG,SANG,SANS,SUNS,SUQS Metadata: {'start_word': 'SNOG', 'end_word': 'SUQS', 'word_length': 4, 'chain_length': 7} ```` @@ -2135,15 +2162,16 @@ Question: This is a logic puzzle. There are 4 houses (numbered 1 on the left, 4 - Each person has a favorite drink: tea, water, milk, coffee - The people keep different animals: fish, cat, horse, bird -1. The fish enthusiast is directly left of Alice. -2. The cat lover is the person who uses a OnePlus 9. -3. The tea drinker is Arnold. -4. The person who uses an iPhone 13 is in the third house. -5. The one who only drinks water is directly left of the cat lover. -6. The fish enthusiast is the coffee drinker. -7. Peter is the person who uses a Samsung Galaxy S21. -8. The bird keeper is directly left of the tea drinker. -9. The person who uses an iPhone 13 is the fish enthusiast. +1. The one who only drinks water is Peter. +2. The cat lover is in the second house. +3. The coffee drinker is the fish enthusiast. +4. The person who uses a OnePlus 9 is the tea drinker. +5. Peter is directly left of Arnold. +6. The person who keeps horses is in the fourth house. +7. The person who keeps horses is Alice. +8. Alice is the person who uses a Google Pixel 6. +9. The person who uses a Samsung Galaxy S21 is the one who only drinks water. +10. Peter is in the first house. What is Name of the person who lives in House 1? Answer: peter @@ -2152,19 +2180,19 @@ Metadata: {'num_people': 4, 'num_characteristics': 4} Example 2: Question: This is a logic puzzle. There are 4 houses (numbered 1 on the left, 4 on the right), from the perspective of someone standing across the street from them. Each has a different person in them. They have different characteristics: - Each person has a unique name: alice, eric, arnold, peter - - Each mother is accompanied by their child: fred, samantha, meredith, bella + - Each mother is accompanied by their child: fred, bella, samantha, meredith - The people are of nationalities: norwegian, swede, brit, dane - - Everyone has something different for lunch: grilled cheese, pizza, stew, spaghetti + - Everyone has something different for lunch: spaghetti, grilled cheese, pizza, stew -1. The person who loves the spaghetti eater is in the third house. -2. The Dane is in the second house. -3. Alice is in the first house. -4. The person who loves eating grilled cheese is the person's child is named Bella. -5. The person who is a pizza lover is directly left of the person's child is named Fred. -6. The person who loves the stew is the person's child is named Fred. -7. The person's child is named Bella is Arnold. -8. The person's child is named Meredith is the British person. -9. The Norwegian is Peter. +1. The person who loves the stew is Eric. +2. The person's child is named Fred is directly left of the person who loves the spaghetti eater. +3. The person's child is named Samantha is Peter. +4. The person who is a pizza lover is the person's child is named Meredith. +5. The person's child is named Meredith is directly left of Eric. +6. The British person is the person's child is named Meredith. +7. The person's child is named Samantha is in the third house. +8. Arnold is the Swedish person. +9. The person's child is named Samantha is the Norwegian. What is Name of the person who lives in House 1? Answer: alice @@ -2172,20 +2200,21 @@ Metadata: {'num_people': 4, 'num_characteristics': 4} Example 3: Question: This is a logic puzzle. There are 4 houses (numbered 1 on the left, 4 on the right), from the perspective of someone standing across the street from them. Each has a different person in them. They have different characteristics: - - Each person has a unique name: eric, alice, arnold, peter - - Everyone has a different favorite cigar: dunhill, prince, blue master, pall mall - - Everyone has something different for lunch: stew, pizza, grilled cheese, spaghetti - - Each person has a favorite color: red, white, green, yellow + - Each person has a unique name: alice, peter, eric, arnold + - Everyone has a different favorite cigar: prince, dunhill, pall mall, blue master + - Everyone has something different for lunch: stew, pizza, spaghetti, grilled cheese + - Each person has a favorite color: green, red, yellow, white -1. The person who loves eating grilled cheese is the person whose favorite color is red. -2. Arnold is the person who loves yellow. -3. The person who loves the spaghetti eater is the person who smokes Blue Master. -4. The person partial to Pall Mall is Peter. -5. The Dunhill smoker is directly left of the person partial to Pall Mall. -6. The person who is a pizza lover is Eric. -7. The person who is a pizza lover is in the fourth house. -8. The person whose favorite color is green is in the first house. +1. Eric is the person who loves white. +2. Alice and the Dunhill smoker are next to each other. +3. The person who loves the stew is Arnold. +4. The person whose favorite color is green is directly left of the person who loves the stew. +5. The person who smokes Blue Master is Alice. +6. Alice is the person who loves the spaghetti eater. +7. The person partial to Pall Mall is directly left of Eric. +8. The Prince smoker is in the fourth house. 9. The person who loves yellow is in the second house. +10. Arnold and the person who loves eating grilled cheese are next to each other. What is Name of the person who lives in House 1? Answer: alice diff --git a/notebooks/gsm-symbolic-cot.txt b/notebooks/gsm-symbolic-cot.txt index 9ae6f059..3ebc054d 100644 --- a/notebooks/gsm-symbolic-cot.txt +++ b/notebooks/gsm-symbolic-cot.txt @@ -18,11 +18,11 @@ from typing import Dict, 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': f'{{total_time}}', @@ -30,7 +30,7 @@ def generate_from_variables(time_per_interval: int, distance_per_interval: int, 'answer_value': total_time, 'variables': {{ 'time_per_interval': time_per_interval, - 'distance_per_interval': distance_per_interval, + 'distance_per_interval': distance_per_interval, 'total_distance': total_distance, 'intervals': intervals }} @@ -40,13 +40,13 @@ def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: # Generate random values scaled by difficulty distance_per_interval = int(rng.randint(2, int(10 * difficulty))) time_per_interval = int(rng.randint(5, int(30 * difficulty))) - + # Ensure total distance is divisible by distance_per_interval num_intervals = rng.randint(2, int(20 * difficulty)) total_distance = distance_per_interval * num_intervals - + result = generate_from_variables(time_per_interval, distance_per_interval, total_distance) - + return {{ 'question': result['question'], 'answer': result['answer'], @@ -78,15 +78,15 @@ OUTPUT 2: Output in the form which should be generated from random import Random from typing import Dict, Any -def generate_from_variables(name: str, food: str, rate_per_min: int, batch_size: int, +def generate_from_variables(name: str, food: str, rate_per_min: int, batch_size: int, time_per_batch: int, total_amount: int) -> Dict[str, Any]: peel_time = total_amount // rate_per_min num_batches = total_amount // batch_size cook_time = num_batches * time_per_batch total_time = peel_time + cook_time - + question = f"{name} can peel {rate_per_min} {food}s a minute and saute {batch_size} {food}s in {time_per_batch} minutes. How long will it take her to peel and saute {total_amount} {food}s?" - + answer_cot = f"First find how long it takes {name} to peel the {food}: {total_amount} {food} / {rate_per_min} {food}/minute = {peel_time} minutes\n" \ f"Then find how many batches of {food} she needs to cook: {total_amount} {food} / {batch_size} {food}/batch = {num_batches} batches\n" \ f"Then multiply the number of batches by the time per batch to find the total cook time: {num_batches} batches * {time_per_batch} minutes/batch = {cook_time} minutes\n" \ @@ -102,7 +102,7 @@ def generate_from_variables(name: str, food: str, rate_per_min: int, batch_size: 'name': name, 'food': food, 'rate_per_min': rate_per_min, - 'batch_size': batch_size, + 'batch_size': batch_size, 'time_per_batch': time_per_batch, 'total_amount': total_amount, 'peel_time': peel_time, @@ -113,21 +113,21 @@ def generate_from_variables(name: str, food: str, rate_per_min: int, batch_size: def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Emily", "Sarah", "Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia"] foods = ["shrimp", "onion", "carrot", "mushroom", "clam"] - + name = rng.choice(names) food = rng.choice(foods) - + rate_per_min = int(rng.randint(4, int(15 * difficulty))) batch_size = int(rng.randint(20, int(50 * difficulty)) // 5 * 5) time_per_batch = int(rng.randint(5, int(20 * difficulty))) - + # Ensure total is divisible by both rate_per_min and batch_size lcm = rate_per_min * batch_size // math.gcd(rate_per_min, batch_size) num_lcm = rng.randint(1, int(4 * difficulty)) total_amount = lcm * num_lcm result = generate_from_variables(name, food, rate_per_min, batch_size, time_per_batch, total_amount) - + return { 'question': result['question'], 'answer': result['answer'], @@ -160,14 +160,14 @@ OUTPUT 3: Output in the form which should be generated from random import Random from typing import Dict, Any -def generate_from_variables(family: str, item: str, total: int, n1: int, n2: int, +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': f'{n3}', @@ -181,7 +181,7 @@ def generate_from_variables(family: str, item: str, total: int, n1: int, n2: int 'flavor2_count': n2, 'flavor3_count': n3, 'flavor1': flavor1, - 'flavor2': flavor2, + 'flavor2': flavor2, 'flavor3': flavor3 } } @@ -190,22 +190,22 @@ 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))) - + # Ensure conditions are met 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'], @@ -218,7 +218,7 @@ def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: } def original_example() -> Dict[str, Any]: - return generate_from_variables("Adams", "cookie", 7995, 2595, 3075, + return generate_from_variables("Adams", "cookie", 7995, 2595, 3075, "rainbow", "oatmeal", "chocolate chip") ``` @@ -239,17 +239,17 @@ OUTPUT 4: Output in the form which should be generated from random import Random from typing import Dict, Any -def generate_from_variables(name: str, event: str, food: str, obj: str, - package_husband: int, used_spoons: int, +def generate_from_variables(name: str, event: str, food: str, obj: str, + package_husband: int, used_spoons: int, remaining_spoons: int) -> Dict[str, Any]: - + total_spoons = remaining_spoons + used_spoons package_julia = total_spoons - package_husband - + question = f"{name} was preparing for a {event} at her house, where she intended to serve {food}. She noticed that she was out of plastic {obj}, so she bought a new package of {obj}. Later, her husband also bought a package of {package_husband} new {obj} and gave them to {name}. While {name} was making the {food}, she used {used_spoons} of the {obj} to sample her {food}. Later, when she went to set the table, she had a total of {remaining_spoons} {obj}. How many {obj} were in the package that {name} bought?" - + answer_cot = f"The total number of {obj} from {name} and her husband was {remaining_spoons}+{used_spoons}={total_spoons} {obj}.\nSince the husband bought a package of {package_husband} {obj}, then {name}'s package contained {total_spoons}-{package_husband}={package_julia} {obj}.\n#### {package_julia}" - + return { 'question': question, 'answer': f'{package_julia}', @@ -257,7 +257,7 @@ def generate_from_variables(name: str, event: str, food: str, obj: str, 'answer_value': package_julia, 'variables': { 'name': name, - 'event': event, + 'event': event, 'food': food, 'obj': obj, 'package_husband': package_husband, @@ -271,22 +271,22 @@ def generate_from_variables(name: str, event: str, food: str, obj: str, def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] events = ['lunch party', 'birthday party', 'potluck party', 'baby shower', 'game night'] - foods = ['roast chicken', 'grilled salmon', 'beef stew', 'vegetable lasagna', + foods = ['roast chicken', 'grilled salmon', 'beef stew', 'vegetable lasagna', 'stuffed peppers', 'shrimp scampi', 'creme brulee'] objects = ['spoons', 'forks', 'plates'] - + name = rng.choice(names) event = rng.choice(events) food = rng.choice(foods) obj = rng.choice(objects) - + package_husband = int(rng.randint(5, int(20 * difficulty))) used_spoons = int(rng.randint(3, int(10 * difficulty))) remaining_spoons = int(rng.randint(12, int(40 * difficulty))) - - result = generate_from_variables(name, event, food, obj, package_husband, + + result = generate_from_variables(name, event, food, obj, package_husband, used_spoons, remaining_spoons) - + return { 'question': result['question'], 'answer': result['answer'], @@ -299,6 +299,6 @@ def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: } def original_example() -> Dict[str, Any]: - return generate_from_variables('Julia', 'dinner party', 'stew', 'spoons', + return generate_from_variables('Julia', 'dinner party', 'stew', 'spoons', 5, 3, 12) ``` diff --git a/notebooks/test_generator_files.py b/notebooks/test_generator_files.py index bc6d7196..a41bed3b 100644 --- a/notebooks/test_generator_files.py +++ b/notebooks/test_generator_files.py @@ -1,33 +1,32 @@ -import os import importlib.util +import os from datetime import datetime -from typing import Dict, Any +from typing import Any, Dict + def test_generator_files(directory_path: str) -> None: """Test all generator files in directory""" - + # Setup logging timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") log_file = f"generator_tests_{timestamp}.log" - - with open(log_file, 'w') as log: + + with open(log_file, "w") as log: # Walk through directory for root, _, files in os.walk(directory_path): for file in files: - if not file.endswith('.py'): + if not file.endswith(".py"): continue - + filepath = os.path.join(root, file) try: # Import module dynamically - spec = importlib.util.spec_from_file_location( - file[:-3], filepath - ) + spec = importlib.util.spec_from_file_location(file[:-3], filepath) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) - + # Check for original_example function - if hasattr(module, 'original_example'): + if hasattr(module, "original_example"): try: result = module.original_example() if isinstance(result, dict): @@ -38,16 +37,16 @@ def test_generator_files(directory_path: str) -> None: message = f"ERROR: {file} - execution failed: {str(e)}\n" else: message = f"ERROR: {file} - no original_example() found\n" - + except Exception as e: message = f"ERROR: {file} - import failed: {str(e)}\n" - + # Log result log.write(message) - print(message, end='') + print(message, end="") + # Usage if __name__ == "__main__": generator_path = "../reasoning_gym/arithmetic/gsm_symbolic" test_generator_files(generator_path) - \ No newline at end of file diff --git a/reasoning_gym/arithmetic/__init__.py b/reasoning_gym/arithmetic/__init__.py index 9047d55f..9a6d775a 100644 --- a/reasoning_gym/arithmetic/__init__.py +++ b/reasoning_gym/arithmetic/__init__.py @@ -12,10 +12,10 @@ from .calendar_arithmetic import CalendarArithmeticConfig, CalendarArithmeticDat from .chain_sum import ChainSum, ChainSumConfig from .fraction_simplification import FractionSimplificationConfig, FractionSimplificationDataset from .gcd import GCDConfig, GCDDataset +from .gsm_symbolic.gsm_symbolic_datasets import GSMSymbolicDataset, GSMSymbolicDatasetConfig from .lcm import LCMConfig, LCMDataset from .leg_counting import LegCountingConfig, LegCountingDataset from .prime_factorization import PrimeFactorizationConfig, PrimeFactorizationDataset -from .gsm_symbolic.gsm_symbolic_datasets import GSMSymbolicDataset, GSMSymbolicDatasetConfig from .time_intervals import TimeIntervalsConfig, TimeIntervalsDataset __all__ = [ diff --git a/reasoning_gym/arithmetic/gsm_symbolic/generators.py b/reasoning_gym/arithmetic/gsm_symbolic/generators.py index 2b00e426..22fb5d4b 100644 --- a/reasoning_gym/arithmetic/gsm_symbolic/generators.py +++ b/reasoning_gym/arithmetic/gsm_symbolic/generators.py @@ -1,170 +1,179 @@ -from random import Random -from typing import Dict, Any import math from fractions import Fraction +from random import Random +from typing import Any, Dict + def generate_0(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - - def generate_from_variables(name: str, food: str, peel_rate: int, batch_size: int, - time_per_batch: int, total_amount: int) -> Dict[str, Any]: - + + def generate_from_variables( + name: str, food: str, peel_rate: int, batch_size: int, time_per_batch: int, total_amount: int + ) -> Dict[str, Any]: + peel_time = total_amount // peel_rate - num_batches = total_amount // batch_size + num_batches = total_amount // batch_size cook_time = num_batches * time_per_batch total_time = peel_time + cook_time question = f"{name} can peel {peel_rate} {food}s a minute and saute {batch_size} {food}s in {time_per_batch} minutes. How long will it take her to peel and saute {total_amount} {food}s?" - - answer_cot = f"First find how long it takes {name} to peel the {food}: {total_amount} {food} / {peel_rate} {food}/minute = {peel_time} minutes\n" \ - f"Then find how many batches of {food} she needs to cook: {total_amount} {food} / {batch_size} {food}/batch = {num_batches} batches\n" \ - f"Then multiply the number of batches by the time per batch to find the total cook time: {num_batches} batches * {time_per_batch} minutes/batch = {cook_time} minutes\n" \ - f"Then add the peeling time to find the total time {name} spends: {cook_time} minutes + {peel_time} minutes = {total_time} minutes\n" \ - f"#### {total_time}" + + answer_cot = ( + f"First find how long it takes {name} to peel the {food}: {total_amount} {food} / {peel_rate} {food}/minute = {peel_time} minutes\n" + f"Then find how many batches of {food} she needs to cook: {total_amount} {food} / {batch_size} {food}/batch = {num_batches} batches\n" + f"Then multiply the number of batches by the time per batch to find the total cook time: {num_batches} batches * {time_per_batch} minutes/batch = {cook_time} minutes\n" + f"Then add the peeling time to find the total time {name} spends: {cook_time} minutes + {peel_time} minutes = {total_time} minutes\n" + f"#### {total_time}" + ) return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'name': name, - 'food': food, - 'peel_rate': peel_rate, - 'batch_size': batch_size, - 'time_per_batch': time_per_batch, - 'total_amount': total_amount, - 'peel_time': peel_time, - 'cook_time': cook_time - } + "question": question, + "answer": str(total_time), + "answer_cot": answer_cot, + "answer_value": total_time, + "variables": { + "name": name, + "food": food, + "peel_rate": peel_rate, + "batch_size": batch_size, + "time_per_batch": time_per_batch, + "total_amount": total_amount, + "peel_time": peel_time, + "cook_time": cook_time, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names_female = ["Emily", "Sarah", "Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia"] foods = ["shrimp", "onion", "carrot", "mushroom", "clam"] - + name = rng.choice(names_female) food = rng.choice(foods) - + peel_rate = int(rng.randint(4, int(15 * difficulty))) batch_size = int(rng.randrange(20, int(50 * difficulty), 5)) time_per_batch = int(rng.randint(5, int(20 * difficulty))) - + # Ensure total is divisible by both peel_rate and batch_size lcm = peel_rate * batch_size // math.gcd(peel_rate, batch_size) num_lcm = rng.randint(1, int(4 * difficulty)) total_amount = lcm * num_lcm - + result = generate_from_variables(name, food, peel_rate, batch_size, time_per_batch, 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'] - } + "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_1(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, family: str, blocks: int, animals: int, - rings: int, total: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, family: str, blocks: int, animals: int, rings: int, total: int + ) -> Dict[str, Any]: bouncy_balls = total - (blocks + animals + rings) - + question = f"When {name} watches her {family}, she gets out a variety of toys for him. The bag of building blocks has {blocks} blocks in it. The bin of stuffed animals has {animals} stuffed animals inside. The tower of stacking rings has {rings} multicolored rings on it. {name} recently bought a tube of bouncy balls, bringing her total number of toys for her {family} up to {total}. How many bouncy balls came in the tube?" - + answer_cot = f"Let T be the number of bouncy balls in the tube.\nAfter buying the tube of balls, {name} has {blocks} + {animals} + {rings} + T = {blocks + animals + rings} + T = {total} toys for her {family}.\nThus, T = {total} - {blocks + animals + rings} = {bouncy_balls} bouncy balls came in the tube.\n#### {bouncy_balls}" return { - 'question': question, - 'answer': str(bouncy_balls), - 'answer_cot': answer_cot, - 'answer_value': bouncy_balls, - 'variables': { - 'name': name, - 'family': family, - 'building_blocks': blocks, - 'stuffed_animals': animals, - 'stacking_rings': rings, - 'total_toys': total, - 'bouncy_balls': bouncy_balls - } + "question": question, + "answer": str(bouncy_balls), + "answer_cot": answer_cot, + "answer_value": bouncy_balls, + "variables": { + "name": name, + "family": family, + "building_blocks": blocks, + "stuffed_animals": animals, + "stacking_rings": rings, + "total_toys": total, + "bouncy_balls": bouncy_balls, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Sophie', 'Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia'] - family_members = ['nephew', 'cousin', 'brother'] - + names_female = ["Sophie", "Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia"] + family_members = ["nephew", "cousin", "brother"] + name = rng.choice(names_female) family = rng.choice(family_members) - + blocks = int(rng.randint(70, int(75 * difficulty))) animals = int(rng.randint(35, int(50 * difficulty))) rings = int(rng.randint(20, int(35 * difficulty))) - + total = blocks + animals + rings + int(rng.randint(20, int(100 * difficulty))) - + result = generate_from_variables(name, family, blocks, animals, rings, total) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_2(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(teacher: str, total: int, p1: int, p2: int, - group1: str, group2: str, group3: str, - event: str) -> Dict[str, Any]: + def generate_from_variables( + teacher: str, total: int, p1: int, p2: int, group1: str, group2: str, group3: str, event: str + ) -> Dict[str, Any]: group1_count = int(total * p1 / 100) remaining = total - group1_count group23_count = int(remaining * p2 / 100) total_leaving = group1_count + group23_count - + question = f"In {teacher}'s class of {total} students, {p1}% of the class are {group1}. Out of the remaining class, {p2}% of the students are {group2} or part of {group3}. These 3 groups of students will need to leave early today to travel to an away {event}. How many students are leaving early?" - - answer_cot = f"{p1}% of the {total} student class are {group1} so that's {p1/100}*{total} = {group1_count} students\n" \ - f"There are {total} students and {group1_count} are {group1} so that leaves {total}-{group1_count} = {remaining} students\n" \ - f"{p2}% of the remaining {remaining} students are part of {group3} or {group2} so that's {p2/100}*{remaining} = {group23_count} students\n" \ - f"{group1_count} students are {group1} and {group23_count} are part of {group3}/{group2} so {group1_count}+{group23_count} = {total_leaving} students will be leaving early\n" \ - f"#### {total_leaving}" + + answer_cot = ( + f"{p1}% of the {total} student class are {group1} so that's {p1/100}*{total} = {group1_count} students\n" + f"There are {total} students and {group1_count} are {group1} so that leaves {total}-{group1_count} = {remaining} students\n" + f"{p2}% of the remaining {remaining} students are part of {group3} or {group2} so that's {p2/100}*{remaining} = {group23_count} students\n" + f"{group1_count} students are {group1} and {group23_count} are part of {group3}/{group2} so {group1_count}+{group23_count} = {total_leaving} students will be leaving early\n" + f"#### {total_leaving}" + ) return { - 'question': question, - 'answer': str(total_leaving), - 'answer_cot': answer_cot, - 'answer_value': total_leaving, - 'variables': { - 'teacher': teacher, - 'total_students': total, - 'percent_group1': p1, - 'percent_group23': p2, - 'group1': group1, - 'group2': group2, - 'group3': group3, - 'event': event, - 'group1_count': group1_count, - 'group23_count': group23_count - } + "question": question, + "answer": str(total_leaving), + "answer_cot": answer_cot, + "answer_value": total_leaving, + "variables": { + "teacher": teacher, + "total_students": total, + "percent_group1": p1, + "percent_group23": p2, + "group1": group1, + "group2": group2, + "group3": group3, + "event": event, + "group1_count": group1_count, + "group23_count": group23_count, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - teachers = ['Ms. Johnson', 'Mr. Smith', 'Dr. Lee', 'Mrs. Garcia'] - sports = ['soccer players', 'basketball players', 'volleyball players', 'swimmers'] - activities = ['dancers', 'choir members', 'debate team members', 'robotics club members'] - events = ['competition', 'tournament', 'performance', 'meet'] + teachers = ["Ms. Johnson", "Mr. Smith", "Dr. Lee", "Mrs. Garcia"] + sports = ["soccer players", "basketball players", "volleyball players", "swimmers"] + activities = ["dancers", "choir members", "debate team members", "robotics club members"] + events = ["competition", "tournament", "performance", "meet"] teacher = rng.choice(teachers) group1 = rng.choice(sports) @@ -174,35 +183,39 @@ def generate_2(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: total = int(rng.randint(20, int(150 * difficulty))) p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) - + # Ensure conditions are met - while not (p1 < 100 and p2 < 100 and - (total * p1) % 100 == 0 and - ((total - total * p1 / 100) * p2) % 100 == 0): + while not (p1 < 100 and p2 < 100 and (total * p1) % 100 == 0 and ((total - total * p1 / 100) * p2) % 100 == 0): total = int(rng.randint(20, int(150 * difficulty))) p1 = int(rng.randint(10, min(50, int(100 * difficulty)))) p2 = int(rng.randint(15, min(45, int(100 * difficulty)))) result = generate_from_variables(teacher, total, p1, p2, group1, group2, group3, event) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_3(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, initial_pals: int, lost_pals: int, - letters_per_week: int, pages_per_letter: int, - minutes_per_page: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, + initial_pals: int, + lost_pals: int, + letters_per_week: int, + pages_per_letter: int, + minutes_per_page: int, + ) -> Dict[str, Any]: current_pals = initial_pals - lost_pals letters_received = current_pals * letters_per_week pages_to_write = letters_received * pages_per_letter @@ -211,257 +224,273 @@ def generate_3(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"{name} was a pen pal with {initial_pals} people. He stopped being penpals with {lost_pals} of them. They each send {letters_per_week} letters a week that are {pages_per_letter} pages long. He responds in kind. He can write a page every {minutes_per_page} minutes. How many hours does he spend writing a week?" - answer_cot = f"{name} is penpals with {initial_pals}-{lost_pals}={current_pals} people\n" \ - f"Thus he gets {current_pals}*{letters_per_week}={letters_received} letters a week\n" \ - f"So he writes {letters_received}*{pages_per_letter}={pages_to_write} pages a week\n" \ - f"So he writes for {pages_to_write}*{minutes_per_page}={total_minutes} minutes a week\n" \ - f"So he writes {total_minutes}/60={hours} hours a week\n#### {hours}" + answer_cot = ( + f"{name} is penpals with {initial_pals}-{lost_pals}={current_pals} people\n" + f"Thus he gets {current_pals}*{letters_per_week}={letters_received} letters a week\n" + f"So he writes {letters_received}*{pages_per_letter}={pages_to_write} pages a week\n" + f"So he writes for {pages_to_write}*{minutes_per_page}={total_minutes} minutes a week\n" + f"So he writes {total_minutes}/60={hours} hours a week\n#### {hours}" + ) return { - 'question': question, - 'answer': str(hours), - 'answer_cot': answer_cot, - 'answer_value': hours, - 'variables': { - 'name': name, - 'initial_penpals': initial_pals, - 'lost_penpals': lost_pals, - 'current_penpals': current_pals, - 'letters_per_week': letters_per_week, - 'pages_per_letter': pages_per_letter, - 'minutes_per_page': minutes_per_page, - 'total_minutes': total_minutes - } + "question": question, + "answer": str(hours), + "answer_cot": answer_cot, + "answer_value": hours, + "variables": { + "name": name, + "initial_penpals": initial_pals, + "lost_penpals": lost_pals, + "current_penpals": current_pals, + "letters_per_week": letters_per_week, + "pages_per_letter": pages_per_letter, + "minutes_per_page": minutes_per_page, + "total_minutes": total_minutes, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Mike", "John", "David", "James", "Robert", "William", "Richard"] name = rng.choice(names) - + initial_pals = int(rng.randint(5, int(15 * difficulty))) lost_pals = int(rng.randint(1, initial_pals - 1)) letters_per_week = int(rng.randint(2, int(5 * difficulty))) pages_per_letter = int(rng.randint(5, int(12 * difficulty))) minutes_per_page = int(rng.randint(4, int(15 * difficulty))) - + # Ensure result is in whole hours while ((initial_pals - lost_pals) * letters_per_week * pages_per_letter * minutes_per_page) % 60 != 0: minutes_per_page = int(rng.randint(4, int(15 * difficulty))) - result = generate_from_variables(name, initial_pals, lost_pals, - letters_per_week, pages_per_letter, minutes_per_page) - + result = generate_from_variables( + name, initial_pals, lost_pals, letters_per_week, pages_per_letter, minutes_per_page + ) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_4(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, items: str, food: str, location: str, container: str, - num_jars: int, per_jar: int, per_pan: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, items: str, food: str, location: str, container: str, num_jars: int, per_jar: int, per_pan: int + ) -> Dict[str, Any]: total_items = num_jars * per_jar num_pans = total_items // per_pan - + question = f"{name} has {num_jars} jars of {items} in her {location}. Each jar of {items} can decorate {per_jar} {food}s. {name} wants to bake enough {food}s to use up all of her {items}. If each {container} holds {per_pan} {food}s, how many {container}s worth of {food}s should she bake?" - + answer_cot = f"She has enough {items} for {num_jars} * {per_jar} = {total_items} {food}s.\nShe needs {total_items} / {per_pan} = {num_pans} {container}s to bake all of the {food}s.\n#### {num_pans}" return { - 'question': question, - 'answer': str(num_pans), - 'answer_cot': answer_cot, - 'answer_value': num_pans, - 'variables': { - 'name': name, - 'items': items, - 'food': food, - 'location': location, - 'container': container, - 'num_jars': num_jars, - 'per_jar': per_jar, - 'per_pan': per_pan, - 'total_items': total_items - } + "question": question, + "answer": str(num_pans), + "answer_cot": answer_cot, + "answer_value": num_pans, + "variables": { + "name": name, + "items": items, + "food": food, + "location": location, + "container": container, + "num_jars": num_jars, + "per_jar": per_jar, + "per_pan": per_pan, + "total_items": total_items, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Mary', 'Sarah', 'Emma', 'Elizabeth', 'Catherine'] - items = ['sprinkles', 'frosting', 'icing', 'chocolate chips'] - foods = ['cupcake', 'cookie', 'brownie', 'muffin'] - locations = ['pantry', 'cupboard', 'kitchen cabinet', 'storage room'] - containers = ['pan', 'tray', 'baking sheet', 'rack'] - + names_female = ["Mary", "Sarah", "Emma", "Elizabeth", "Catherine"] + items = ["sprinkles", "frosting", "icing", "chocolate chips"] + foods = ["cupcake", "cookie", "brownie", "muffin"] + locations = ["pantry", "cupboard", "kitchen cabinet", "storage room"] + containers = ["pan", "tray", "baking sheet", "rack"] + name = rng.choice(names_female) item = rng.choice(items) food = rng.choice(foods) location = rng.choice(locations) container = rng.choice(containers) - + # Generate numbers ensuring divisibility per_pan = int(rng.randint(6, int(24 * difficulty))) per_jar = int(rng.randint(6, int(20 * difficulty))) num_jars = int(rng.randint(3, int(15 * difficulty))) - + # Ensure total is divisible by per_pan total = num_jars * per_jar while total % per_pan != 0: num_jars = int(rng.randint(3, int(15 * difficulty))) total = num_jars * per_jar - result = generate_from_variables(name, item, food, location, container, - num_jars, per_jar, per_pan) - + result = generate_from_variables(name, item, food, location, container, num_jars, per_jar, per_pan) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_5(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name1: str, name2: str, city: str, celebrity_type: str, - vacation_type: str, n1: int, n2: int, s1: int, s2: int, - goal: int) -> Dict[str, Any]: + def generate_from_variables( + name1: str, + name2: str, + city: str, + celebrity_type: str, + vacation_type: str, + n1: int, + n2: int, + s1: int, + s2: int, + goal: int, + ) -> Dict[str, Any]: signatures_collected = s1 + s2 signatures_needed = goal - signatures_collected - + question = f"{name1} and {name2} are sisters from {city} who love collecting signatures from {celebrity_type}. During their {vacation_type} from school, the sisters spend every afternoon collecting signatures. After {n1} weeks, {name1} and {name2} compare their autograph books, counting up the number of signatures each sister has collected. {name1} has {s1} signatures in her book, and {name2} has {s2}. The sisters have {n2} more weeks of {vacation_type}, and they decide they want to reach {goal} signatures between them by the end of the summer. How many signatures do the sisters need to collect to reach their goal?" - + answer_cot = f"{name1} and {name2} have already collected {s1} + {s2} signatures = {signatures_collected} signatures.\nSince their goal is {goal}, they need to collect {goal} - {signatures_collected} signatures. {goal} - {signatures_collected} = {signatures_needed} signatures\n#### {signatures_needed}" - + return { - 'question': question, - 'answer': str(signatures_needed), - 'answer_cot': answer_cot, - 'answer_value': signatures_needed, - 'variables': { - 'name1': name1, - 'name2': name2, - 'city': city, - 'celebrity_type': celebrity_type, - 'vacation_type': vacation_type, - 'weeks_passed': n1, - 'weeks_remaining': n2, - 'signatures1': s1, - 'signatures2': s2, - 'goal': goal, - 'signatures_collected': signatures_collected, - 'signatures_needed': signatures_needed - } + "question": question, + "answer": str(signatures_needed), + "answer_cot": answer_cot, + "answer_value": signatures_needed, + "variables": { + "name1": name1, + "name2": name2, + "city": city, + "celebrity_type": celebrity_type, + "vacation_type": vacation_type, + "weeks_passed": n1, + "weeks_remaining": n2, + "signatures1": s1, + "signatures2": s2, + "goal": goal, + "signatures_collected": signatures_collected, + "signatures_needed": signatures_needed, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte', 'Carol', 'Jennifer'] - cities = ['Los Angeles', 'New York', 'Chicago', 'Houston', 'Phoenix'] - celebrity_types = ['movie stars', 'athletes', 'musicians', 'politicians', 'authors'] - vacation_types = ['winter break', 'spring break', 'summer break', 'fall break'] - + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Carol", "Jennifer"] + cities = ["Los Angeles", "New York", "Chicago", "Houston", "Phoenix"] + celebrity_types = ["movie stars", "athletes", "musicians", "politicians", "authors"] + vacation_types = ["winter break", "spring break", "summer break", "fall break"] + name1, name2 = rng.sample(names_female, 2) city = rng.choice(cities) celebrity_type = rng.choice(celebrity_types) vacation_type = rng.choice(vacation_types) - + n1 = int(rng.randint(3, int(8 * difficulty))) - n2 = int(rng.randint(2, int(5 * difficulty))) + n2 = int(rng.randint(2, int(5 * difficulty))) s1 = int(rng.randint(15, int(40 * difficulty))) s2 = int(rng.randint(30, int(60 * difficulty))) goal = int(rng.randrange(90, int(150 * difficulty), 5)) - + # Ensure conditions are met while s1 + s2 >= goal: s1 = int(rng.randint(15, int(40 * difficulty))) s2 = int(rng.randint(30, int(60 * difficulty))) - - result = generate_from_variables(name1, name2, city, celebrity_type, vacation_type, - n1, n2, s1, s2, goal) - + + result = generate_from_variables(name1, name2, city, celebrity_type, vacation_type, n1, n2, s1, s2, goal) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_6(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(n_girls: int, place: str, multiplier: int) -> Dict[str, Any]: n_boys = n_girls * multiplier total_kids = n_girls + n_boys - + question = f"There are {n_girls} girls in the {place}. If there are {multiplier} times the number of boys in the {place}, how many kids are in the {place}?" - + answer_cot = f"There are {n_girls} girls x {multiplier} boys/girl = {n_boys} boys in the {place}.\nIn total there are {n_girls} girls + {n_boys} boys = {total_kids} kids in the {place}\n#### {total_kids}" return { - 'question': question, - 'answer': str(total_kids), - 'answer_cot': answer_cot, - 'answer_value': total_kids, - 'variables': { - 'n_girls': n_girls, - 'place': place, - 'multiplier': multiplier, - 'n_boys': n_boys, - 'total_kids': total_kids - } + "question": question, + "answer": str(total_kids), + "answer_cot": answer_cot, + "answer_value": total_kids, + "variables": { + "n_girls": n_girls, + "place": place, + "multiplier": multiplier, + "n_boys": n_boys, + "total_kids": total_kids, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - places = ['park', 'yard', 'field', 'playground', 'garden'] - multipliers = [2, 3, 4] # twice, triple, quadruple + places = ["park", "yard", "field", "playground", "garden"] + multipliers = [2, 3, 4] # twice, triple, quadruple place = rng.choice(places) multiplier = rng.choice(multipliers) - + # Scale n_girls with difficulty but ensure result is valid n_girls = int(rng.randint(5, int(50 * difficulty))) while n_girls * (multiplier + 1) > 200: n_girls = int(rng.randint(5, int(50 * difficulty))) result = generate_from_variables(n_girls, place, multiplier) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_7(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, plants_received: int, plants_per_ledge: int, - num_ledges: int, plants_to_give: int) -> Dict[str, Any]: - + def generate_from_variables( + name: str, plants_received: int, plants_per_ledge: int, num_ledges: int, plants_to_give: int + ) -> Dict[str, Any]: + initial_plants = plants_per_ledge * num_ledges - total_plants = initial_plants + plants_received + total_plants = initial_plants + plants_received plants_given = num_ledges * plants_to_give remaining_plants = total_plants - plants_given @@ -470,115 +499,126 @@ def generate_7(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: answer_cot = f"Yesterday, before receiving the plants, {name} had {num_ledges}*{plants_per_ledge} = {initial_plants} potted plants\nAfter receiving an additional {plants_received} plants, she therefore had a total of {initial_plants} + {plants_received} = {total_plants} potted plants\nTomorrow, {name}'s plant giveaway will be {num_ledges}*{plants_to_give} = {plants_given} potted plants.\nShe will therefore remain with {total_plants} - {plants_given} = {remaining_plants} potted plants.\n#### {remaining_plants}" return { - 'question': question, - 'answer': str(remaining_plants), - 'answer_cot': answer_cot, - 'answer_value': remaining_plants, - 'variables': { - 'name': name, - 'plants_received': plants_received, - 'plants_per_ledge': plants_per_ledge, - 'num_ledges': num_ledges, - 'plants_to_give': plants_to_give, - 'initial_plants': initial_plants, - 'total_plants': total_plants, - 'plants_given': plants_given, - 'remaining_plants': remaining_plants - } + "question": question, + "answer": str(remaining_plants), + "answer_cot": answer_cot, + "answer_value": remaining_plants, + "variables": { + "name": name, + "plants_received": plants_received, + "plants_per_ledge": plants_per_ledge, + "num_ledges": num_ledges, + "plants_to_give": plants_to_give, + "initial_plants": initial_plants, + "total_plants": total_plants, + "plants_given": plants_given, + "remaining_plants": remaining_plants, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Mary", "Emma", "Sophia", "Isabella", "Olivia", "Ava", "Mia"] - + name = rng.choice(names) plants_received = int(rng.randint(20, int(50 * difficulty))) plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) num_ledges = int(rng.randint(50, int(70 * difficulty))) plants_to_give = int(rng.randint(3, int(8 * difficulty))) - + # Ensure condition: w * r + x - w*n > 0 while (num_ledges * plants_per_ledge + plants_received - num_ledges * plants_to_give) <= 0: plants_per_ledge = int(rng.randint(7, int(13 * difficulty))) plants_to_give = int(rng.randint(3, int(8 * difficulty))) - result = generate_from_variables(name, plants_received, plants_per_ledge, - num_ledges, plants_to_give) - + result = generate_from_variables(name, plants_received, plants_per_ledge, num_ledges, plants_to_give) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_8(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, drink: str, sugar_ratio: int, water_ratio: int, - total_items: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, drink: str, sugar_ratio: int, water_ratio: int, total_items: int + ) -> Dict[str, Any]: total_ratio = sugar_ratio + water_ratio sugar_amount = (sugar_ratio * total_items) // total_ratio - + question = f"{name} makes {drink} using teaspoons of sugar and cups of water in the ratio of {sugar_ratio}:{water_ratio}. If she used a total of {total_items} teaspoons of sugar and cups of water, calculate the number of teaspoonfuls of sugar she used." - + answer_cot = f"The total ratio representing the ingredients she used to make the {drink} is {sugar_ratio}+{water_ratio} = {total_ratio}\nSince the fraction representing the number of teaspoons she used is {sugar_ratio}/{total_ratio}, she used {sugar_ratio}/{total_ratio}*{total_items} = {sugar_amount}\n#### {sugar_amount}" - + return { - 'question': question, - 'answer': str(sugar_amount), - 'answer_cot': answer_cot, - 'answer_value': sugar_amount, - 'variables': { - 'name': name, - 'drink': drink, - 'sugar_ratio': sugar_ratio, - 'water_ratio': water_ratio, - 'total_items': total_items, - 'sugar_amount': sugar_amount - } + "question": question, + "answer": str(sugar_amount), + "answer_cot": answer_cot, + "answer_value": sugar_amount, + "variables": { + "name": name, + "drink": drink, + "sugar_ratio": sugar_ratio, + "water_ratio": water_ratio, + "total_items": total_items, + "sugar_amount": sugar_amount, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - drinks = ['coffee', 'tea'] - + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"] + drinks = ["coffee", "tea"] + name = rng.choice(names_female) drink = rng.choice(drinks) - + sugar_ratio = int(rng.randint(25, int(201 * difficulty))) water_ratio = int(rng.randint(5, int(101 * difficulty))) - + # Ensure total is divisible by ratio sum total_ratio = sugar_ratio + water_ratio num_multiples = rng.randint(1, int(10 * difficulty)) total_items = total_ratio * num_multiples - + result = generate_from_variables(name, drink, sugar_ratio, water_ratio, total_items) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_9(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, num_bills: int, bill_value: int, num_items1: int, - price1: int, num_items2: int, price2: int, item1: str, - item2: str, currency: str) -> Dict[str, Any]: - + def generate_from_variables( + name: str, + num_bills: int, + bill_value: int, + num_items1: int, + price1: int, + num_items2: int, + price2: int, + item1: str, + item2: str, + currency: str, + ) -> Dict[str, Any]: + initial_amount = num_bills * bill_value spent_items1 = num_items1 * price1 spent_items2 = num_items2 * price2 @@ -586,32 +626,34 @@ def generate_9(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: remaining = initial_amount - total_spent question = f"{name} has {num_bills} {currency}{bill_value} bills. He buys {num_items1} {item1}s for {currency}{price1} each. He also buys {num_items2} packs of {item2}s for {currency}{price2} each. How much money does he have left?" - - answer_cot = f"{name} starts off with {num_bills} * {currency}{bill_value} = {currency}{initial_amount}.\n" \ - f"{name} spends {num_items1} {item1}s * {currency}{price1} = {currency}{spent_items1} on {item1}s.\n" \ - f"{name} spends {num_items2} packs of {item2}s * {currency}{price2} = {currency}{spent_items2} on {item2}s.\n" \ - f"Total {name} has spent {currency}{spent_items1} + {currency}{spent_items2} = {currency}{total_spent}.\n" \ - f"{name} has {currency}{initial_amount} - {currency}{total_spent} = {currency}{remaining} remaining.\n#### {remaining}" + + answer_cot = ( + f"{name} starts off with {num_bills} * {currency}{bill_value} = {currency}{initial_amount}.\n" + f"{name} spends {num_items1} {item1}s * {currency}{price1} = {currency}{spent_items1} on {item1}s.\n" + f"{name} spends {num_items2} packs of {item2}s * {currency}{price2} = {currency}{spent_items2} on {item2}s.\n" + f"Total {name} has spent {currency}{spent_items1} + {currency}{spent_items2} = {currency}{total_spent}.\n" + f"{name} has {currency}{initial_amount} - {currency}{total_spent} = {currency}{remaining} remaining.\n#### {remaining}" + ) return { - 'question': question, - 'answer': str(remaining), - 'answer_cot': answer_cot, - 'answer_value': remaining, - 'variables': { - 'name': name, - 'num_bills': num_bills, - 'bill_value': bill_value, - 'num_items1': num_items1, - 'price1': price1, - 'num_items2': num_items2, - 'price2': price2, - 'item1': item1, - 'item2': item2, - 'currency': currency, - 'initial_amount': initial_amount, - 'total_spent': total_spent - } + "question": question, + "answer": str(remaining), + "answer_cot": answer_cot, + "answer_value": remaining, + "variables": { + "name": name, + "num_bills": num_bills, + "bill_value": bill_value, + "num_items1": num_items1, + "price1": price1, + "num_items2": num_items2, + "price2": price2, + "item1": item1, + "item2": item2, + "currency": currency, + "initial_amount": initial_amount, + "total_spent": total_spent, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: @@ -620,106 +662,109 @@ def generate_9(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: items2 = ["sticker", "candy bar", "trading card", "pencil", "eraser"] currencies = ["$", "€", "£"] bills = [(5, 5), (10, 10), (20, 20), (50, 50), (100, 100)] - + name = rng.choice(names) item1 = rng.choice(items1) item2 = rng.choice(items2) currency = rng.choice(currencies) bill_value = rng.choice(bills)[1] - + num_bills = int(rng.randint(1, int(10 * difficulty))) num_items1 = int(rng.randint(2, int(15 * difficulty))) num_items2 = int(rng.randint(2, int(10 * difficulty))) price1 = int(rng.randint(1, int(10 * difficulty))) price2 = int(rng.randint(1, int(10 * difficulty))) - + # Ensure total cost doesn't exceed available money while (num_items1 * price1 + num_items2 * price2) > (num_bills * bill_value): num_items1 = int(rng.randint(2, int(15 * difficulty))) num_items2 = int(rng.randint(2, int(10 * difficulty))) - - result = generate_from_variables(name, num_bills, bill_value, num_items1, price1, - num_items2, price2, item1, item2, currency) - + + result = generate_from_variables( + name, num_bills, bill_value, num_items1, price1, num_items2, price2, item1, item2, currency + ) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_10(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name1: str, name2: str, age1: int, years: int, - relation_type: str, mult: int) -> Dict[str, Any]: + def generate_from_variables( + name1: str, name2: str, age1: int, years: int, relation_type: str, mult: int + ) -> Dict[str, Any]: future_age = age1 * mult current_age = future_age - years - + question = f"{name1} is {age1} years old. In {years} years his {relation_type} {name2} will be {mult} times as old as {name1} is now. How old is {name2} right now?" - + answer_cot = f"{years} years from now {name2} will be {age1}*{mult}={future_age}.\nRight now {name2} is {future_age}-{years}={current_age} years old.\n#### {current_age}" - + return { - 'question': question, - 'answer': str(current_age), - 'answer_cot': answer_cot, - 'answer_value': current_age, - 'variables': { - 'name1': name1, - 'name2': name2, - 'age1': age1, - 'years': years, - 'relation_type': relation_type, - 'mult': mult, - 'future_age': future_age, - 'current_age': current_age - } + "question": question, + "answer": str(current_age), + "answer_cot": answer_cot, + "answer_value": current_age, + "variables": { + "name1": name1, + "name2": name2, + "age1": age1, + "years": years, + "relation_type": relation_type, + "mult": mult, + "future_age": future_age, + "current_age": current_age, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_male = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] - names_female = ['Mary', 'Patricia', 'Jennifer', 'Linda', 'Elizabeth', 'Barbara', 'Susan'] - relation_types = ['sister', 'cousin'] - + names_male = ["James", "John", "Robert", "Michael", "William", "David", "Richard"] + names_female = ["Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan"] + relation_types = ["sister", "cousin"] + name1 = rng.choice(names_male) name2 = rng.choice(names_female) relation_type = rng.choice(relation_types) - + age1 = int(rng.randint(8, int(25 * difficulty))) years = int(rng.randint(2, int(10 * difficulty))) mult = int(rng.randint(2, int(5 * difficulty))) - + # Ensure conditions are met while age1 * mult - years <= 0: age1 = int(rng.randint(8, int(25 * difficulty))) years = int(rng.randint(2, int(10 * difficulty))) mult = int(rng.randint(2, int(5 * difficulty))) - + result = generate_from_variables(name1, name2, age1, years, relation_type, mult) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_11(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, food1: str, food2: str, mult: int, n: int, - m: int, k: int) -> Dict[str, Any]: + def generate_from_variables(name: str, food1: str, food2: str, mult: int, n: int, m: int, k: int) -> Dict[str, Any]: initial_food1 = n * mult # initial corn initial_total = initial_food1 + n # initial total bought_food1 = m - k # bought corn @@ -727,289 +772,312 @@ def generate_11(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: final_total = initial_total + bought_total # final total question = f"At {name}'s house, there is {mult} times as much {food1} as {food2}. He has a total of {n} {food2} in his house. {name} bought {m} more {food2} at the store and {k} fewer {food1} than the number of {food2}. Find the combined total of the number of {food1} and {food2} {name} has in the house?" - + answer_cot = f"Before buying any {food1} and {food2}, {name} had {mult} times as many {food1} as {food2}, which is {n} {food2} * {mult} {food1}/{food2} = {initial_food1} {food1}\nThe total number of {food1} and {food2} that {name} had before is {initial_food1} {food1} + {n} {food2} = {initial_total} items\nWhen he bought {k} fewer {food1} than {food2}, he bought {m} {food1} - {k} {food1} = {bought_food1} {food1}\nIn total, he bought {bought_food1} {food1} + {m} {food2} = {bought_total} items\nAfter the purchases, {name} has {initial_total} items + {bought_total} items = {final_total} total {food1} and {food2} combined.\n#### {final_total}" return { - 'question': question, - 'answer': str(final_total), - 'answer_cot': answer_cot, - 'answer_value': final_total, - 'variables': { - 'name': name, - 'food1': food1, - 'food2': food2, - 'multiplier': mult, - 'initial_amount': n, - 'bought_amount': m, - 'difference': k, - 'initial_total': initial_total, - 'bought_total': bought_total, - 'final_total': final_total - } + "question": question, + "answer": str(final_total), + "answer_cot": answer_cot, + "answer_value": final_total, + "variables": { + "name": name, + "food1": food1, + "food2": food2, + "multiplier": mult, + "initial_amount": n, + "bought_amount": m, + "difference": k, + "initial_total": initial_total, + "bought_total": bought_total, + "final_total": final_total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Allan", "John", "Michael", "David", "James", "Robert", "William"] - foods = ["corn", "apple", "banana", "orange", "pear", "grape", "fig", - "persimmon", "plum", "kiwi"] + foods = ["corn", "apple", "banana", "orange", "pear", "grape", "fig", "persimmon", "plum", "kiwi"] multipliers = ["twice", "three times", "four times"] name = rng.choice(names) food1, food2 = rng.sample(foods, 2) mult = rng.randint(2, int(4 * difficulty)) - + n = int(rng.randint(20, int(100 * difficulty))) m = int(rng.randint(30, int(100 * difficulty))) k = int(rng.randint(10, min(m, int(50 * difficulty)))) result = generate_from_variables(name, food1, food2, mult, n, m, k) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_12(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, game1: str, game2: str, period: str, - time1: int, time2: int, num1: int, num2: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, game1: str, game2: str, period: str, time1: int, time2: int, num1: int, num2: int + ) -> Dict[str, Any]: total_time1 = time1 * num1 total_time2 = time2 * num2 total_time = total_time1 + total_time2 question = f"It takes {name} {time1} minutes to finish a {game1} and {time2} minutes to finish a {game2}. Over the {period} she solved {num1} {game1}s and {num2} {game2}s. How much time did she spend playing these games?" - answer_cot = f"It takes {time1} minutes to complete a {game1} and she completed {num1} for a total of {time1}*{num1} = {total_time1} minutes\n" \ - f"It takes {time2} minutes to complete a {game2} and she completed {num2} for a total of {time2}*{num2} = {total_time2} minutes\n" \ - f"She spent {total_time1} minutes on {game1}s and {total_time2} minutes on {game2}s for a total of {total_time1}+{total_time2} = {total_time} minutes\n" \ - f"#### {total_time}" + answer_cot = ( + f"It takes {time1} minutes to complete a {game1} and she completed {num1} for a total of {time1}*{num1} = {total_time1} minutes\n" + f"It takes {time2} minutes to complete a {game2} and she completed {num2} for a total of {time2}*{num2} = {total_time2} minutes\n" + f"She spent {total_time1} minutes on {game1}s and {total_time2} minutes on {game2}s for a total of {total_time1}+{total_time2} = {total_time} minutes\n" + f"#### {total_time}" + ) return { - 'question': question, - 'answer': str(total_time), - 'answer_cot': answer_cot, - 'answer_value': total_time, - 'variables': { - 'name': name, - 'game1': game1, - 'game2': game2, - 'period': period, - 'time1': time1, - 'time2': time2, - 'num1': num1, - 'num2': num2, - 'total_time1': total_time1, - 'total_time2': total_time2 - } + "question": question, + "answer": str(total_time), + "answer_cot": answer_cot, + "answer_value": total_time, + "variables": { + "name": name, + "game1": game1, + "game2": game2, + "period": period, + "time1": time1, + "time2": time2, + "num1": num1, + "num2": num2, + "total_time1": total_time1, + "total_time2": total_time2, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"] games = ["word puzzle", "jigsaw puzzle", "chess puzzle", "riddle", "brain teaser"] periods = ["weekend", "vacation", "holiday", "day off", "free time"] - + name = rng.choice(names) game1, game2 = rng.sample(games, 2) period = rng.choice(periods) - + time1 = int(rng.randint(5, int(30 * difficulty))) time2 = int(rng.randint(3, int(20 * difficulty))) while time2 >= time1: # ensure time1 > time2 time1 = int(rng.randint(5, int(30 * difficulty))) time2 = int(rng.randint(3, int(20 * difficulty))) - + num1 = int(rng.randint(2, int(10 * difficulty))) num2 = int(rng.randint(4, int(15 * difficulty))) - + result = generate_from_variables(name, game1, game2, period, time1, time2, num1, num2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_13(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(park_name: str, unit: str, length1: int, length2: int, - speed1: int, speed2: int) -> Dict[str, Any]: + def generate_from_variables( + park_name: str, unit: str, length1: int, length2: int, speed1: int, speed2: int + ) -> Dict[str, Any]: time1 = length1 // speed1 time2 = length2 // speed2 time_diff = time1 - time2 - + question = f"The biggest waterslide at {park_name} is {length1} {unit} long, and people slide down at {speed1} {unit}/minute. The second biggest waterslide is {length2} {unit} long, but steeper, so people slide down at {speed2} {unit}/minute. How much longer does it take to ride the biggest slide compared to the second biggest slide?" - + answer_cot = f"First find the ride length of the biggest slide: {length1} {unit} / {speed1} {unit}/minute = {time1} minutes\nThen find the ride length of the second biggest slide: {length2} {unit} / {speed2} {unit}/minute = {time2} minutes\nThen subtract the ride length of the second longest slide from the longest slide to find the difference: {time1} minutes - {time2} minutes = {time_diff} minutes\n#### {time_diff}" return { - 'question': question, - 'answer': str(time_diff), - 'answer_cot': answer_cot, - 'answer_value': time_diff, - 'variables': { - 'park_name': park_name, - 'unit': unit, - 'length1': length1, - 'length2': length2, - 'speed1': speed1, - 'speed2': speed2, - 'time1': time1, - 'time2': time2 - } + "question": question, + "answer": str(time_diff), + "answer_cot": answer_cot, + "answer_value": time_diff, + "variables": { + "park_name": park_name, + "unit": unit, + "length1": length1, + "length2": length2, + "speed1": speed1, + "speed2": speed2, + "time1": time1, + "time2": time2, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: parks = ["Splash World", "Aqua Adventure", "Water Wonderland", "Neptunes Kingdom"] - units = ['yards', 'meters'] - + units = ["yards", "meters"] + park_name = rng.choice(parks) unit = rng.choice(units) - + length1 = int(rng.randrange(250, int(401 * difficulty), 10)) length2 = int(rng.randrange(200, int(301 * difficulty), 10)) speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) - + # Ensure conditions are met - while (length1 <= length2 or speed2 <= speed1 or - length1 % speed1 != 0 or length2 % speed2 != 0 or - (length1 // speed1) <= (length2 // speed2)): + while ( + length1 <= length2 + or speed2 <= speed1 + or length1 % speed1 != 0 + or length2 % speed2 != 0 + or (length1 // speed1) <= (length2 // speed2) + ): length1 = int(rng.randrange(250, int(401 * difficulty), 10)) length2 = int(rng.randrange(200, int(301 * difficulty), 10)) speed1 = int(rng.randrange(40, int(81 * difficulty), 5)) speed2 = int(rng.randrange(60, int(101 * difficulty), 5)) result = generate_from_variables(park_name, unit, length1, length2, speed1, speed2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_14(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, day1: str, day2: str, day3: str, - time1: int, time2: int, mult: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, day1: str, day2: str, day3: str, time1: int, time2: int, mult: int + ) -> Dict[str, Any]: combined_time = time1 + time2 target_time = combined_time * mult - + question = f"On {day3}, {name} wants to exercise for {mult} the amount of time he did on {day2} and {day1} combined. On {day1} he exercised for {time1} minutes. On {day2} he exercised for {time2} minutes. How many minutes does he have to exercise on {day3} to reach his goal?" - + answer_cot = f"On {day1} and {day2} he exercised a total of {combined_time} minutes because {time1} + {time2} = {combined_time}\nOn {day3} he has to exercise for {target_time} minutes because {combined_time} x {mult} = {target_time}\n#### {target_time}" return { - 'question': question, - 'answer': str(target_time), - 'answer_cot': answer_cot, - 'answer_value': target_time, - 'variables': { - 'name': name, - 'day1': day1, - 'day2': day2, - 'day3': day3, - 'time1': time1, - 'time2': time2, - 'multiplier': mult, - 'combined_time': combined_time, - 'target_time': target_time - } + "question": question, + "answer": str(target_time), + "answer_cot": answer_cot, + "answer_value": target_time, + "variables": { + "name": name, + "day1": day1, + "day2": day2, + "day3": day3, + "time1": time1, + "time2": time2, + "multiplier": mult, + "combined_time": combined_time, + "target_time": target_time, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Peter", "John", "Michael", "David", "James", "Robert", "William"] weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] multipliers = [2, 3, 4] - + name = rng.choice(names) day1, day2, day3 = rng.sample(weekdays, 3) mult = rng.choice(multipliers) - + time1 = int(rng.randint(10, int(60 * difficulty))) time2 = int(rng.randint(10, int(60 * difficulty))) - + # Check conditions while (time1 + time2) <= 0 or ((time1 + time2) * mult / 60) >= 14: time1 = int(rng.randint(10, int(60 * difficulty))) time2 = int(rng.randint(10, int(60 * difficulty))) - + result = generate_from_variables(name, day1, day2, day3, time1, time2, mult) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_15(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, sport: str, item1: str, item2: str, - item3: str, item4: str, currency: str, price1: int, - price2: int, price3: int, price4: int, discount: int) -> Dict[str, Any]: - + def generate_from_variables( + name: str, + sport: str, + item1: str, + item2: str, + item3: str, + item4: str, + currency: str, + price1: int, + price2: int, + price3: int, + price4: int, + discount: int, + ) -> Dict[str, Any]: + shorts_price = price1 + price2 shoes_price = price3 // 2 socks_price = price4 - discount total = price1 + shorts_price + shoes_price + socks_price - + question = f"{name} qualified for a spot on the {sport} team, so she went shopping for some athletic gear. She bought a {item1} for {currency}{price1}, a pair of {sport} {item2} for {currency}{price2} more than the {item1} cost, and a pair of {item3} that were originally {currency}{price3} but were on sale for half price. She had a coupon for {currency}{discount} off the package of {currency}{price4} athletic {item4} that she also bought. How much did she spend on athletic gear?" answer_cot = f"The {item2} were {currency}{price2} more than the {item1}, so they cost {currency}{price2} + {currency}{price1} = {currency}{shorts_price}.\nHer {item3} were half the original {currency}{price3} price, so they cost {currency}{price3} / 2 = ${shoes_price}.\nWith her coupon, the {item4} were {currency}{price4} - {currency}{discount} = {currency}{socks_price}.\nThe {item1}, {item2}, {item3}, and {item4} together cost {currency}{price1} + {currency}{shorts_price} + {currency}{shoes_price} + {currency}{socks_price} = {currency}{total}.\n#### {total}" return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'sport': sport, - 'item1': item1, - 'item2': item2, - 'item3': item3, - 'item4': item4, - 'currency': currency, - 'price1': price1, - 'price2': price2, - 'price3': price3, - 'price4': price4, - 'discount': discount - } + "question": question, + "answer": str(total), + "answer_cot": answer_cot, + "answer_value": total, + "variables": { + "name": name, + "sport": sport, + "item1": item1, + "item2": item2, + "item3": item3, + "item4": item4, + "currency": currency, + "price1": price1, + "price2": price2, + "price3": price3, + "price4": price4, + "discount": discount, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Amelia"] - sports = ["swimming", "cycling", "basketball", "soccer", "volleyball"] + sports = ["swimming", "cycling", "basketball", "soccer", "volleyball"] items1 = ["t-shirt", "jersey", "sports bra"] items2 = ["shorts", "leggings", "sweatpants"] items3 = ["sneakers", "cleats", "athletic shoes"] @@ -1032,88 +1100,93 @@ def generate_15(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: # Ensure price3 is even for clean division by 2 price3 = int(rng.randint(30, int(80 * difficulty)) // 2 * 2) - result = generate_from_variables(name, sport, item1, item2, item3, item4, currency, - price1, price2, price3, price4, discount) - + result = generate_from_variables( + name, sport, item1, item2, item3, item4, currency, price1, price2, price3, price4, discount + ) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_16(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name1: str, name2: str, name3: str, platform: str, - mult1: int, mult2: int, n: int) -> Dict[str, Any]: + def generate_from_variables( + name1: str, name2: str, name3: str, platform: str, mult1: int, mult2: int, n: int + ) -> Dict[str, Any]: base_friends = n // mult1 # Dorothy's friends - charlie_friends = n # Charlie's friends + charlie_friends = n # Charlie's friends james_friends = base_friends * mult2 # James's friends - + question = f"{name1} has {mult1} times as many {platform} friends as {name2}. {name3} has {mult2} times as many friends on {platform} as {name2}. If {name1} has {n} friends on {platform}, how many {platform} friends does {name3} have?" - + answer_cot = f"{name2} has {n} / {mult1} = {base_friends} {platform} friends.\n{name3} has {mult2} * {base_friends} = {james_friends} {platform} friends.\n#### {james_friends}" - + return { - 'question': question, - 'answer': str(james_friends), - 'answer_cot': answer_cot, - 'answer_value': james_friends, - 'variables': { - 'name1': name1, - 'name2': name2, - 'name3': name3, - 'platform': platform, - 'mult1': mult1, - 'mult2': mult2, - 'base_friends': base_friends, - 'charlie_friends': charlie_friends, - 'james_friends': james_friends - } + "question": question, + "answer": str(james_friends), + "answer_cot": answer_cot, + "answer_value": james_friends, + "variables": { + "name1": name1, + "name2": name2, + "name3": name3, + "platform": platform, + "mult1": mult1, + "mult2": mult2, + "base_friends": base_friends, + "charlie_friends": charlie_friends, + "james_friends": james_friends, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Charlie', 'Dorothy', 'James', 'Sarah', 'Michael', 'Emily', 'David'] - platforms = ['Instagram', 'Twitter', 'LinkedIn', 'TikTok', 'Snapchat'] - + names = ["Charlie", "Dorothy", "James", "Sarah", "Michael", "Emily", "David"] + platforms = ["Instagram", "Twitter", "LinkedIn", "TikTok", "Snapchat"] + name1, name2, name3 = rng.sample(names, 3) platform = rng.choice(platforms) - + # Generate multipliers that will be different mult1 = rng.randint(2, int(5 * difficulty)) mult2 = rng.randint(2, int(5 * difficulty)) while mult2 == mult1: mult2 = rng.randint(2, int(5 * difficulty)) - + # Generate n that's divisible by mult1 base = rng.randint(4, int(20 * difficulty)) n = base * mult1 - + result = generate_from_variables(name1, name2, name3, platform, mult1, mult2, n) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_17(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(facility: str, total: int, item: str, frac: Fraction, - event: str, daily: int, period: int) -> Dict[str, Any]: + def generate_from_variables( + facility: str, total: int, item: str, frac: Fraction, event: str, daily: int, period: int + ) -> Dict[str, Any]: initial_occupied = int(total * frac) initial_empty = total - initial_occupied weekly_admitted = daily * 7 @@ -1121,33 +1194,33 @@ def generate_17(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: final_empty = initial_empty - total_admitted question = f"A {facility} has a capacity of {total} {item}s with {frac} occupied. Due to the {event}, {daily} patients are admitted into the {facility} each day. Calculate the total number of unoccupied {item}s in the {facility} after {period} weeks." - + answer_cot = f"If {frac} of the total capacity of the {facility} {item}s is occupied, it means {frac} * {total} = {initial_occupied} {item}s have patients using them.\nThe total number of {item}s in the {facility} without new admissions is {total} {item}s - {initial_occupied} {item}s = {initial_empty} {item}s.\nIf {daily} people are admitted each day, the total number of patients in the {facility} after one week is {daily} patients/day * 7 days/week = {weekly_admitted} patients.\nAfter {period} weeks, the total number of patients admitted into the {facility} is {weekly_admitted} patients/week * {period} weeks = {total_admitted} patients, who each use one {item}.\nIf there were {initial_empty} unoccupied {item}s in the {facility} before the new admissions, the total number is reduced to {initial_empty} {item}s - {total_admitted} {item}s = {final_empty} unoccupied {item}s.\n#### {final_empty}" return { - 'question': question, - 'answer': str(final_empty), - 'answer_cot': answer_cot, - 'answer_value': final_empty, - 'variables': { - 'facility': facility, - 'total_capacity': total, - 'item': item, - 'initial_fraction': frac, - 'event': event, - 'daily_patients': daily, - 'period_weeks': period, - 'initial_occupied': initial_occupied, - 'initial_empty': initial_empty, - 'total_admitted': total_admitted - } + "question": question, + "answer": str(final_empty), + "answer_cot": answer_cot, + "answer_value": final_empty, + "variables": { + "facility": facility, + "total_capacity": total, + "item": item, + "initial_fraction": frac, + "event": event, + "daily_patients": daily, + "period_weeks": period, + "initial_occupied": initial_occupied, + "initial_empty": initial_empty, + "total_admitted": total_admitted, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: facilities = ["hospital", "clinic", "medical center", "care facility"] - items = ["bed", "room", "ward"] + items = ["bed", "room", "ward"] events = ["flu season", "natural disaster", "major accident", "pandemic"] - fractions = [Fraction(1,5), Fraction(1,4), Fraction(1,3), Fraction(1,2)] + fractions = [Fraction(1, 5), Fraction(1, 4), Fraction(1, 3), Fraction(1, 2)] facility = rng.choice(facilities) item = rng.choice(items) @@ -1167,18 +1240,19 @@ def generate_17(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: result = generate_from_variables(facility, total, item, frac, event, daily, period) return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_18(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(name1: str, name2: str, game: str, n1: int, n2: int, frac: float) -> Dict[str, Any]: @@ -1188,62 +1262,84 @@ def generate_18(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"{name1} scored {n1} points in one game of {game}. {name2} scored {n2} more than {frac:.0%} as many as {name1}. How many points did {name1} and {name2} have in total?" answer_cot = f"{name1} = {n1} points\n{name2} = {frac} * {n1} + {n2} = {score2} points\n{n1} + {score2} = {total} points\nTogether, {name1} and {name2} scored {total} points.\n#### {total}" - + return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'game': game, - 'score1': n1, - 'bonus': n2, - 'fraction': frac, - 'score2': score2, - 'total_score': total - } + "question": question, + "answer": str(total), + "answer_cot": answer_cot, + "answer_value": total, + "variables": { + "name1": name1, + "name2": name2, + "game": game, + "score1": n1, + "bonus": n2, + "fraction": frac, + "score2": score2, + "total_score": total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Charles", - "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica", "Sarah", "Karen"] + names = [ + "James", + "John", + "Robert", + "Michael", + "William", + "David", + "Richard", + "Joseph", + "Thomas", + "Charles", + "Mary", + "Patricia", + "Jennifer", + "Linda", + "Elizabeth", + "Barbara", + "Susan", + "Jessica", + "Sarah", + "Karen", + ] games = ["bowling", "darts", "archery", "basketball", "tennis"] - fractions = [0.5] # Could add more fractions if needed - + fractions = [0.5] # Could add more fractions if needed + name1, name2 = rng.sample(names, 2) game = rng.choice(games) frac = rng.choice(fractions) - + n1 = int(rng.randint(200, int(500 * difficulty))) n2 = int(rng.randint(5, int(50 * difficulty))) - + # Ensure fraction calculation results in integer while not float(frac * n1).is_integer(): n1 = int(rng.randint(200, int(500 * difficulty))) result = generate_from_variables(name1, name2, game, n1, n2, frac) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_19(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, pan: str, initial_kernels: int, time_interval: int, - multiplier_2: int, multiplier_3: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, pan: str, initial_kernels: int, time_interval: int, multiplier_2: int, multiplier_3: int + ) -> Dict[str, Any]: second_interval = multiplier_2 * initial_kernels - third_interval = multiplier_3 * initial_kernels + third_interval = multiplier_3 * initial_kernels fourth_interval = third_interval // 2 residual = fourth_interval // 4 total = initial_kernels + second_interval + third_interval + fourth_interval + residual @@ -1253,158 +1349,161 @@ def generate_19(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: answer_cot = f"In the second {time_interval} seconds of cooking, {multiplier_2} * {initial_kernels} = {second_interval} kernels pop.\nIn the third {time_interval} seconds, {multiplier_3} * {initial_kernels} = {third_interval} kernels pop.\nIn the final {time_interval} seconds, {third_interval} / 2 = {fourth_interval} kernels pop.\nAfter cooking, the residual heat makes {fourth_interval} / 4 = {residual} kernels pop.\nThus, {name} has {initial_kernels} + {second_interval} + {third_interval} + {fourth_interval} + {residual} = {total} pieces of popcorn to eat.\n#### {total}" return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'name': name, - 'pan': pan, - 'initial_kernels': initial_kernels, - 'time_interval': time_interval, - 'multiplier_2': multiplier_2, - 'multiplier_3': multiplier_3, - 'second_interval': second_interval, - 'third_interval': third_interval, - 'fourth_interval': fourth_interval, - 'residual': residual, - 'total': total - } + "question": question, + "answer": str(total), + "answer_cot": answer_cot, + "answer_value": total, + "variables": { + "name": name, + "pan": pan, + "initial_kernels": initial_kernels, + "time_interval": time_interval, + "multiplier_2": multiplier_2, + "multiplier_3": multiplier_3, + "second_interval": second_interval, + "third_interval": third_interval, + "fourth_interval": fourth_interval, + "residual": residual, + "total": total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["Garrett", "James", "Michael", "David", "John", "Robert", "William"] pans = ["pan", "pot", "skillet"] - + name = rng.choice(names) pan = rng.choice(pans) - + # Generate numbers ensuring divisibility conditions are met initial_kernels = int(rng.randrange(10, int(101 * difficulty), 10)) time_interval = int(rng.randrange(10, int(31 * difficulty), 2)) multiplier_2 = rng.randint(2, int(5 * difficulty)) - + # Ensure multiplier_3 > multiplier_2 and results in clean division by 8 while True: multiplier_3 = rng.randint(multiplier_2 + 1, int(8 * difficulty)) if (multiplier_3 * initial_kernels) % 8 == 0: break - - result = generate_from_variables(name, pan, initial_kernels, time_interval, - multiplier_2, multiplier_3) - + + result = generate_from_variables(name, pan, initial_kernels, time_interval, multiplier_2, multiplier_3) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_20(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, obj: str, surface: str, - capacity: int, total: int, num_trays: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, obj: str, surface: str, capacity: int, total: int, num_trays: int + ) -> Dict[str, Any]: max_capacity = capacity * num_trays leftover = total - max_capacity - + question = f"{name} places {obj}s on the {surface}. Each {surface} can hold {capacity} {obj}s. If he has {total} {obj}s and {num_trays} {surface}s, how many {obj}s won't he be able to place on the {surface}?" - + answer_cot = f"{name} will be able to place a total of {capacity} x {num_trays} = {max_capacity} {obj}s.\nTherefore, there are {total} - {max_capacity} = {leftover} {obj}s that he won't be able to place on the {surface}.\n#### {leftover}" - + return { - 'question': question, - 'answer': str(leftover), - 'answer_cot': answer_cot, - 'answer_value': leftover, - 'variables': { - 'name': name, - 'obj': obj, - 'surface': surface, - 'capacity_per_tray': capacity, - 'total_items': total, - 'num_trays': num_trays, - 'max_capacity': max_capacity, - 'leftover': leftover - } + "question": question, + "answer": str(leftover), + "answer_cot": answer_cot, + "answer_value": leftover, + "variables": { + "name": name, + "obj": obj, + "surface": surface, + "capacity_per_tray": capacity, + "total_items": total, + "num_trays": num_trays, + "max_capacity": max_capacity, + "leftover": leftover, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard'] - objects = ['olive', 'almond', 'cookie', 'cracker', 'banana'] - surfaces = ['plate', 'table', 'bowl', 'tray', 'basket'] - + names = ["James", "John", "Robert", "Michael", "William", "David", "Richard"] + objects = ["olive", "almond", "cookie", "cracker", "banana"] + surfaces = ["plate", "table", "bowl", "tray", "basket"] + name = rng.choice(names) obj = rng.choice(objects) surface = rng.choice(surfaces) - + capacity = int(rng.randint(20, int(51 * difficulty))) num_trays = int(rng.randint(2, int(7 * difficulty))) - + # Ensure total is greater than max capacity max_capacity = capacity * num_trays total = max_capacity + int(rng.randint(1, int(20 * difficulty))) - + result = generate_from_variables(name, obj, surface, capacity, total, num_trays) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_21(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, length: int, unit_length: str, plant_width: int, - space: float, owned: int, currency: str, cost: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, length: int, unit_length: str, plant_width: int, space: float, owned: int, currency: str, cost: int + ) -> Dict[str, Any]: total_plants = int(length / space) plants_to_buy = total_plants - owned total_cost = plants_to_buy * cost question = f"{name} has a flower bed that is {length} {unit_length} long. {name} wants to fill her flower bed with plants. {name}'s flowers grow {plant_width} inches wide so she needs to leave {space} {unit_length} between every plant. {name} already owns {owned} flowers. Each flowering plant costs {currency}{cost} at the store, how much money will {name} spend at the store to fill up her flower bed?" - + answer_cot = f"{name}'s flower bed is {length} {unit_length} / {space} {unit_length} per plant = {total_plants} plants needed.\n{name} needs to buy {total_plants} plants - {owned} plants = {plants_to_buy} plants needed to purchase.\n{name} will spend {plants_to_buy} plants * {currency}{cost} = {currency}{total_cost}.\n#### {total_cost}" return { - 'question': question, - 'answer': str(total_cost), - 'answer_cot': answer_cot, - 'answer_value': total_cost, - 'variables': { - 'name': name, - 'bed_length': length, - 'unit': unit_length, - 'plant_width': plant_width, - 'plant_spacing': space, - 'owned_plants': owned, - 'currency': currency, - 'cost_per_plant': cost, - 'total_plants': total_plants, - 'plants_to_buy': plants_to_buy - } + "question": question, + "answer": str(total_cost), + "answer_cot": answer_cot, + "answer_value": total_cost, + "variables": { + "name": name, + "bed_length": length, + "unit": unit_length, + "plant_width": plant_width, + "plant_spacing": space, + "owned_plants": owned, + "currency": currency, + "cost_per_plant": cost, + "total_plants": total_plants, + "plants_to_buy": plants_to_buy, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte'] - currencies = ['$', '£', '€'] - units = ['feet', 'meters'] - + names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte"] + currencies = ["$", "£", "€"] + units = ["feet", "meters"] + name = rng.choice(names_female) unit = rng.choice(units) currency = rng.choice(currencies) - + length = int(rng.randint(110, int(220 * difficulty))) plant_width = int(rng.randint(2, int(8 * difficulty))) space = round(rng.uniform(1.25, 2.0) * difficulty, 2) @@ -1412,34 +1511,32 @@ def generate_21(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: cost = int(rng.randint(3, int(15 * difficulty))) # Ensure conditions are met - while not (plant_width * 3 < length and - plant_width < space and - length % space == 0 and - length / space > owned): + while not (plant_width * 3 < length and plant_width < space and length % space == 0 and length / space > owned): length = int(rng.randint(110, int(220 * difficulty))) space = round(rng.uniform(1.25, 2.0) * difficulty, 2) owned = int(rng.randint(10, int(30 * difficulty))) - result = generate_from_variables(name, length, unit, plant_width, space, owned, - currency, cost) - + result = generate_from_variables(name, length, unit, plant_width, space, owned, currency, cost) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_22(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, property_type: str, budget: int, price: int, - brokerage_fee: int, transfer_fee: int) -> Dict[str, Any]: + def generate_from_variables( + name: str, property_type: str, budget: int, price: int, brokerage_fee: int, transfer_fee: int + ) -> Dict[str, Any]: brokerage_amount = int(price * brokerage_fee / 100) transfer_amount = int(price * transfer_fee / 100) total_price = price + brokerage_amount + transfer_amount @@ -1450,199 +1547,202 @@ def generate_22(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: answer_cot = f"The brokerage fee is ${price:,} x {brokerage_fee}/100 = ${brokerage_amount:,}.\nThe transfer fee is ${price:,} x {transfer_fee}/100 = ${transfer_amount:,}.\nThe total price of the {property_type} is ${price:,} + ${brokerage_amount:,} + ${transfer_amount:,} = ${total_price:,}.\nSo, it is ${total_price:,} - ${budget:,} = ${difference:,} more than {name}'s budget.\n#### {difference}" return { - 'question': question, - 'answer': f'{difference}', - 'answer_cot': answer_cot, - 'answer_value': difference, - 'variables': { - 'name': name, - 'property_type': property_type, - 'budget': budget, - 'price': price, - 'brokerage_fee': brokerage_fee, - 'transfer_fee': transfer_fee, - 'brokerage_amount': brokerage_amount, - 'transfer_amount': transfer_amount, - 'total_price': total_price - } + "question": question, + "answer": f"{difference}", + "answer_cot": answer_cot, + "answer_value": difference, + "variables": { + "name": name, + "property_type": property_type, + "budget": budget, + "price": price, + "brokerage_fee": brokerage_fee, + "transfer_fee": transfer_fee, + "brokerage_amount": brokerage_amount, + "transfer_amount": transfer_amount, + "total_price": total_price, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Mrs. Smith', 'Ms. Johnson', 'Dr. Patel', 'Mrs. Lee'] - property_types = ['house', 'apartment', 'condo', 'townhouse'] - + names = ["Mrs. Smith", "Ms. Johnson", "Dr. Patel", "Mrs. Lee"] + property_types = ["house", "apartment", "condo", "townhouse"] + name = rng.choice(names) property_type = rng.choice(property_types) - + # Scale ranges by difficulty while maintaining integer results budget = int(rng.randrange(300000, int(500000 * difficulty), 10000)) price = int(rng.randrange(250000, budget, 10000)) brokerage_fee = int(rng.randint(3, 8)) transfer_fee = int(rng.randint(10, 15)) - + # Verify conditions while True: - total_cost = price * (1 + brokerage_fee/100 + transfer_fee/100) - if (total_cost > budget + 1 and - price * brokerage_fee % 100 == 0 and - price * transfer_fee % 100 == 0): + total_cost = price * (1 + brokerage_fee / 100 + transfer_fee / 100) + if total_cost > budget + 1 and price * brokerage_fee % 100 == 0 and price * transfer_fee % 100 == 0: break price = int(rng.randrange(250000, budget, 10000)) - - result = generate_from_variables(name, property_type, budget, price, - brokerage_fee, transfer_fee) - + + result = generate_from_variables(name, property_type, budget, price, brokerage_fee, transfer_fee) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_23(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, task: str, profession: str, hours: int, - work_type: str, rate: int, fee: int, currency: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, task: str, profession: str, hours: int, work_type: str, rate: int, fee: int, currency: str + ) -> Dict[str, Any]: lost_income = hours * rate savings = lost_income - fee - + question = f"{name} is trying to decide whether to do {task} herself or hire an {profession}. If she does it herself, she'll be able to do {hours} fewer hours of {work_type} work, losing {currency}{rate}/hour in missed income. The {profession} charges {currency}{fee}. How much more money will she have if she hires the {profession}?" - + answer_cot = f"First find the total lost revenue if {name} does {task} herself: {currency}{rate}/hour * {hours} hours = {currency}{lost_income}\nThen subtract the {profession}'s charge to find how much money {name} saves: {currency}{lost_income} - {currency}{fee} = {currency}{savings}\n#### {savings}" return { - 'question': question, - 'answer': str(savings), - 'answer_cot': answer_cot, - 'answer_value': savings, - 'variables': { - 'name': name, - 'task': task, - 'profession': profession, - 'hours': hours, - 'work_type': work_type, - 'hourly_rate': rate, - 'fee': fee, - 'currency': currency, - 'lost_income': lost_income - } + "question": question, + "answer": str(savings), + "answer_cot": answer_cot, + "answer_value": savings, + "variables": { + "name": name, + "task": task, + "profession": profession, + "hours": hours, + "work_type": work_type, + "hourly_rate": rate, + "fee": fee, + "currency": currency, + "lost_income": lost_income, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_female = ['Emma', 'Sophia', 'Isabella', 'Olivia', 'Ava', 'Mia', 'Emily'] + names_female = ["Emma", "Sophia", "Isabella", "Olivia", "Ava", "Mia", "Emily"] tasks = ["her taxes", "her financial planning", "her business accounting"] professions = ["accountant", "financial advisor", "tax consultant", "bookkeeper"] work_types = ["freelance", "consulting", "part-time", "contract"] - currencies = ['$', '€', '£'] + currencies = ["$", "€", "£"] name = rng.choice(names_female) task = rng.choice(tasks) profession = rng.choice(professions) work_type = rng.choice(work_types) currency = rng.choice(currencies) - + hours = int(rng.randint(4, int(14 * difficulty))) rate = int(rng.randint(20, int(100 * difficulty))) fee = int(rng.randint(50, int(200 * difficulty))) - + # Ensure conditions are met while hours * rate <= fee: hours = int(rng.randint(4, int(14 * difficulty))) rate = int(rng.randint(20, int(100 * difficulty))) fee = int(rng.randint(50, int(200 * difficulty))) - result = generate_from_variables(name, task, profession, hours, work_type, - rate, fee, currency) - + result = generate_from_variables(name, task, profession, hours, work_type, rate, fee, currency) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_24(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(comet_name: str, name: str, relative: str, orbit_period: int, - relative_age: int, multiple: int) -> Dict[str, Any]: + def generate_from_variables( + comet_name: str, name: str, relative: str, orbit_period: int, relative_age: int, multiple: int + ) -> Dict[str, Any]: second_viewing_age = relative_age * multiple first_viewing_age = second_viewing_age - orbit_period - + question = f"Comet {comet_name} orbits the sun every {orbit_period} years. {name}'s {relative} saw the Comet when he was {relative_age} years old. {name} saw the comet a second time when he was {multiple} times the age his {relative} was when he saw the Comet. How old was {name} when he saw the Comet for the first time?" - + answer_cot = f"{name} saw the Comet for the second time when he was {relative_age} years * {multiple}= {second_viewing_age} years old.\nComet {comet_name} can be seen every {orbit_period} years, so {name} saw the comet for the first time when he was {second_viewing_age} years - {orbit_period} years = {first_viewing_age} years old.\n#### {first_viewing_age}" - + return { - 'question': question, - 'answer': str(first_viewing_age), - 'answer_cot': answer_cot, - 'answer_value': first_viewing_age, - 'variables': { - 'comet_name': comet_name, - 'name': name, - 'relative': relative, - 'orbit_period': orbit_period, - 'relative_age': relative_age, - 'multiple': multiple, - 'second_viewing_age': second_viewing_age, - 'first_viewing_age': first_viewing_age - } + "question": question, + "answer": str(first_viewing_age), + "answer_cot": answer_cot, + "answer_value": first_viewing_age, + "variables": { + "comet_name": comet_name, + "name": name, + "relative": relative, + "orbit_period": orbit_period, + "relative_age": relative_age, + "multiple": multiple, + "second_viewing_age": second_viewing_age, + "first_viewing_age": first_viewing_age, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - comets = ['Halley', 'Hale-Bopp', 'Hyakutake', 'Encke'] - names = ['William', 'James', 'John', 'Robert', 'Michael', 'David'] - relatives = ['dad', 'father', 'uncle', 'grandfather'] - multiples = ['two', 'three', 'four'] - + comets = ["Halley", "Hale-Bopp", "Hyakutake", "Encke"] + names = ["William", "James", "John", "Robert", "Michael", "David"] + relatives = ["dad", "father", "uncle", "grandfather"] + multiples = ["two", "three", "four"] + comet_name = rng.choice(comets) name = rng.choice(names) relative = rng.choice(relatives) multiple = rng.choice(multiples) - multiple_num = {'two': 2, 'three': 3, 'four': 4}[multiple] - + multiple_num = {"two": 2, "three": 3, "four": 4}[multiple] + orbit_period = int(rng.randrange(50, int(101 * difficulty), 5)) relative_age = int(rng.randint(20, int(51 * difficulty))) - + # Ensure conditions are met - while (multiple_num * relative_age >= 100 or - multiple_num * relative_age <= orbit_period or - (multiple_num * relative_age - orbit_period) % 1 != 0): + while ( + multiple_num * relative_age >= 100 + or multiple_num * relative_age <= orbit_period + or (multiple_num * relative_age - orbit_period) % 1 != 0 + ): relative_age = int(rng.randint(20, int(51 * difficulty))) - - result = generate_from_variables(comet_name, name, relative, orbit_period, - relative_age, multiple_num) - + + result = generate_from_variables(comet_name, name, relative, orbit_period, relative_age, multiple_num) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_25(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(food: str, calories: int, size: int, servings: int, - total_target: int, consumed: int, unit: str) -> Dict[str, Any]: - + def generate_from_variables( + food: str, calories: int, size: int, servings: int, total_target: int, consumed: int, unit: str + ) -> Dict[str, Any]: + calories_left = total_target - consumed serving_fraction = Fraction(calories_left, calories) grams_per_serving = size // servings @@ -1650,38 +1750,40 @@ def generate_25(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"According to its nutritional info, a bag of {food} has {calories} calories per serving. If a {size} {unit} bag has {servings} servings, how many {unit} can you eat if your daily calorie target is {total_target} and you have already consumed {consumed} calories?" - answer_cot = f"If the total calorie target is {total_target} and I have consumed {consumed} calories then I have {total_target}-{consumed} = {calories_left} calories left to eat\n" \ - f"If each serving of {food} has {calories} calories and I only have {calories_left} calories left to eat, then I can only eat {calories_left}/{calories} of a serving = {serving_fraction} of a serving\n" \ - f"We also know that a {size} {unit} bag of {food} has {servings} servings, hence each serving has {size} {unit}/{servings} = {grams_per_serving} {unit}\n" \ - f"If I can only eat {serving_fraction} of a serving, then I can eat only {grams_per_serving} * {serving_fraction} = {grams_allowed} {unit}\n" \ - f"#### {float(grams_allowed)}" + answer_cot = ( + f"If the total calorie target is {total_target} and I have consumed {consumed} calories then I have {total_target}-{consumed} = {calories_left} calories left to eat\n" + f"If each serving of {food} has {calories} calories and I only have {calories_left} calories left to eat, then I can only eat {calories_left}/{calories} of a serving = {serving_fraction} of a serving\n" + f"We also know that a {size} {unit} bag of {food} has {servings} servings, hence each serving has {size} {unit}/{servings} = {grams_per_serving} {unit}\n" + f"If I can only eat {serving_fraction} of a serving, then I can eat only {grams_per_serving} * {serving_fraction} = {grams_allowed} {unit}\n" + f"#### {float(grams_allowed)}" + ) return { - 'question': question, - 'answer': str(float(grams_allowed)), - 'answer_cot': answer_cot, - 'answer_value': float(grams_allowed), - 'variables': { - 'food': food, - 'calories': calories, - 'size': size, - 'servings': servings, - 'total_target': total_target, - 'consumed': consumed, - 'unit': unit, - 'calories_left': calories_left, - 'grams_per_serving': grams_per_serving, - 'serving_fraction': serving_fraction - } + "question": question, + "answer": str(float(grams_allowed)), + "answer_cot": answer_cot, + "answer_value": float(grams_allowed), + "variables": { + "food": food, + "calories": calories, + "size": size, + "servings": servings, + "total_target": total_target, + "consumed": consumed, + "unit": unit, + "calories_left": calories_left, + "grams_per_serving": grams_per_serving, + "serving_fraction": serving_fraction, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: foods = ["popcorn", "breads", "cookies"] units = ["grams", "ounces", "oz"] - + food = rng.choice(foods) unit = rng.choice(units) - + calories = int(rng.randrange(150, int(500 * difficulty), 25)) size = int(rng.randrange(100, int(400 * difficulty), 25)) servings = int(rng.randint(4, int(8 * difficulty))) @@ -1689,9 +1791,11 @@ def generate_25(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: consumed = int(rng.randrange(600, int(1800 * difficulty), 25)) # Ensure conditions are met - while (consumed >= total_target or - not (size % servings == 0) or - not ((size//servings) * Fraction(total_target-consumed, calories)).denominator == 1): + while ( + consumed >= total_target + or not (size % servings == 0) + or not ((size // servings) * Fraction(total_target - consumed, calories)).denominator == 1 + ): calories = int(rng.randrange(150, int(500 * difficulty), 25)) size = int(rng.randrange(100, int(400 * difficulty), 25)) servings = int(rng.randint(4, int(8 * difficulty))) @@ -1699,44 +1803,45 @@ def generate_25(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: consumed = int(rng.randrange(600, int(1800 * difficulty), 25)) result = generate_from_variables(food, calories, size, servings, total_target, consumed, unit) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_26(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(n: int, ball_type: str, color: str, frac_1: float, frac_2: float) -> Dict[str, Any]: first_calc = int(n * frac_1) final_calc = int(first_calc * frac_2) - + question = f"A juggler can juggle {n} balls. {frac_1:.0%} of the balls are {ball_type} balls, and {frac_2:.0%} of the {ball_type} balls are {color}. How many {color} {ball_type} balls are there?" - + answer_cot = f"{ball_type} balls:{n} * {frac_1}={first_calc}\n{color} {ball_type} balls:{first_calc}*{frac_2}={final_calc} balls\n#### {final_calc}" return { - 'question': question, - 'answer': str(final_calc), - 'answer_cot': answer_cot, - 'answer_value': final_calc, - 'variables': { - 'total_balls': n, - 'ball_type': ball_type, - 'color': color, - 'fraction_first': frac_1, - 'fraction_second': frac_2, - 'first_calculation': first_calc, - 'final_calculation': final_calc - } + "question": question, + "answer": str(final_calc), + "answer_cot": answer_cot, + "answer_value": final_calc, + "variables": { + "total_balls": n, + "ball_type": ball_type, + "color": color, + "fraction_first": frac_1, + "fraction_second": frac_2, + "first_calculation": first_calc, + "final_calculation": final_calc, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: @@ -1746,77 +1851,87 @@ def generate_26(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: ball_type = rng.choice(ball_types) color = rng.choice(colors) - frac_1 = rng.choice(fractions) + frac_1 = rng.choice(fractions) frac_2 = rng.choice(fractions) - + # Generate n that ensures integer results n = int(rng.randint(10, int(100 * difficulty))) while not (n * frac_1).is_integer() or not (n * frac_1 * frac_2).is_integer(): n = int(rng.randint(10, int(100 * difficulty))) result = generate_from_variables(n, ball_type, color, frac_1, frac_2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_27(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, n: int, n_first: int, apartments_each: int, - percent_bigger: int, freq: int, rate: float, - currency: str) -> Dict[str, Any]: - + def generate_from_variables( + name: str, + n: int, + n_first: int, + apartments_each: int, + percent_bigger: int, + freq: int, + rate: float, + currency: str, + ) -> Dict[str, Any]: + first_two = n_first * apartments_each - third_complex = int(first_two * percent_bigger/100) + third_complex = int(first_two * percent_bigger / 100) total_apartments = first_two + third_complex + first_two weekly_visits = total_apartments * freq weekly_earnings = int(weekly_visits * rate) - + question = f"{name} collects garbage from {n} different apartment complexes. The first {n_first} have {apartments_each} apartments each and the last one is {percent_bigger}% bigger than the other {n_first} combined. {name} collects garbage {freq} times a week from each place and he gets paid {currency}{rate:.2f} per collection for each apartment. How much money does he make in a week?" - - answer_cot = f"The first {n_first} complexes have {first_two} apartments\n" \ - f"The third one has {first_two}*{percent_bigger/100}={third_complex} more apartments than those {n_first} combined\n" \ - f"So in total, it has {first_two}+{third_complex}={first_two + third_complex} apartments\n" \ - f"So he goes to {first_two + third_complex}+{first_two}={total_apartments} apartments each time\n" \ - f"That means he visits {total_apartments}*{freq}={weekly_visits} apartments every week\n" \ - f"So he makes {weekly_visits}*{currency}{rate:.2f}={currency}{weekly_earnings} every week\n" \ - f"#### {weekly_earnings}" + + answer_cot = ( + f"The first {n_first} complexes have {first_two} apartments\n" + f"The third one has {first_two}*{percent_bigger/100}={third_complex} more apartments than those {n_first} combined\n" + f"So in total, it has {first_two}+{third_complex}={first_two + third_complex} apartments\n" + f"So he goes to {first_two + third_complex}+{first_two}={total_apartments} apartments each time\n" + f"That means he visits {total_apartments}*{freq}={weekly_visits} apartments every week\n" + f"So he makes {weekly_visits}*{currency}{rate:.2f}={currency}{weekly_earnings} every week\n" + f"#### {weekly_earnings}" + ) return { - 'question': question, - 'answer': str(weekly_earnings), - 'answer_cot': answer_cot, - 'answer_value': weekly_earnings, - 'variables': { - 'name': name, - 'num_complexes': n, - 'first_complexes': n_first, - 'apartments_per_complex': apartments_each, - 'percent_increase': percent_bigger, - 'collections_per_week': freq, - 'rate_per_apartment': rate, - 'currency': currency, - 'total_apartments': total_apartments, - 'weekly_visits': weekly_visits - } + "question": question, + "answer": str(weekly_earnings), + "answer_cot": answer_cot, + "answer_value": weekly_earnings, + "variables": { + "name": name, + "num_complexes": n, + "first_complexes": n_first, + "apartments_per_complex": apartments_each, + "percent_increase": percent_bigger, + "collections_per_week": freq, + "rate_per_apartment": rate, + "currency": currency, + "total_apartments": total_apartments, + "weekly_visits": weekly_visits, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['John', 'Michael', 'David', 'James', 'Robert', 'William'] - currencies = ['$', '£', '€'] - + names = ["John", "Michael", "David", "James", "Robert", "William"] + currencies = ["$", "£", "€"] + name = rng.choice(names) currency = rng.choice(currencies) - + n = rng.randint(3, max(3, int(8 * difficulty))) n_first = n - 1 apartments = int(rng.randrange(100, int(500 * difficulty), 50)) @@ -1826,301 +1941,330 @@ def generate_27(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: rate = rng.choice(rates) # Ensure results are integers - while not ((n-1)*apartments*percent/100).is_integer(): + while not ((n - 1) * apartments * percent / 100).is_integer(): apartments = int(rng.randrange(100, int(500 * difficulty), 50)) percent = rng.randrange(20, int(81 * difficulty), 5) - + result = generate_from_variables(name, n, n_first, apartments, percent, freq, rate, currency) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_28(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, item: str, price: float, percent: float, - usage: int, extra_item: str, extra_price: float, - currency: str, unit: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, + item: str, + price: float, + percent: float, + usage: int, + extra_item: str, + extra_price: float, + currency: str, + unit: str, + ) -> Dict[str, Any]: price_increase = price * percent / 100 new_price = price + price_increase weekly_usage = usage * 7 coffee_cost = new_price * weekly_usage total_cost = coffee_cost + extra_price - + question = f"{name} goes to the store to buy some {item}. The normal brand of {item} he buys costs {currency}{price} per {unit}. He had to buy a more expensive brand that costs {int(percent)}% more since his favorite brand was sold out. He decides to buy a week's worth of {item} and he uses {usage} {unit} of {item} per day. He also decided to buy himself a {extra_item} for {currency}{extra_price}. How much did everything cost?" - + answer_cot = f"The {item} he bought was {price}*{percent/100}={price_increase} more expensive per {unit} than what he normally buys\nSo it cost {price}+{price_increase}={new_price} per {unit}\nHe goes through {usage}*7={weekly_usage} {unit}s of {item} a week\nSo he paid {new_price}*{weekly_usage}={coffee_cost} on {item}\nThat means his total bill was {coffee_cost}+{extra_price}={total_cost}\n#### {int(total_cost)}" return { - 'question': question, - 'answer': str(int(total_cost)), - 'answer_cot': answer_cot, - 'answer_value': int(total_cost), - 'variables': { - 'name': name, - 'item': item, - 'base_price': price, - 'percent_increase': percent, - 'usage_per_day': usage, - 'extra_item': extra_item, - 'extra_price': extra_price, - 'currency': currency, - 'unit': unit, - 'weekly_usage': weekly_usage, - 'total_cost': total_cost - } + "question": question, + "answer": str(int(total_cost)), + "answer_cot": answer_cot, + "answer_value": int(total_cost), + "variables": { + "name": name, + "item": item, + "base_price": price, + "percent_increase": percent, + "usage_per_day": usage, + "extra_item": extra_item, + "extra_price": extra_price, + "currency": currency, + "unit": unit, + "weekly_usage": weekly_usage, + "total_cost": total_cost, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names_male = ['John', 'Michael', 'David', 'James', 'Robert', 'William', 'Richard', 'Thomas'] - items = ['tea', 'sugar', 'flour', 'rice'] - currencies_sym = ['$', '£', '€'] - units = ['kilogram', 'kg'] - extra_items = ['cookie', 'muffin', 'bagel'] - + names_male = ["John", "Michael", "David", "James", "Robert", "William", "Richard", "Thomas"] + items = ["tea", "sugar", "flour", "rice"] + currencies_sym = ["$", "£", "€"] + units = ["kilogram", "kg"] + extra_items = ["cookie", "muffin", "bagel"] + name = rng.choice(names_male) item = rng.choice(items) currency = rng.choice(currencies_sym) unit = rng.choice(units) extra_item = rng.choice(extra_items) - + price = int(rng.randint(3, int(25 * difficulty))) percent = int(rng.randint(2, int(10 * difficulty))) * 5 usage = int(rng.randint(1, int(3 * difficulty))) extra_price = int(rng.randint(1, int(5 * difficulty))) - + # Ensure price * percent / 100 is an integer while (price * percent / 100) != int(price * percent / 100): price = int(rng.randint(3, int(25 * difficulty))) - - result = generate_from_variables(name, item, price, percent, usage, - extra_item, extra_price, currency, unit) - + + result = generate_from_variables(name, item, price, percent, usage, extra_item, extra_price, currency, unit) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_29(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name1: str, name2: str, n1: int, n2: int, - k1: int, k2: int) -> Dict[str, Any]: + def generate_from_variables(name1: str, name2: str, n1: int, n2: int, k1: int, k2: int) -> Dict[str, Any]: total_puppies = n1 + n2 spotted_puppies = k1 + k2 percentage = int(100 * spotted_puppies / total_puppies) - + question = f"{name1}'s dog has {n1} puppies, {k1} of which have spots. {name2}'s dog has {n2} puppies, {k2} of which have spots. What percentage of all the puppies have spots?" - - answer_cot = f"First find the total number of puppies: {n1} puppies + {n2} puppies = {total_puppies} puppies\n" \ - f"Then find the total number of puppies with spots: {k1} puppies + {k2} puppies = {spotted_puppies} puppies\n" \ - f"Then divide the number of spotted puppies by the total number of puppies and multiply by 100% to find the percentage of puppies with spots: {spotted_puppies} puppies / {total_puppies} puppies * 100% = {percentage}%\n" \ - f"#### {percentage}" + + answer_cot = ( + f"First find the total number of puppies: {n1} puppies + {n2} puppies = {total_puppies} puppies\n" + f"Then find the total number of puppies with spots: {k1} puppies + {k2} puppies = {spotted_puppies} puppies\n" + f"Then divide the number of spotted puppies by the total number of puppies and multiply by 100% to find the percentage of puppies with spots: {spotted_puppies} puppies / {total_puppies} puppies * 100% = {percentage}%\n" + f"#### {percentage}" + ) return { - 'question': question, - 'answer': str(percentage), - 'answer_cot': answer_cot, - 'answer_value': percentage, - 'variables': { - 'name1': name1, - 'name2': name2, - 'puppies1': n1, - 'puppies2': n2, - 'spotted1': k1, - 'spotted2': k2, - 'total_puppies': total_puppies, - 'total_spotted': spotted_puppies - } + "question": question, + "answer": str(percentage), + "answer_cot": answer_cot, + "answer_value": percentage, + "variables": { + "name1": name1, + "name2": name2, + "puppies1": n1, + "puppies2": n2, + "spotted1": k1, + "spotted2": k2, + "total_puppies": total_puppies, + "total_spotted": spotted_puppies, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ["Jennifer", "Michael", "Christopher", "Jessica", "Matthew", "Ashley", - "Joshua", "Amanda", "Daniel", "David", "James", "Robert", "John", "Joseph"] - + names = [ + "Jennifer", + "Michael", + "Christopher", + "Jessica", + "Matthew", + "Ashley", + "Joshua", + "Amanda", + "Daniel", + "David", + "James", + "Robert", + "John", + "Joseph", + ] + name1, name2 = rng.sample(names, 2) - + # Scale ranges by difficulty but ensure values remain integers n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) n2 = int(rng.randrange(400, int(650 * difficulty), 5)) k1 = int(rng.randrange(170, int(290 * difficulty), 10)) k2 = int(rng.randrange(120, int(170 * difficulty), 10)) - + # Ensure conditions are met while (k1 + k2) >= (n1 + n2) or (n1 + n2) % (k1 + k2) != 0: n1 = int(rng.randrange(950, int(1050 * difficulty), 5)) n2 = int(rng.randrange(400, int(650 * difficulty), 5)) k1 = int(rng.randrange(170, int(290 * difficulty), 10)) k2 = int(rng.randrange(120, int(170 * difficulty), 10)) - + result = generate_from_variables(name1, name2, n1, n2, k1, k2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_30(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(group: str, n: int, n_1: int, n_2: int, - hobby1: str, hobby2: str, hobby3: str, hobby4: str) -> Dict[str, Any]: + def generate_from_variables( + group: str, n: int, n_1: int, n_2: int, hobby1: str, hobby2: str, hobby3: str, hobby4: str + ) -> Dict[str, Any]: n_4 = 2 * n_2 # number that like hobby4 (music) n_3 = n - (n_1 + n_2 + n_4) # number that like hobby3 (video games) - + question = f"A {group} of {n} students has various hobbies. {n_1} like to {hobby1}, {n_2} like to play {hobby2}, and the rest like to either {hobby3} or {hobby4}. How many like to {hobby3} if the number that like to {hobby4} is twice the number that prefer playing {hobby2}?" - + answer_cot = f"The number of students that like to {hobby4} is twice as many as the number who like {hobby2}, so 2 * {n_2} = {n_4}\nThe number that like to {hobby3} is {n} total students - {n_1} {hobby1} - {n_2} {hobby2} - {n_4} {hobby4} = {n_3}\n#### {n_3}" - + return { - 'question': question, - 'answer': str(n_3), - 'answer_cot': answer_cot, - 'answer_value': n_3, - 'variables': { - 'group_type': group, - 'total_students': n, - 'hobby1_count': n_1, - 'hobby2_count': n_2, - 'hobby3_count': n_3, - 'hobby4_count': n_4, - 'hobby1': hobby1, - 'hobby2': hobby2, - 'hobby3': hobby3, - 'hobby4': hobby4 - } + "question": question, + "answer": str(n_3), + "answer_cot": answer_cot, + "answer_value": n_3, + "variables": { + "group_type": group, + "total_students": n, + "hobby1_count": n_1, + "hobby2_count": n_2, + "hobby3_count": n_3, + "hobby4_count": n_4, + "hobby1": hobby1, + "hobby2": hobby2, + "hobby3": hobby3, + "hobby4": hobby4, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: groups = ["group", "class"] - hobbies = ['read', 'paint', 'hike', 'dance', 'bake', 'play video games', 'play music'] - sports = ['basketball', 'soccer', 'tennis', 'baseball', 'volleyball'] - + hobbies = ["read", "paint", "hike", "dance", "bake", "play video games", "play music"] + sports = ["basketball", "soccer", "tennis", "baseball", "volleyball"] + group = rng.choice(groups) hobby2 = rng.choice(sports) hobby1, hobby3, hobby4 = rng.sample([h for h in hobbies if h not in [hobby2]], 3) - + # Generate numbers that satisfy conditions n = int(rng.randint(20, int(200 * difficulty))) - n_2 = int(rng.randint(2, n//6)) # Keep n_2 small since we multiply by 2 - n_1 = int(rng.randint(2, n//3)) - + n_2 = int(rng.randint(2, n // 6)) # Keep n_2 small since we multiply by 2 + n_1 = int(rng.randint(2, n // 3)) + # Verify n_1 + n_2 + (2*n_2) < n - while n_1 + 3*n_2 >= n: + while n_1 + 3 * n_2 >= n: n = int(rng.randint(20, int(200 * difficulty))) - n_2 = int(rng.randint(2, n//6)) - n_1 = int(rng.randint(2, n//3)) - + n_2 = int(rng.randint(2, n // 6)) + n_1 = int(rng.randint(2, n // 3)) + result = generate_from_variables(group, n, n_1, n_2, hobby1, hobby2, hobby3, hobby4) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_31(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - - def generate_from_variables(name: str, fruit: str, total: int, n1: int, n2: int, n3: int, - sibling1: str, sibling2: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, fruit: str, total: int, n1: int, n2: int, n3: int, sibling1: str, sibling2: str + ) -> Dict[str, Any]: slice2 = n1 + n2 slice3 = slice2 + n3 total_eaten = n1 + slice2 + slice3 - + question = f"{name} sliced an {fruit} into {total} pieces. She ate {n1} slice, her {sibling1} ate {n2} more than her, and her {sibling2} ate {n3} more than her {sibling1}. How many slices of {fruit} did they all eat?" - + answer_cot = f"Her {sibling1} ate {n1} + {n2} = {slice2} slices.\nHer {sibling2} ate {slice2} + {n3} = {slice3} slices.\nThey ate a total of {n1} + {slice2} + {slice3} = {total_eaten} slices.\n#### {total_eaten}" return { - 'question': question, - 'answer': str(total_eaten), - 'answer_cot': answer_cot, - 'answer_value': total_eaten, - 'variables': { - 'name': name, - 'fruit': fruit, - 'total_slices': total, - 'first_person_slices': n1, - 'second_person_extra': n2, - 'third_person_extra': n3, - 'sibling1': sibling1, - 'sibling2': sibling2, - 'total_eaten': total_eaten - } + "question": question, + "answer": str(total_eaten), + "answer_cot": answer_cot, + "answer_value": total_eaten, + "variables": { + "name": name, + "fruit": fruit, + "total_slices": total, + "first_person_slices": n1, + "second_person_extra": n2, + "third_person_extra": n3, + "sibling1": sibling1, + "sibling2": sibling2, + "total_eaten": total_eaten, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names_female = ["Emma", "Olivia", "Ava", "Isabella", "Sophia", "Mia", "Charlotte", "Doxa"] fruits = ["orange", "pear", "peach", "mango", "kiwi", "apple"] siblings = ["brother", "sister", "cousin", "friend"] - + name = rng.choice(names_female) fruit = rng.choice(fruits) sibling1, sibling2 = rng.sample(siblings, 2) - + total = int(rng.randint(6, int(33 * difficulty))) n1 = int(rng.randint(3, int(15 * difficulty))) n2 = int(rng.randint(5, int(13 * difficulty))) n3 = int(rng.randint(3, int(14 * difficulty))) - + # Ensure conditions are met while n1 + (n1 + n2) + (n1 + n2 + n3) > total: n1 = int(rng.randint(3, int(15 * difficulty))) n2 = int(rng.randint(5, int(13 * difficulty))) n3 = int(rng.randint(3, int(14 * difficulty))) - + result = generate_from_variables(name, fruit, total, n1, n2, n3, sibling1, sibling2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_32(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, periods: int, extra_classes: int, - mins_per_class: int, days: int, weekend_fraction: float) -> Dict[str, Any]: + def generate_from_variables( + name: str, periods: int, extra_classes: int, mins_per_class: int, days: int, weekend_fraction: float + ) -> Dict[str, Any]: total_classes = periods + extra_classes - daily_mins = total_classes * mins_per_class + daily_mins = total_classes * mins_per_class weekly_mins = daily_mins * days weekend_mins = int(weekly_mins * weekend_fraction) total_mins = weekly_mins + 2 * weekend_mins @@ -2128,231 +2272,247 @@ def generate_32(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"There are {periods} periods in the day for a normal student but {name} has to take {extra_classes} extra classes. Each class is {mins_per_class} minutes long. He goes to class for {days} days a week. He then spends {weekend_fraction} of his weekly minutes each on Saturday and Sunday as extra learning time. How many hours a week does he spend learning?" - answer_cot = f"He takes {periods}+{extra_classes}={total_classes} classes a day\n" \ - f"That means he spends {mins_per_class}*{total_classes}={daily_mins} minutes per day in class\n" \ - f"So he spends {daily_mins}*{days}={weekly_mins} minutes a week\n" \ - f"That means he spends {weekly_mins}*{weekend_fraction}={weekend_mins} minutes each on Saturday and Sunday\n" \ - f"So he spends {weekly_mins}+{weekend_mins}+{weekend_mins}={total_mins} minutes per week\n" \ - f"So he spends {total_mins}/60={total_hours} hours per week\n#### {total_hours}" + answer_cot = ( + f"He takes {periods}+{extra_classes}={total_classes} classes a day\n" + f"That means he spends {mins_per_class}*{total_classes}={daily_mins} minutes per day in class\n" + f"So he spends {daily_mins}*{days}={weekly_mins} minutes a week\n" + f"That means he spends {weekly_mins}*{weekend_fraction}={weekend_mins} minutes each on Saturday and Sunday\n" + f"So he spends {weekly_mins}+{weekend_mins}+{weekend_mins}={total_mins} minutes per week\n" + f"So he spends {total_mins}/60={total_hours} hours per week\n#### {total_hours}" + ) return { - 'question': question, - 'answer': str(total_hours), - 'answer_cot': answer_cot, - 'answer_value': total_hours, - 'variables': { - 'name': name, - 'periods': periods, - 'extra_classes': extra_classes, - 'mins_per_class': mins_per_class, - 'days': days, - 'weekend_fraction': weekend_fraction, - 'total_classes': total_classes, - 'daily_mins': daily_mins, - 'weekly_mins': weekly_mins, - 'weekend_mins': weekend_mins, - 'total_mins': total_mins - } + "question": question, + "answer": str(total_hours), + "answer_cot": answer_cot, + "answer_value": total_hours, + "variables": { + "name": name, + "periods": periods, + "extra_classes": extra_classes, + "mins_per_class": mins_per_class, + "days": days, + "weekend_fraction": weekend_fraction, + "total_classes": total_classes, + "daily_mins": daily_mins, + "weekly_mins": weekly_mins, + "weekend_mins": weekend_mins, + "total_mins": total_mins, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["John", "James", "William", "Michael", "David", "Richard", "Thomas"] fractions = ["1/16", "1/8", "1/4", "1/2"] - + name = rng.choice(names) periods = int(rng.randint(5, int(10 * difficulty))) extra_classes = int(rng.randint(1, int(5 * difficulty))) mins_per_class = int(rng.randrange(30, int(61 * difficulty), 5)) days = int(rng.randint(4, int(7 * difficulty))) weekend_fraction = float(eval(rng.choice(fractions))) - + # Ensure results are integers - while not (((periods + extra_classes) * mins_per_class * days * weekend_fraction).is_integer() and - (((periods + extra_classes) * mins_per_class * days + - 2 * (periods + extra_classes) * mins_per_class * days * weekend_fraction) / 60).is_integer()): + while not ( + ((periods + extra_classes) * mins_per_class * days * weekend_fraction).is_integer() + and ( + ( + (periods + extra_classes) * mins_per_class * days + + 2 * (periods + extra_classes) * mins_per_class * days * weekend_fraction + ) + / 60 + ).is_integer() + ): periods = int(rng.randint(5, int(10 * difficulty))) extra_classes = int(rng.randint(1, int(5 * difficulty))) mins_per_class = int(rng.randrange(30, int(61 * difficulty), 5)) days = int(rng.randint(4, int(7 * difficulty))) - - result = generate_from_variables(name, periods, extra_classes, mins_per_class, - days, weekend_fraction) - + + result = generate_from_variables(name, periods, extra_classes, mins_per_class, days, weekend_fraction) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_33(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(name1: str, name2: str, mult: int, n: int) -> Dict[str, Any]: n_mult = n * mult daily_total = n + n_mult weekly_total = daily_total * 7 - + question = f"{name1} operates the cash register exactly {mult} times as fast as her less-experienced colleague {name2}. Daily, {name2} processes {n} customers. What is the total weekly production for the two if they work all days of the week?" - - answer_cot = f"While {name2} is processing {n} orders in a day, {name1} processes {n} orders/day * {mult} = {n_mult} orders/day.\n" \ - f"In a day, they process {n_mult} orders/day + {n} orders/day = {daily_total} orders together.\n" \ - f"The total number of orders the two processes in a week is {daily_total} orders/day * 7 days/week = {weekly_total} orders\n" \ - f"#### {weekly_total}" + + answer_cot = ( + f"While {name2} is processing {n} orders in a day, {name1} processes {n} orders/day * {mult} = {n_mult} orders/day.\n" + f"In a day, they process {n_mult} orders/day + {n} orders/day = {daily_total} orders together.\n" + f"The total number of orders the two processes in a week is {daily_total} orders/day * 7 days/week = {weekly_total} orders\n" + f"#### {weekly_total}" + ) return { - 'question': question, - 'answer': str(weekly_total), - 'answer_cot': answer_cot, - 'answer_value': weekly_total, - 'variables': { - 'name1': name1, - 'name2': name2, - 'multiplier': mult, - 'base_rate': n, - 'fast_rate': n_mult, - 'daily_total': daily_total, - 'weekly_total': weekly_total - } + "question": question, + "answer": str(weekly_total), + "answer_cot": answer_cot, + "answer_value": weekly_total, + "variables": { + "name1": name1, + "name2": name2, + "multiplier": mult, + "base_rate": n, + "fast_rate": n_mult, + "daily_total": daily_total, + "weekly_total": weekly_total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names_female = ["Julie", "Sarah", "Emma", "Sophia", "Olivia", "Isabella", "Mia", "Charlotte"] multi_times = [2, 3, 4] - + name1, name2 = rng.sample(names_female, 2) mult = rng.choice(multi_times) n = int(rng.randint(30, int(100 * difficulty))) - + # Ensure conditions are met while not (n * mult).is_integer() or not ((n + n * mult) * 7).is_integer(): n = int(rng.randint(30, int(100 * difficulty))) - + result = generate_from_variables(name1, name2, mult, n) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_34(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(event: str, item: str, family: str, n: int, m: int, total: int) -> Dict[str, Any]: twins_total = 2 * n remaining = total - twins_total friends_found = remaining - m - + question = f"The {event} team hid {total} {item}. The {family} twins each found {n} {item}. All the other {item} except {m} were found by their friends. How many {item} did the friends find?" - + answer_cot = f"The {family} twins found, {n} * 2 = {twins_total} {item}.\nThe number that remained hidden was {total} - {twins_total} = {remaining} {item}\nSince {m} {item} were not found, this means the friends found {remaining} - {m} = {friends_found} {item}\n#### {friends_found}" - + return { - 'question': question, - 'answer': str(friends_found), - 'answer_cot': answer_cot, - 'answer_value': friends_found, - 'variables': { - 'event': event, - 'item': item, - 'family': family, - 'items_per_twin': n, - 'unfound_items': m, - 'total_items': total, - 'twins_total': twins_total, - 'friends_found': friends_found - } + "question": question, + "answer": str(friends_found), + "answer_cot": answer_cot, + "answer_value": friends_found, + "variables": { + "event": event, + "item": item, + "family": family, + "items_per_twin": n, + "unfound_items": m, + "total_items": total, + "twins_total": twins_total, + "friends_found": friends_found, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: events = ["Halloween candy hunt", "Treasure hunt", "Scavenger hunt", "Charity fundraiser"] items = ["eggs", "treats", "toys", "coins", "tokens", "balls", "candies", "goodies"] families = ["Johnson", "Williams", "Mirzakhani", "Lopez", "Garcia", "Lee"] - + event = rng.choice(events) item = rng.choice(items) family = rng.choice(families) - + total = int(rng.randrange(50, int(201 * difficulty), 10)) n = int(rng.randint(10, int(51 * difficulty))) m = int(rng.randint(5, int(21 * difficulty))) - + # Ensure conditions are met while 2 * n + m >= total: n = int(rng.randint(10, int(51 * difficulty))) m = int(rng.randint(5, int(21 * difficulty))) - + result = generate_from_variables(event, item, family, n, m, total) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_35(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(job: str, building: str, room: str, num_rooms: int, - num_days: int, time_per_room: int, hours_per_day: int) -> Dict[str, Any]: - + def generate_from_variables( + job: str, building: str, room: str, num_rooms: int, num_days: int, time_per_room: int, hours_per_day: int + ) -> Dict[str, Any]: + rooms_per_day = num_rooms // num_days minutes_per_day = rooms_per_day * time_per_room hours_cleaning = minutes_per_day / 60 percentage = int(100 * hours_cleaning / hours_per_day) question = f"A {job} has to clean a {building} with {num_rooms} {room}s. They have {num_days} days to get it done. It takes them {time_per_room} minutes per {room}. If they work {hours_per_day} hour day, what percentage of their day, on average, is spent cleaning {room}s?" - - answer_cot = f"They have to clean {rooms_per_day} {room}s a day because {num_rooms} / {num_days} = {rooms_per_day}\n" \ - f"They spend {minutes_per_day} minutes cleaning per day because {rooms_per_day} x {time_per_room} = {minutes_per_day}\n" \ - f"They spend {hours_cleaning} hours a day because {minutes_per_day} / 60 = {hours_cleaning}\n" \ - f"They spend {hours_cleaning/hours_per_day} of their day cleaning {room}s because {hours_cleaning} / {hours_per_day} = {hours_cleaning/hours_per_day}\n" \ - f"They spend {percentage}% of their day cleaning {room}s because {hours_cleaning/hours_per_day} x 100 = {percentage}\n" \ - f"#### {percentage}" + + answer_cot = ( + f"They have to clean {rooms_per_day} {room}s a day because {num_rooms} / {num_days} = {rooms_per_day}\n" + f"They spend {minutes_per_day} minutes cleaning per day because {rooms_per_day} x {time_per_room} = {minutes_per_day}\n" + f"They spend {hours_cleaning} hours a day because {minutes_per_day} / 60 = {hours_cleaning}\n" + f"They spend {hours_cleaning/hours_per_day} of their day cleaning {room}s because {hours_cleaning} / {hours_per_day} = {hours_cleaning/hours_per_day}\n" + f"They spend {percentage}% of their day cleaning {room}s because {hours_cleaning/hours_per_day} x 100 = {percentage}\n" + f"#### {percentage}" + ) return { - 'question': question, - 'answer': str(percentage), - 'answer_cot': answer_cot, - 'answer_value': percentage, - 'variables': { - 'job': job, - 'building': building, - 'room': room, - 'num_rooms': num_rooms, - 'num_days': num_days, - 'time_per_room': time_per_room, - 'hours_per_day': hours_per_day, - 'rooms_per_day': rooms_per_day, - 'minutes_per_day': minutes_per_day, - 'hours_cleaning': hours_cleaning, - 'percentage': percentage - } + "question": question, + "answer": str(percentage), + "answer_cot": answer_cot, + "answer_value": percentage, + "variables": { + "job": job, + "building": building, + "room": room, + "num_rooms": num_rooms, + "num_days": num_days, + "time_per_room": time_per_room, + "hours_per_day": hours_per_day, + "rooms_per_day": rooms_per_day, + "minutes_per_day": minutes_per_day, + "hours_cleaning": hours_cleaning, + "percentage": percentage, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: jobs = ["janitor", "cleaner", "maintenance worker"] buildings = ["office building", "hospital", "university"] rooms = ["room", "floor"] - + job = rng.choice(jobs) building = rng.choice(buildings) room = rng.choice(rooms) @@ -2360,147 +2520,163 @@ def generate_35(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: num_days = int(rng.randint(3, int(12 * difficulty))) time_per_room = int(rng.randrange(10, int(46 * difficulty), 5)) hours_per_day = int(rng.randint(6, int(17 * difficulty))) - + # Generate num_rooms ensuring divisibility by num_days rooms_per_day = rng.randint(5, int(20 * difficulty)) num_rooms = rooms_per_day * num_days - + # Ensure conditions are met - while (num_rooms/num_days) * time_per_room >= hours_per_day * 60: + while (num_rooms / num_days) * time_per_room >= hours_per_day * 60: rooms_per_day = rng.randint(5, int(20 * difficulty)) num_rooms = rooms_per_day * num_days - result = generate_from_variables(job, building, room, num_rooms, num_days, - time_per_room, hours_per_day) - + result = generate_from_variables(job, building, room, num_rooms, num_days, time_per_room, hours_per_day) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_36(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(n: int, p1: int, r1: int, name: str, s1: str, s2: str, s3: str) -> Dict[str, Any]: - easy_questions = int(n * (p1/100)) - other_questions = int(n * (1-p1/100)) - easy_correct = int(easy_questions * (r1/100)) + easy_questions = int(n * (p1 / 100)) + other_questions = int(n * (1 - p1 / 100)) + easy_correct = int(easy_questions * (r1 / 100)) other_correct = int(other_questions * 0.5) total_correct = easy_correct + other_correct question = f"In a {n}-item quiz, {p1}% of the questions are {s1}, and the rest are equally divided as {s2} and {s3} questions. If {name} is sure to get {r1}% of the {s1} questions, and half of the {s2} and {s3} questions correctly, how many points is she sure to get?" - answer_cot = f"The {s2} and {s3} questions comprises 100% - {p1}% = {100-p1}% of the quiz.\n" \ - f"There are {n} questions x {p1}/100 = {easy_questions} {s1} questions.\n" \ - f"There are a total of {n} questions x {100-p1}/100 = {other_questions} {s2} and {s3} questions.\n" \ - f"If {name} is sure to get {r1}% of the {s1} questions, then this means she is sure of her {easy_questions} questions x {r1}/100 = {easy_correct} points.\n" \ - f"From the {s2} and {s3} questions, she is sure to get half of it correctly so that is {other_questions} questions * 0.5 = {other_correct} points.\n" \ - f"Thus, she is sure of getting {easy_correct} points + {other_correct} points = {total_correct} points in her quiz.\n#### {total_correct}" + answer_cot = ( + f"The {s2} and {s3} questions comprises 100% - {p1}% = {100-p1}% of the quiz.\n" + f"There are {n} questions x {p1}/100 = {easy_questions} {s1} questions.\n" + f"There are a total of {n} questions x {100-p1}/100 = {other_questions} {s2} and {s3} questions.\n" + f"If {name} is sure to get {r1}% of the {s1} questions, then this means she is sure of her {easy_questions} questions x {r1}/100 = {easy_correct} points.\n" + f"From the {s2} and {s3} questions, she is sure to get half of it correctly so that is {other_questions} questions * 0.5 = {other_correct} points.\n" + f"Thus, she is sure of getting {easy_correct} points + {other_correct} points = {total_correct} points in her quiz.\n#### {total_correct}" + ) return { - 'question': question, - 'answer': str(total_correct), - 'answer_cot': answer_cot, - 'answer_value': total_correct, - 'variables': { - 'total_questions': n, - 'easy_percent': p1, - 'easy_correct_percent': r1, - 'student_name': name, - 'easy_subject': s1, - 'medium_subject': s2, - 'hard_subject': s3, - 'easy_questions': easy_questions, - 'other_questions': other_questions, - 'easy_correct': easy_correct, - 'other_correct': other_correct - } + "question": question, + "answer": str(total_correct), + "answer_cot": answer_cot, + "answer_value": total_correct, + "variables": { + "total_questions": n, + "easy_percent": p1, + "easy_correct_percent": r1, + "student_name": name, + "easy_subject": s1, + "medium_subject": s2, + "hard_subject": s3, + "easy_questions": easy_questions, + "other_questions": other_questions, + "easy_correct": easy_correct, + "other_correct": other_correct, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - subjects = ["history", "geography", "biology", "chemistry", "physics", - "economics", "literature", "algebra", "geometry"] + subjects = [ + "history", + "geography", + "biology", + "chemistry", + "physics", + "economics", + "literature", + "algebra", + "geometry", + ] names = ["Emma", "Sophia", "Olivia", "Ava", "Isabella", "Mia", "Charlotte"] - + # Generate valid numbers ensuring integer results while True: n = int(rng.randrange(10, int(151 * difficulty), 10)) p1 = int(rng.randrange(5, int(71 * difficulty), 5)) r1 = int(rng.randrange(5, int(101 * difficulty), 5)) - + # Check conditions - if (n * (p1/100)).is_integer() and \ - (n * (p1/100) * (r1/100)).is_integer() and \ - (n*(1-(p1/100))*0.5).is_integer(): + if ( + (n * (p1 / 100)).is_integer() + and (n * (p1 / 100) * (r1 / 100)).is_integer() + and (n * (1 - (p1 / 100)) * 0.5).is_integer() + ): break - + name = rng.choice(names) s1, s2, s3 = rng.sample(subjects, 3) - + result = generate_from_variables(n, p1, r1, name, s1, s2, s3) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_37(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(worker: str, base: int, unit: str, tool1: str, - tool2: str, tool3: str, mult1: int, mult2: int, - n: int, days: int) -> Dict[str, Any]: + def generate_from_variables( + worker: str, base: int, unit: str, tool1: str, tool2: str, tool3: str, mult1: int, mult2: int, n: int, days: int + ) -> Dict[str, Any]: iron_amount = base * mult1 - steel_amount = int(iron_amount * (1 + mult2/100)) + steel_amount = int(iron_amount * (1 + mult2 / 100)) daily_total = steel_amount * n total_amount = daily_total * days question = f"One {worker} can mine {base} {unit} of ore per day with {tool1}. He can mine {mult1} times as much with a {tool2} and {mult2}% more with a {tool3} than with a {tool2}. How many {unit} of ore can {n} {worker}s with {tool3}s mine in a month with {days} days?" - - answer_cot = f"First find how much ore a {worker} can mine with a {tool2}: {base} {unit}/day * {mult1} = {iron_amount} {unit}/day\n" \ - f"Then multiply that amount by {100+mult2}% to find how much a {worker} can mine with a {tool3}: {iron_amount} {unit}/day * {100+mult2}% = {steel_amount} {unit}/day\n" \ - f"Then multiply the amount one {worker} can mine in a day with a {tool3} by the number of {worker}s: {steel_amount} {unit}/day/{worker} * {n} {worker}s = {daily_total} {unit}/day\n" \ - f"Then multiply the daily amount of ore by the number of days to find the total ore mined in a month: {daily_total} {unit}/day * {days} days = {total_amount} {unit}/day\n" \ - f"#### {total_amount}" + + answer_cot = ( + f"First find how much ore a {worker} can mine with a {tool2}: {base} {unit}/day * {mult1} = {iron_amount} {unit}/day\n" + f"Then multiply that amount by {100+mult2}% to find how much a {worker} can mine with a {tool3}: {iron_amount} {unit}/day * {100+mult2}% = {steel_amount} {unit}/day\n" + f"Then multiply the amount one {worker} can mine in a day with a {tool3} by the number of {worker}s: {steel_amount} {unit}/day/{worker} * {n} {worker}s = {daily_total} {unit}/day\n" + f"Then multiply the daily amount of ore by the number of days to find the total ore mined in a month: {daily_total} {unit}/day * {days} days = {total_amount} {unit}/day\n" + f"#### {total_amount}" + ) return { - 'question': question, - 'answer': str(total_amount), - 'answer_cot': answer_cot, - 'answer_value': total_amount, - 'variables': { - 'worker': worker, - 'base_amount': base, - 'unit': unit, - 'tool1': tool1, - 'tool2': tool2, - 'tool3': tool3, - 'mult1': mult1, - 'mult2': mult2, - 'num_workers': n, - 'num_days': days, - 'iron_amount': iron_amount, - 'steel_amount': steel_amount, - 'daily_total': daily_total - } + "question": question, + "answer": str(total_amount), + "answer_cot": answer_cot, + "answer_value": total_amount, + "variables": { + "worker": worker, + "base_amount": base, + "unit": unit, + "tool1": tool1, + "tool2": tool2, + "tool3": tool3, + "mult1": mult1, + "mult2": mult2, + "num_workers": n, + "num_days": days, + "iron_amount": iron_amount, + "steel_amount": steel_amount, + "daily_total": daily_total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - workers = ["miner", "goblin", "gnome", "troll"] + workers = ["miner", "goblin", "gnome", "troll"] tools1 = ["bare hands", "basic shovel", "wooden pickaxe"] units = ["pounds", "kgs"] tools2 = ["nickel pickaxe", "bronze pickaxe", "silver pickaxe"] @@ -2519,35 +2695,49 @@ def generate_37(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: days = int(rng.randint(28, 32)) # Verify conditions - while not (base * mult1 * (1 + mult2/100)).is_integer() or \ - int(base * mult1 * (1 + mult2/100) * n * days) >= 100000: + while ( + not (base * mult1 * (1 + mult2 / 100)).is_integer() + or int(base * mult1 * (1 + mult2 / 100) * n * days) >= 100000 + ): base = int(rng.randint(5, int(20 * difficulty))) - mult1 = int(rng.randint(2, int(4 * difficulty))) + mult1 = int(rng.randint(2, int(4 * difficulty))) mult2 = int(rng.randrange(30, int(80 * difficulty), 5)) n = int(rng.randint(20, int(50 * difficulty))) - result = generate_from_variables(worker, base, unit, tool1, tool2, tool3, - mult1, mult2, n, days) + result = generate_from_variables(worker, base, unit, tool1, tool2, tool3, mult1, mult2, n, days) return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_38(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, count: int, child_type: str, - item1: str, item2: str, item3: str, item4: str, item5: str, - n1: int, n2: int, n3: int, n4: int, n5: int) -> Dict[str, Any]: - + def generate_from_variables( + name: str, + count: int, + child_type: str, + item1: str, + item2: str, + item3: str, + item4: str, + item5: str, + n1: int, + n2: int, + n3: int, + n4: int, + n5: int, + ) -> Dict[str, Any]: + skeins_per_child = n1 + n2 + n3 + n4 + n5 total_skeins = count * skeins_per_child @@ -2556,19 +2746,19 @@ def generate_38(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: answer_cot = f"A full outfit for each child will require {n1} skeins per {item1} + {n2} skeins per {item2} + {n3} skeins per {item3} + {n4} skeins per pair of {item4} + {n5} skeins per pair of {item5} = {skeins_per_child} skeins of wool.\nSo to knit outfits for all of her grandchildren, she will need {count} * {skeins_per_child} = {total_skeins} skeins of wool.\n#### {total_skeins}" return { - 'question': question, - 'answer': str(total_skeins), - 'answer_cot': answer_cot, - 'answer_value': total_skeins, - 'variables': { - 'name': name, - 'count': count, - 'child_type': child_type, - 'items': [item1, item2, item3, item4, item5], - 'skeins_per_item': [n1, n2, n3, n4, n5], - 'skeins_per_child': skeins_per_child, - 'total_skeins': total_skeins - } + "question": question, + "answer": str(total_skeins), + "answer_cot": answer_cot, + "answer_value": total_skeins, + "variables": { + "name": name, + "count": count, + "child_type": child_type, + "items": [item1, item2, item3, item4, item5], + "skeins_per_item": [n1, n2, n3, n4, n5], + "skeins_per_child": skeins_per_child, + "total_skeins": total_skeins, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: @@ -2589,177 +2779,181 @@ def generate_38(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: n4 = int(rng.randint(3, int(19 * difficulty))) n5 = int(rng.randint(3, int(19 * difficulty))) - result = generate_from_variables(name, count, child_type, - item1, item2, item3, item4, item5, - n1, n2, n3, n4, n5) + result = generate_from_variables(name, count, child_type, item1, item2, item3, item4, item5, n1, n2, n3, n4, n5) return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_39(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(total: int, grade: str, school_name: str, num_girls: int, - day: str, absent_girls: int, absent_boys: int) -> Dict[str, Any]: + def generate_from_variables( + total: int, grade: str, school_name: str, num_girls: int, day: str, absent_girls: int, absent_boys: int + ) -> Dict[str, Any]: num_boys = total - num_girls remaining_boys = num_boys - absent_boys - + question = f"There are {total} {grade}-graders at {school_name} School. {num_girls} of them are girls. On {day}, {absent_girls} {grade}-grade girls and {absent_boys} {grade}-grade boys were absent. How many {grade} grade boys were at {school_name} School on {day}?" - + answer_cot = f"Of the {total} {grade} graders, {num_girls} are girls, so {total} students - {num_girls} girls = {num_boys} boys.\nOn {day} there were {num_boys} boys - {absent_boys} absent = {remaining_boys} boys.\n#### {remaining_boys}" return { - 'question': question, - 'answer': str(remaining_boys), - 'answer_cot': answer_cot, - 'answer_value': remaining_boys, - 'variables': { - 'total_students': total, - 'grade': grade, - 'school_name': school_name, - 'num_girls': num_girls, - 'num_boys': num_boys, - 'day': day, - 'absent_girls': absent_girls, - 'absent_boys': absent_boys, - 'remaining_boys': remaining_boys - } + "question": question, + "answer": str(remaining_boys), + "answer_cot": answer_cot, + "answer_value": remaining_boys, + "variables": { + "total_students": total, + "grade": grade, + "school_name": school_name, + "num_girls": num_girls, + "num_boys": num_boys, + "day": day, + "absent_girls": absent_girls, + "absent_boys": absent_boys, + "remaining_boys": remaining_boys, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: school_names = ["Maple Grove", "Sunny Hill", "Oak Ridge", "Pine Valley"] grades = ["first", "second", "third", "fourth", "fifth"] days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] - + school_name = rng.choice(school_names) grade = rng.choice(grades) day = rng.choice(days) - + total = int(rng.randint(50, int(200 * difficulty))) num_girls = int(rng.randint(20, total - 1)) num_boys = total - num_girls - + absent_girls = int(rng.randint(2, min(num_girls, int(10 * difficulty)))) absent_boys = int(rng.randint(2, min(num_boys, int(10 * difficulty)))) - - result = generate_from_variables(total, grade, school_name, num_girls, - day, absent_girls, absent_boys) - + + result = generate_from_variables(total, grade, school_name, num_girls, day, absent_girls, absent_boys) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_40(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(item: str, n1: int, c1: str, c2: str, c3: str, p: int) -> Dict[str, Any]: - more_cards = int(p/100 * n1) + more_cards = int(p / 100 * n1) n2 = n1 + more_cards n3 = n1 + n2 total = n3 + n3 - + question = f"In a set of {item}'s cards, there are {n1} {c1} cards, and {p}% more {c2} cards. {c3} cards are as many as the sum of {c1} and {c2} cards. How many cards of all mentioned colors are there?" - answer_cot = f"There are {p}/100 * {n1} = {more_cards} more {c2} cards than {c1} cards.\n" \ - f"Which means there are {n1} + {more_cards} = {n2} {c2} cards.\n" \ - f"{c3} cards make up to {n1} + {n2} = {n3} cards.\n" \ - f"So in total, there are {n3} + {n3} = {total} cards of different colors.\n" \ - f"#### {total}" + answer_cot = ( + f"There are {p}/100 * {n1} = {more_cards} more {c2} cards than {c1} cards.\n" + f"Which means there are {n1} + {more_cards} = {n2} {c2} cards.\n" + f"{c3} cards make up to {n1} + {n2} = {n3} cards.\n" + f"So in total, there are {n3} + {n3} = {total} cards of different colors.\n" + f"#### {total}" + ) return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'item': item, - 'n1': n1, - 'c1': c1, - 'c2': c2, - 'c3': c3, - 'p': p, - 'more_cards': more_cards, - 'total': total - } + "question": question, + "answer": str(total), + "answer_cot": answer_cot, + "answer_value": total, + "variables": { + "item": item, + "n1": n1, + "c1": c1, + "c2": c2, + "c3": c3, + "p": p, + "more_cards": more_cards, + "total": total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: items = ["magician", "artist", "chef", "scientist", "athlete"] colors = ["red", "blue", "green", "yellow", "purple", "orange"] - + item = rng.choice(items) c1, c2, c3 = rng.sample(colors, 3) - + n1 = int(rng.randint(20, int(81 * difficulty))) - + # Generate p ensuring division results in integer while True: p = int(rng.randint(20, min(90, int(100 * difficulty)))) - if (p/100 * n1).is_integer(): + if (p / 100 * n1).is_integer(): break - + result = generate_from_variables(item, n1, c1, c2, c3, p) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_41(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, event: str, organization: str, fraction: str, - current: int, total: int, currency: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, event: str, organization: str, fraction: str, current: int, total: int, currency: str + ) -> Dict[str, Any]: fraction = convert_fraction_word(fraction) fraction_val = Fraction(fraction) org_amount = int(total * fraction_val) covered_amount = org_amount + current missing_amount = total - covered_amount - + question = f"{name} is raising money for a {event}. He has applied for help from the {organization}, which has decided to cover {fraction} of the cost of the {event}. How much money is {name} missing if he has {currency}{current} and the {event} costs {currency}{total}?" - + answer_cot = f"{name}'s {organization} has decided to pay {total} * {fraction} = {currency}{org_amount} for his {event}.\nIn total {name} has covered {org_amount} + {current} = {currency}{covered_amount} for his {event}\nTherefore, {name} needs {total} - {covered_amount} = {currency}{missing_amount} more for the {event}.\n#### {missing_amount}" - + return { - 'question': question, - 'answer': str(missing_amount), - 'answer_cot': answer_cot, - 'answer_value': missing_amount, - 'variables': { - 'name': name, - 'event': event, - 'organization': organization, - 'fraction': fraction, - 'current_amount': current, - 'total_cost': total, - 'currency': currency, - 'org_contribution': org_amount, - 'covered_amount': covered_amount - } + "question": question, + "answer": str(missing_amount), + "answer_cot": answer_cot, + "answer_value": missing_amount, + "variables": { + "name": name, + "event": event, + "organization": organization, + "fraction": fraction, + "current_amount": current, + "total_cost": total, + "currency": currency, + "org_contribution": org_amount, + "covered_amount": covered_amount, + }, } def convert_fraction_word(fraction_str: str) -> str: @@ -2767,9 +2961,9 @@ def generate_41(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: # Add fraction word mapping FRACTION_WORDS = { - "half": "1/2", - "one-half": "1/2", - "quarter": "1/4", + "half": "1/2", + "one-half": "1/2", + "quarter": "1/4", } return FRACTION_WORDS.get(fraction_str.lower(), fraction_str) @@ -2779,45 +2973,53 @@ def generate_41(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: organizations = ["school", "community center", "local charity", "youth club", "parent association"] currencies = ["$", "€", "£"] fractions = ["half", "1/2", "one-half"] - + name = rng.choice(names) event = rng.choice(events) organization = rng.choice(organizations) currency = rng.choice(currencies) fraction = rng.choice(fractions) fraction = convert_fraction_word(fraction) - + # Scale ranges by difficulty but ensure results are integers current = int(rng.randrange(10, int(200 * difficulty), 5)) total = int(rng.randrange(200, int(1000 * difficulty), 10)) - + # Ensure conditions are met while current >= total or not float(total * Fraction(fraction)).is_integer(): current = int(rng.randrange(10, int(200 * difficulty), 5)) total = int(rng.randrange(200, int(1000 * difficulty), 10)) - + result = generate_from_variables(name, event, organization, fraction, current, total, currency) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_42(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(title: str, name: str, property_type: str, price: int, - fee1_name: str, fee1_percent: int, - fee2_name: str, fee2_percent: int, - loan: int) -> Dict[str, Any]: - + def generate_from_variables( + title: str, + name: str, + property_type: str, + price: int, + fee1_name: str, + fee1_percent: int, + fee2_name: str, + fee2_percent: int, + loan: int, + ) -> Dict[str, Any]: + fee1_amount = price * fee1_percent // 100 fee2_amount = price * fee2_percent // 100 total_fees = fee1_amount + fee2_amount + loan @@ -2825,39 +3027,41 @@ def generate_42(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"{title} {name} sold his {property_type} for ${price}. He paid the {fee1_name} fees that amount to {fee1_percent}% of the selling price and also paid a {fee2_name} fee that is {fee2_percent}% of the selling price. If he also paid ${loan} for the remaining loan amount of the {property_type}, how much is {title} {name}'s net proceeds from selling the {property_type}?" - answer_cot = f"{title} {name} paid ${price} x {fee1_percent}/100 = ${fee1_amount} for the {fee1_name} fees.\n" \ - f"He paid ${price} x {fee2_percent}/100 = ${fee2_amount} for the {fee2_name} fee.\n" \ - f"So, {title} {name} paid a total of ${fee1_amount} + ${fee2_amount} + ${loan} = ${total_fees} for the {fee1_name}, {fee2_name}, and loan fees.\n" \ - f"Hence, {title} {name}'s net proceeds is ${price} - ${total_fees} = ${net_proceeds}.\n#### {net_proceeds}" + answer_cot = ( + f"{title} {name} paid ${price} x {fee1_percent}/100 = ${fee1_amount} for the {fee1_name} fees.\n" + f"He paid ${price} x {fee2_percent}/100 = ${fee2_amount} for the {fee2_name} fee.\n" + f"So, {title} {name} paid a total of ${fee1_amount} + ${fee2_amount} + ${loan} = ${total_fees} for the {fee1_name}, {fee2_name}, and loan fees.\n" + f"Hence, {title} {name}'s net proceeds is ${price} - ${total_fees} = ${net_proceeds}.\n#### {net_proceeds}" + ) return { - 'question': question, - 'answer': str(net_proceeds), - 'answer_cot': answer_cot, - 'answer_value': net_proceeds, - 'variables': { - 'title': title, - 'name': name, - 'property_type': property_type, - 'price': price, - 'fee1_name': fee1_name, - 'fee1_percent': fee1_percent, - 'fee2_name': fee2_name, - 'fee2_percent': fee2_percent, - 'loan': loan, - 'fee1_amount': fee1_amount, - 'fee2_amount': fee2_amount, - 'total_fees': total_fees, - 'net_proceeds': net_proceeds - } + "question": question, + "answer": str(net_proceeds), + "answer_cot": answer_cot, + "answer_value": net_proceeds, + "variables": { + "title": title, + "name": name, + "property_type": property_type, + "price": price, + "fee1_name": fee1_name, + "fee1_percent": fee1_percent, + "fee2_name": fee2_name, + "fee2_percent": fee2_percent, + "loan": loan, + "fee1_amount": fee1_amount, + "fee2_amount": fee2_amount, + "total_fees": total_fees, + "net_proceeds": net_proceeds, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - titles = ['Mr.', 'Prof.', 'Dr.'] - names = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez'] - properties = ['house', 'apartment', 'condo', 'villa', 'cottage'] - fee1_names = ['transfer', 'registration', 'legal'] - fee2_names = ['brokerage', 'agent', 'realtor'] + titles = ["Mr.", "Prof.", "Dr."] + names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez"] + properties = ["house", "apartment", "condo", "villa", "cottage"] + fee1_names = ["transfer", "registration", "legal"] + fee2_names = ["brokerage", "agent", "realtor"] title = rng.choice(titles) name = rng.choice(names) @@ -2875,83 +3079,95 @@ def generate_42(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: price = int(rng.randrange(200000, int(1000000 * difficulty), 10000)) loan = int(rng.randrange(100000, int(700000 * difficulty), 10000)) - result = generate_from_variables(title, name, property_type, price, - fee1_name, fee1_percent, - fee2_name, fee2_percent, loan) + result = generate_from_variables( + title, name, property_type, price, fee1_name, fee1_percent, fee2_name, fee2_percent, loan + ) return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_43(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: def generate_from_variables(person1: str, item: str, n: int, relation: str, k: int) -> Dict[str, Any]: other_amount = n - k total = n + other_amount - + question = f"A {person1} has {n} {item}s. His {relation} has {k} fewer {item}s than he has. How many {item}s do they have together?" - + answer_cot = f"His {relation} has {n} - {k} = {other_amount} {item}s.\nTogether, they have {n} + {other_amount} = {total} {item}s.\n#### {total}" - + return { - 'question': question, - 'answer': str(total), - 'answer_cot': answer_cot, - 'answer_value': total, - 'variables': { - 'person1': person1, - 'item': item, - 'first_amount': n, - 'relation': relation, - 'difference': k, - 'second_amount': other_amount, - 'total': total - } + "question": question, + "answer": str(total), + "answer_cot": answer_cot, + "answer_value": total, + "variables": { + "person1": person1, + "item": item, + "first_amount": n, + "relation": relation, + "difference": k, + "second_amount": other_amount, + "total": total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: people = ["student", "boy", "child", "kid"] - items = ["marble", "sticker", "toy", "book", "pencil"] + items = ["marble", "sticker", "toy", "book", "pencil"] relations = ["sister", "brother", "friend", "cousin"] - + person1 = rng.choice(people) item = rng.choice(items) relation = rng.choice(relations) - + n = int(rng.randint(5, int(21 * difficulty))) - k = int(rng.randint(2, min(n-1, int(10 * difficulty)))) - + k = int(rng.randint(2, min(n - 1, int(10 * difficulty)))) + result = generate_from_variables(person1, item, n, relation, k) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_44(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(store: str, color1: str, color2: str, color3: str, - n1: int, n2: int, n3: int, p1: int, p2: int, p3: int, - currency: str) -> Dict[str, Any]: + def generate_from_variables( + store: str, + color1: str, + color2: str, + color3: str, + n1: int, + n2: int, + n3: int, + p1: int, + p2: int, + p3: int, + currency: str, + ) -> Dict[str, Any]: total1 = n1 * p1 - total2 = n2 * p2 + total2 = n2 * p2 total3 = n3 * p3 grand_total = total1 + total2 + total3 @@ -2960,91 +3176,98 @@ def generate_44(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: answer_cot = f"For the {color1} balls, {n1} balls * {currency}{p1}/ball = {currency}{total1}.\nFor the {color2} balls, {n2} balls * {currency}{p2}/ball = {currency}{total2}.\nFor the {color3} balls, {n3} balls * {currency}{p3}/ball = {currency}{total3}.\nFor all balls, {currency}{total1} + {currency}{total2} + {currency}{total3} = {currency}{grand_total}.\n#### {grand_total}" return { - 'question': question, - 'answer': str(grand_total), - 'answer_cot': answer_cot, - 'answer_value': grand_total, - 'variables': { - 'store': store, - 'colors': [color1, color2, color3], - 'quantities': [n1, n2, n3], - 'prices': [p1, p2, p3], - 'currency': currency, - 'subtotals': [total1, total2, total3], - 'total': grand_total - } + "question": question, + "answer": str(grand_total), + "answer_cot": answer_cot, + "answer_value": grand_total, + "variables": { + "store": store, + "colors": [color1, color2, color3], + "quantities": [n1, n2, n3], + "prices": [p1, p2, p3], + "currency": currency, + "subtotals": [total1, total2, total3], + "total": grand_total, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: stores = ["store", "shop", "market", "warehouse"] colors = ["red", "blue", "green", "yellow", "purple", "orange", "pink"] currencies = ["$", "€", "£"] - + store = rng.choice(stores) color1, color2, color3 = rng.sample(colors, 3) currency = rng.choice(currencies) - + n1 = int(rng.randint(3, int(20 * difficulty))) n2 = int(rng.randint(5, int(30 * difficulty))) n3 = int(rng.randint(15, int(50 * difficulty))) - + p1 = int(rng.randint(5, int(15 * difficulty))) p2 = int(rng.randint(3, int(10 * difficulty))) p3 = int(rng.randint(2, int(8 * difficulty))) - result = generate_from_variables(store, color1, color2, color3, n1, n2, n3, - p1, p2, p3, currency) - + result = generate_from_variables(store, color1, color2, color3, n1, n2, n3, p1, p2, p3, currency) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_45(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, event: str, food: str, obj: str, - package_husband: int, used_items: int, - total_remaining: int) -> Dict[str, Any]: - + def generate_from_variables( + name: str, event: str, food: str, obj: str, package_husband: int, used_items: int, total_remaining: int + ) -> Dict[str, Any]: + total_items = total_remaining + used_items package_size = total_items - package_husband - + question = f"{name} was preparing for a {event} at her house, where she intended to serve {food}. She noticed that she was out of plastic {obj}, so she bought a new package of {obj}. Later, her husband also bought a package of {package_husband} new {obj} and gave them to {name}. While {name} was making the {food}, she used {used_items} of the {obj} to sample her {food}. Later, when she went to set the table, she had a total of {total_remaining} {obj}. How many {obj} were in the package that {name} bought?" - + answer_cot = f"The total number of {obj} from {name} and her husband was {total_remaining}+{used_items}={total_items} {obj}.\nSince the husband bought a package of {package_husband} {obj}, then {name}'s package contained {total_items}-{package_husband}={package_size} {obj}.\n#### {package_size}" return { - 'question': question, - 'answer': str(package_size), - 'answer_cot': answer_cot, - 'answer_value': package_size, - 'variables': { - 'name': name, - 'event': event, - 'food': food, - 'obj': obj, - 'husband_package': package_husband, - 'used_items': used_items, - 'remaining': total_remaining, - 'total': total_items, - 'package_size': package_size - } + "question": question, + "answer": str(package_size), + "answer_cot": answer_cot, + "answer_value": package_size, + "variables": { + "name": name, + "event": event, + "food": food, + "obj": obj, + "husband_package": package_husband, + "used_items": used_items, + "remaining": total_remaining, + "total": total_items, + "package_size": package_size, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - names = ['Emma', 'Olivia', 'Sophia', 'Isabella', 'Ava', 'Mia', 'Charlotte'] - events = ['lunch party', 'birthday party', 'potluck party', 'baby shower', 'game night'] - foods = ['roast chicken', 'grilled salmon', 'beef stew', 'vegetable lasagna', - 'stuffed peppers', 'shrimp scampi', 'creme brulee'] - objects = ['spoons', 'forks', 'plates'] + names = ["Emma", "Olivia", "Sophia", "Isabella", "Ava", "Mia", "Charlotte"] + events = ["lunch party", "birthday party", "potluck party", "baby shower", "game night"] + foods = [ + "roast chicken", + "grilled salmon", + "beef stew", + "vegetable lasagna", + "stuffed peppers", + "shrimp scampi", + "creme brulee", + ] + objects = ["spoons", "forks", "plates"] name = rng.choice(names) event = rng.choice(events) @@ -3053,198 +3276,210 @@ def generate_45(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: package_husband = int(rng.randint(5, int(20 * difficulty))) used_items = int(rng.randint(3, int(10 * difficulty))) - + # Calculate total_remaining to satisfy conditions package_size = int(rng.randint(10, int(30 * difficulty))) total_items = package_size + package_husband total_remaining = total_items - used_items - result = generate_from_variables(name, event, food, obj, - package_husband, used_items, total_remaining) - + result = generate_from_variables(name, event, food, obj, package_husband, used_items, total_remaining) + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_46(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(fruit1: str, fruit2: str, n1: int, n2: int, - frac1: float, frac2: float, spill: int, total: int) -> Dict[str, Any]: + def generate_from_variables( + fruit1: str, fruit2: str, n1: int, n2: int, frac1: float, frac2: float, spill: int, total: int + ) -> Dict[str, Any]: n1_after_spill = n1 - spill - water_fruit1 = (n1_after_spill * frac1) - water_fruit2 = (n2 * frac2) + water_fruit1 = n1_after_spill * frac1 + water_fruit2 = n2 * frac2 total_water = water_fruit1 + water_fruit2 - + question = f"I have {n1} liters of {fruit1} drink that are {frac1} water and I wish to add it to {n2} liters of {fruit2} drink that is {frac2} water. But as I pour it, I spill {spill} liter of the {fruit1} drink. How much water is in the remaining {total} liters?" answer_cot = f"There are {n2} x {frac2} = {water_fruit2} liters of water from the {n2} liters {fruit2} drink.\nAfter {spill} liter of {fruit1} drink was spilled, there were {n1} - {spill} = {n1_after_spill} liters of {fruit1} drink left.\nOut of the {n1_after_spill} liters, {n1_after_spill} x {frac1} = {water_fruit1} liters are water.\nThus, there are a total of {water_fruit2} + {water_fruit1} = {total_water} liters of water out of the {total} liters.\n#### {int(total_water)}" return { - 'question': question, - 'answer': str(int(total_water)), - 'answer_cot': answer_cot, - 'answer_value': int(total_water), - 'variables': { - 'fruit1': fruit1, - 'fruit2': fruit2, - 'initial_amount1': n1, - 'initial_amount2': n2, - 'water_fraction1': frac1, - 'water_fraction2': frac2, - 'spilled_amount': spill, - 'total_volume': total, - 'water_content1': water_fruit1, - 'water_content2': water_fruit2 - } + "question": question, + "answer": str(int(total_water)), + "answer_cot": answer_cot, + "answer_value": int(total_water), + "variables": { + "fruit1": fruit1, + "fruit2": fruit2, + "initial_amount1": n1, + "initial_amount2": n2, + "water_fraction1": frac1, + "water_fraction2": frac2, + "spilled_amount": spill, + "total_volume": total, + "water_content1": water_fruit1, + "water_content2": water_fruit2, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: fruits = ["apple", "grape", "mango", "peach", "lemon"] - fractions = {"two-thirds": 2/3, "three-fifths": 3/5, "three-quarters": 3/4, - "one-half": 1/2, "four-fifths": 4/5} - + fractions = { + "two-thirds": 2 / 3, + "three-fifths": 3 / 5, + "three-quarters": 3 / 4, + "one-half": 1 / 2, + "four-fifths": 4 / 5, + } + fruit1, fruit2 = rng.sample(fruits, 2) frac1 = rng.choice(list(fractions.values())) frac2 = rng.choice(list(fractions.values())) - + n1 = int(rng.randint(9, int(21 * difficulty))) n2 = int(rng.randint(12, int(31 * difficulty))) spill = int(rng.randint(3, min(7, n1))) - + # Ensure conditions are met - while not (n1 + n2 - spill > 0 and - (n2 * frac2).is_integer() and - ((n1 - spill) * frac1).is_integer()): + while not (n1 + n2 - spill > 0 and (n2 * frac2).is_integer() and ((n1 - spill) * frac1).is_integer()): n1 = int(rng.randint(9, int(21 * difficulty))) n2 = int(rng.randint(12, int(31 * difficulty))) spill = int(rng.randint(3, min(7, n1))) - + total = n1 + n2 - spill - + result = generate_from_variables(fruit1, fruit2, n1, n2, frac1, frac2, spill, total) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_47(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, n1: int, c1: float, n2: int, c2: float, - c3: int, obj1: str, obj2: str, currency: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, n1: int, c1: float, n2: int, c2: float, c3: int, obj1: str, obj2: str, currency: str + ) -> Dict[str, Any]: cost1 = n1 * c1 cost2 = n2 * c2 total_cost = cost1 + cost2 + c3 - + question = f"{name} went to buy some school supplies. He bought {n1} {obj1} which cost {currency}{c1} each, {n2} {obj2} which cost {currency}{c2} each, and a rim of bond paper which cost {currency}{c3}. How much did {name} spend on everything?" - - answer_cot = f"{name} spent {n1} x {currency}{c1} = {currency}{int(cost1)} for the {obj1}.\n" \ - f"He also spent {n2} x {currency}{c2} = {currency}{int(cost2)} for the {obj2}.\n" \ - f"Therefore, {name} spent a total of {currency}{int(cost1)} + {currency}{int(cost2)} + {currency}{c3} = {currency}{int(total_cost)} for the school supplies.\n" \ - f"#### {int(total_cost)}" + + answer_cot = ( + f"{name} spent {n1} x {currency}{c1} = {currency}{int(cost1)} for the {obj1}.\n" + f"He also spent {n2} x {currency}{c2} = {currency}{int(cost2)} for the {obj2}.\n" + f"Therefore, {name} spent a total of {currency}{int(cost1)} + {currency}{int(cost2)} + {currency}{c3} = {currency}{int(total_cost)} for the school supplies.\n" + f"#### {int(total_cost)}" + ) return { - 'question': question, - 'answer': str(int(total_cost)), - 'answer_cot': answer_cot, - 'answer_value': int(total_cost), - 'variables': { - 'name': name, - 'items1_count': n1, - 'item1_cost': c1, - 'items2_count': n2, - 'item2_cost': c2, - 'paper_cost': c3, - 'item1': obj1, - 'item2': obj2, - 'currency': currency - } + "question": question, + "answer": str(int(total_cost)), + "answer_cot": answer_cot, + "answer_value": int(total_cost), + "variables": { + "name": name, + "items1_count": n1, + "item1_cost": c1, + "items2_count": n2, + "item2_cost": c2, + "paper_cost": c3, + "item1": obj1, + "item2": obj2, + "currency": currency, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["John", "Michael", "David", "James", "William", "Robert", "Thomas"] items = ["notebooks", "pencils", "erasers", "crayons", "colored pencils", "markers", "rulers", "folders"] currencies = ["$", "€", "£"] - + name = rng.choice(names) obj1, obj2 = rng.sample(items, 2) currency = rng.choice(currencies) - + n1 = int(rng.randrange(6, int(25 * difficulty), 2)) c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 # Round to nearest 0.25 n2 = int(rng.randrange(4, int(15 * difficulty), 2)) c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 c3 = int(rng.randint(10, int(25 * difficulty))) - + # Ensure conditions are met while not (n1 * c1).is_integer() or not (n2 * c2).is_integer(): c1 = round(rng.uniform(2.25, 11.5 * difficulty) * 4) / 4 c2 = round(rng.uniform(8.25, 19.5 * difficulty) * 4) / 4 - + result = generate_from_variables(name, n1, c1, n2, c2, c3, obj1, obj2, currency) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_48(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(item1: str, item2: str, shop: str, currency: str, - price1: int, price2: int, n1: int, n2: int) -> Dict[str, Any]: + def generate_from_variables( + item1: str, item2: str, shop: str, currency: str, price1: int, price2: int, n1: int, n2: int + ) -> Dict[str, Any]: total1 = n1 * price1 total2 = n2 * price2 diff = total1 - total2 - + question = f"A loaf of {item1} at the {shop} costs {currency}{price1}. {item2}s cost {currency}{price2} each. How much more do {n1} loaves of {item1} cost than {n2} {item2}s?" - - answer_cot = f"{n1} loaves of {item1} cost {n1} * {currency}{price1} = {currency}{total1}.\n" \ - f"{n2} {item2}s cost {n2} * {currency}{price2} = {currency}{total2}.\n" \ - f"The loaves of {item1} cost {currency}{total1} - {currency}{total2} = {currency}{diff} more than the {item2}s.\n" \ - f"#### {diff}" + + answer_cot = ( + f"{n1} loaves of {item1} cost {n1} * {currency}{price1} = {currency}{total1}.\n" + f"{n2} {item2}s cost {n2} * {currency}{price2} = {currency}{total2}.\n" + f"The loaves of {item1} cost {currency}{total1} - {currency}{total2} = {currency}{diff} more than the {item2}s.\n" + f"#### {diff}" + ) return { - 'question': question, - 'answer': str(diff), - 'answer_cot': answer_cot, - 'answer_value': diff, - 'variables': { - 'item1': item1, - 'item2': item2, - 'shop': shop, - 'currency': currency, - 'price1': price1, - 'price2': price2, - 'n1': n1, - 'n2': n2, - 'total1': total1, - 'total2': total2 - } + "question": question, + "answer": str(diff), + "answer_cot": answer_cot, + "answer_value": diff, + "variables": { + "item1": item1, + "item2": item2, + "shop": shop, + "currency": currency, + "price1": price1, + "price2": price2, + "n1": n1, + "n2": n2, + "total1": total1, + "total2": total2, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: @@ -3252,41 +3487,43 @@ def generate_48(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: items2 = ["bagel", "muffin", "croissant", "biscuit"] shops = ["bakery", "cafe", "store", "market"] currencies = ["$", "£", "€"] - + item1 = rng.choice(items1) item2 = rng.choice(items2) shop = rng.choice(shops) currency = rng.choice(currencies) - + price1 = int(rng.randint(2, int(10 * difficulty))) price2 = int(rng.randint(1, int(5 * difficulty))) n1 = int(rng.randint(2, int(10 * difficulty))) n2 = int(rng.randint(2, int(10 * difficulty))) - + # Ensure condition: n1 * price1 > n2 * price2 while n1 * price1 <= n2 * price2: n1 = int(rng.randint(2, int(10 * difficulty))) n2 = int(rng.randint(2, int(10 * difficulty))) result = generate_from_variables(item1, item2, shop, currency, price1, price2, n1, n2) - + return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_49(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: - def generate_from_variables(name: str, item1: str, item2: str, price1: int, price2: int, - total: float, n1: int, percent: int, currency: str) -> Dict[str, Any]: + def generate_from_variables( + name: str, item1: str, item2: str, price1: int, price2: int, total: float, n1: int, percent: int, currency: str + ) -> Dict[str, Any]: change = total * percent / 100 spent = total * (100 - percent) / 100 cost_item1 = n1 * price1 / 100 @@ -3295,36 +3532,38 @@ def generate_49(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: question = f"The vending machines sell {item1} for {price1} cents and {item2} for {price2} cents. {name} spent {currency}{total} and got {n1} bags of {item1} and had {percent}% of his money left. How many {item2} did he buy?" - answer_cot = f"{name} got {currency}{change} in change because {total} x {percent}/100 = {change}\n" \ - f"{name} spent {currency}{spent} because {total} - {change} = {spent}\n" \ - f"{name} spent {currency}{cost_item1} on {item1} because {n1} x {price1/100} = {cost_item1}\n" \ - f"{name} spent {spent_item2} on {item2} because {spent} - {cost_item1} = {spent_item2}\n" \ - f"{name} bought {n2} {item2} because {spent_item2} / {price2/100} = {n2}\n" \ - f"#### {n2}" + answer_cot = ( + f"{name} got {currency}{change} in change because {total} x {percent}/100 = {change}\n" + f"{name} spent {currency}{spent} because {total} - {change} = {spent}\n" + f"{name} spent {currency}{cost_item1} on {item1} because {n1} x {price1/100} = {cost_item1}\n" + f"{name} spent {spent_item2} on {item2} because {spent} - {cost_item1} = {spent_item2}\n" + f"{name} bought {n2} {item2} because {spent_item2} / {price2/100} = {n2}\n" + f"#### {n2}" + ) return { - 'question': question, - 'answer': str(n2), - 'answer_cot': answer_cot, - 'answer_value': n2, - 'variables': { - 'name': name, - 'item1': item1, - 'item2': item2, - 'price1': price1, - 'price2': price2, - 'total_spent': total, - 'num_item1': n1, - 'num_item2': n2, - 'percent_change': percent, - 'currency': currency - } + "question": question, + "answer": str(n2), + "answer_cot": answer_cot, + "answer_value": n2, + "variables": { + "name": name, + "item1": item1, + "item2": item2, + "price1": price1, + "price2": price2, + "total_spent": total, + "num_item1": n1, + "num_item2": n2, + "percent_change": percent, + "currency": currency, + }, } def generate_example(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: names = ["George", "James", "John", "Robert", "Michael", "William"] - items = ['pretzels', 'popcorn', 'gum', 'cookies', 'crackers'] - currencies = ['$', '£', '€'] + items = ["pretzels", "popcorn", "gum", "cookies", "crackers"] + currencies = ["$", "£", "€"] name = rng.choice(names) item1, item2 = rng.sample(items, 2) @@ -3340,9 +3579,11 @@ def generate_49(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: percent = int(rng.randint(1, int(10 * difficulty))) # Validate conditions - while not (isinstance(total * percent / 100, int) and - isinstance((total * (100 - percent) / 100 - n1 * price1 / 100) / (price2 / 100), int) and - (total * (100 - percent) / 100 - n1 * price1 / 100) % (price2 / 100) == 0): + while not ( + isinstance(total * percent / 100, int) + and isinstance((total * (100 - percent) / 100 - n1 * price1 / 100) / (price2 / 100), int) + and (total * (100 - percent) / 100 - n1 * price1 / 100) % (price2 / 100) == 0 + ): total = int(rng.randrange(500, int(1500 * difficulty), 100)) n1 = int(rng.randint(1, int(10 * difficulty))) percent = int(rng.randint(1, int(10 * difficulty))) @@ -3350,71 +3591,83 @@ def generate_49(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: result = generate_from_variables(name, item1, item2, price1, price2, total, n1, percent, currency) return { - 'question': result['question'], - 'answer': result['answer'], - 'metadata': { - 'difficulty': difficulty, - 'answer_value': result['answer_value'], - 'answer_cot': result['answer_cot'], - 'variables': result['variables'] - } + "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_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': str(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 - } + "question": question, + "answer": str(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'] - } + "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]: - + 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 @@ -3422,42 +3675,44 @@ def generate_51(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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}" + 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': str(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 - } + "question": question, + "answer": str(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 = ['$', '£', '€'] + 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) @@ -3467,103 +3722,112 @@ def generate_51(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + 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'] - } + "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) + 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}" + 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': str(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 - } + "question": question, + "answer": str(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)] + 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} - + frac_map = {"half": 0.5, "one-third": 1 / 3, "one-fourth": 0.25} + # Ensure division results in integer while not (alphabet[1] * frac_map[frac]).is_integer(): 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'] - } + "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]: @@ -3571,221 +3835,232 @@ def generate_53(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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: + 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'] - } + "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]: - + 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': str(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 - } + "question": question, + "answer": str(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'] - + 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) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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"] + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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"] + items = ["cupcake", "muffin", "brownie", "biscuit"] flavors = ["vanilla", "strawberry", "blueberry", "lemon", "peanut butter"] family = rng.choice(families) @@ -3803,109 +4078,113 @@ def generate_56(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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'] - } + "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]: + 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': str(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] - } + "question": question, + "answer": str(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'] + sports = ["basketball", "badminton", "table tennis", "football", "volleyball"] sport1, sport2, sport3 = rng.sample(sports, 3) - + # Generate numbers based on difficulty n1 = int(rng.randint(4, int(21 * difficulty))) n2 = int(rng.randint(10, int(31 * difficulty))) n3 = int(rng.randint(10, int(31 * difficulty))) multiplier = 2 # "twice" that number - + # Check condition while n1 * multiplier + n2 + n3 > 250: n1 = int(rng.randint(4, int(21 * difficulty))) n2 = int(rng.randint(10, int(31 * difficulty))) n3 = int(rng.randint(10, int(31 * difficulty))) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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"] + containers = ["cup", "bottle", "carton"] liquids = ["juice", "soda", "sparkling water", "tea", "lemonade"] units = ["ounce", "mL", "cc", "oz"] @@ -3913,84 +4192,88 @@ def generate_58(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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]: # Generate random values scaled by difficulty distance_per_interval = int(rng.randint(2, int(100 * difficulty))) time_per_interval = int(rng.randint(2, int(500 * difficulty))) - + # Ensure total distance is divisible by distance_per_interval num_intervals = rng.randint(2, int(20 * difficulty)) total_distance = distance_per_interval * num_intervals - + # Ensure total_distance is in valid range while total_distance > 100: num_intervals = rng.randint(2, int(20 * difficulty)) total_distance = distance_per_interval * num_intervals 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'] - } + "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]: - + 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) @@ -4001,115 +4284,129 @@ def generate_60(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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'] - + 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 - + beach_time = int(rng.randint(40, int(70 * difficulty))) beach_dist = int(rng.randint(10, int(20 * difficulty))) sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) total_dist = beach_dist + sidewalk_dist # Ensure mathematical consistency - while not (beach_dist < beach_time and - speed_mult * beach_dist < beach_time and - beach_time % beach_dist == 0): + while not (beach_dist < beach_time and speed_mult * beach_dist < beach_time and beach_time % beach_dist == 0): beach_time = int(rng.randint(40, int(70 * difficulty))) beach_dist = int(rng.randint(10, int(20 * difficulty))) sidewalk_dist = int(rng.randint(10, int(20 * difficulty))) total_dist = beach_dist + sidewalk_dist - result = generate_from_variables(name, unit, total_dist, beach_dist, - sidewalk_dist, speed_mult, beach_time) - + 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'] - } + "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]: - + 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 + 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 + 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?" + 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': str(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 - } + "question": question, + "answer": str(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 = ['$', '£', '€'] + 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] name = rng.choice(names_female) @@ -4120,7 +4417,7 @@ def generate_61(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: item3 = rng.choice(items3) unit = rng.choice(units) cur = rng.choice(currencies) - + total = int(rng.randint(1200, int(1500 * difficulty))) n1 = int(rng.randint(15, int(18 * difficulty))) n2 = int(rng.randint(4, int(10 * difficulty))) @@ -4133,101 +4430,106 @@ def generate_61(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: discount = rng.choice(fraction_nums[:4]) # Ensure conditions are met - while not (n2 < n1 and - n12 == n1 + n2 + k and - 0 <= k < n1 and - int(n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3) == n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 and - n1*p1 + n2*(1-discount)*p1 + k*p1 + p2 + n3*p3 < total): + while not ( + n2 < n1 + and n12 == n1 + n2 + k + and 0 <= k < n1 + and int(n1 * p1 + n2 * (1 - discount) * p1 + k * p1 + p2 + n3 * p3) + == n1 * p1 + n2 * (1 - discount) * p1 + k * p1 + p2 + n3 * p3 + and n1 * p1 + n2 * (1 - discount) * p1 + k * p1 + p2 + n3 * p3 < total + ): n1 = int(rng.randint(15, int(18 * difficulty))) n2 = int(rng.randint(4, int(10 * difficulty))) k = int(rng.randint(2, int(5 * difficulty))) n12 = n1 + n2 + k p1 = int(rng.randint(20, int(24 * difficulty))) - result = generate_from_variables(name, location, shop, item1, item2, item3, unit, cur, - total, n1, n2, n12, k, n3, p1, p2, p3, discount) - + 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'] - } + "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]: - + 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': str(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 - } + "question": question, + "answer": str(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) - + + 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'] - } + "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]: + 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 @@ -4236,38 +4538,52 @@ def generate_63(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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}" + 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': str(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 - } + "question": question, + "answer": str(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"] - + 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))) @@ -4280,18 +4596,19 @@ def generate_63(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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'] - } + "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]: @@ -4299,94 +4616,100 @@ def generate_64(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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}" + + 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': str(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 - } + "question": question, + "answer": str(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'] - } + "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) - + 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}" + + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -4395,138 +4718,153 @@ def generate_65(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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(): + 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'] - } + "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]: - + 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}" + 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': str(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 - } + "question": question, + "answer": str(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) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -4535,94 +4873,93 @@ def generate_67(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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'] - } + "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_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}" + + 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': str(day3_total), - 'answer_cot': answer_cot, - 'answer_value': day3_total, - 'variables': { - 'initial_infected': n0, - 'infection_rate': r, - 'days': d, - 'disease_type': disease - } + "question": question, + "answer": str(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'] - + diseases = ["virus", "bacteria", "parasite", "infection"] + disease = rng.choice(diseases) n0 = int(rng.randint(5, int(21 * difficulty))) r = int(rng.randint(2, int(8 * difficulty))) d = 3 # Fixed at 3 days per problem description - + # Check condition: n0 * (r + 1)**d < 20000 - while n0 * (r + 1)**d >= 20000: + while n0 * (r + 1) ** d >= 20000: n0 = int(rng.randint(5, int(21 * difficulty))) r = int(rng.randint(2, int(8 * difficulty))) - + 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'] - } + "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]: @@ -4631,22 +4968,22 @@ def generate_69(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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]: @@ -4657,63 +4994,67 @@ def generate_69(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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]) + 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'] - } + "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]: - + 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}" - + + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -4722,44 +5063,56 @@ def generate_70(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + n = int(rng.randrange(10, int(101 * difficulty), 2)) fake_num = int(rng.randint(2, min(10, int(n * frac)))) k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) - + # Ensure conditions are met while not (isinstance(n * frac, int) and k < n * frac and k > fake_num): n = int(rng.randrange(10, int(101 * difficulty), 2)) k = int(rng.randint(fake_num + 1, min(int(n * frac), int(20 * difficulty)))) - + 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'] - } + "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]: + 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 + cost2 = n2 * p2 cost3 = n3 * p3 total_cost = cost1 + cost2 + cost3 @@ -4768,27 +5121,27 @@ def generate_71(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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]: @@ -4809,103 +5162,116 @@ def generate_71(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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'] - } + "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]: - + 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 + + 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?" @@ -4913,33 +5279,33 @@ def generate_73(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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 = ['$', '£', '€'] + 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) @@ -4955,346 +5321,374 @@ def generate_73(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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) - + length = int(rng.randrange(10, int(500 * difficulty), 10)) num_remoras = int(rng.randint(2, int(10 * difficulty))) remora_length = int(rng.randint(2, int(100 * difficulty))) - + # Ensure conditions are met - while (num_remoras * remora_length >= length * 12 or - (num_remoras * remora_length) % 12 != 0 or - (length * 12) % (num_remoras * remora_length) != 0 or - 100 % int((num_remoras * remora_length)/(length * 12) * 100) != 0): + while ( + num_remoras * remora_length >= length * 12 + or (num_remoras * remora_length) % 12 != 0 + or (length * 12) % (num_remoras * remora_length) != 0 + or 100 % int((num_remoras * remora_length) / (length * 12) * 100) != 0 + ): length = int(rng.randrange(10, int(500 * difficulty), 10)) num_remoras = int(rng.randint(2, int(10 * difficulty))) remora_length = int(rng.randint(2, int(100 * difficulty))) 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'] - } + "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]: - + 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}" - + + 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': str(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 - } + "question": question, + "answer": str(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'] - } + "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)) + 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}" - + + 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': str(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 - } + "question": question, + "answer": str(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} - + fractions = {"a third": 1 / 3, "half": 1 / 2, "a quarter": 1 / 4, "two thirds": 2 / 3} + company = rng.choice(companies) frac = fractions[rng.choice(list(fractions.keys()))] - + # Generate values ensuring all divisions result in integers n = int(rng.randint(201, int(1001 * difficulty))) p1 = int(rng.randint(10, int(51 * difficulty))) p2 = int(rng.randint(10, int(51 * difficulty))) - + # Ensure integer results - while not (n * (p1/100)).is_integer() or \ - not (n * (p1/100) * (p2/100)).is_integer() or \ - not (n * (p1/100) * (p2/100) * frac).is_integer(): + while ( + not (n * (p1 / 100)).is_integer() + or not (n * (p1 / 100) * (p2 / 100)).is_integer() + or not (n * (p1 / 100) * (p2 / 100) * frac).is_integer() + ): n = int(rng.randint(201, int(1001 * difficulty))) p1 = int(rng.randint(10, int(51 * difficulty))) p2 = int(rng.randint(10, int(51 * difficulty))) - + 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'] - } + "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]: + 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}" + + 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': str(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 - } + "question": question, + "answer": str(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'] + events = ["party", "meeting", "conference", "gathering", "celebration"] groups = ["teachers", "doctors", "engineers", "nurses", "artists", "lawyers"] - times = ['an hour', 'two hours', 'half an hour', '45 minutes'] + 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) - + m = int(rng.randint(20, int(75 * difficulty))) w = int(rng.randint(10, int(80 * difficulty))) total = m + w - + # Ensure fraction calculations result in integers while not (total * frac).is_integer(): m = int(rng.randint(20, int(75 * difficulty))) w = int(rng.randint(10, int(80 * difficulty))) total = m + w - + stayed = total - int(total * frac) - m_left = int(rng.randint(15, min(stayed-1, int(35 * difficulty)))) - + m_left = int(rng.randint(15, min(stayed - 1, int(35 * difficulty)))) + 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'] - } + "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}" + + 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': str(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 - } + "question": question, + "answer": str(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) - + age_diff = int(rng.randint(5, int(30 * difficulty))) age1 = int(rng.randint(15, int(75 * difficulty))) - + # Ensure average is an integer while (2 * age1 + age_diff) % 2 != 0: 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'] - } + "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]: + 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 @@ -5304,33 +5698,35 @@ def generate_79(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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}" + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -5341,7 +5737,7 @@ def generate_79(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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))) @@ -5349,368 +5745,386 @@ def generate_79(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: multiplier = 2 # Verify conditions - while not ((end_time - start_time > free_hours + 1) and - ((end_time - start_time - free_hours - 1) * first_hour_cost * multiplier).is_integer()): + while not ( + (end_time - start_time > free_hours + 1) + and ((end_time - start_time - free_hours - 1) * first_hour_cost * multiplier).is_integer() + ): 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) - + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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) - + + 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'] - } + "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]: + 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}" + + 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': str(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 - } + "question": question, + "answer": str(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): + 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'] - } + "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 - + 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': str(amount1), - 'answer_cot': answer_cot, - 'answer_value': amount1, - 'variables': { - 'name1': name1, - 'name2': name2, - 'total_fence': total, - 'difference': diff, - 'unit': unit, - 'amount1': amount1, - 'amount2': amount2 - } + "question": question, + "answer": str(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'] - + names = ["Sam", "Harry", "Tom", "John", "Mike", "Dave", "Steve", "Bob"] + units = ["feet", "yards", "meters"] + name1, name2 = rng.sample(names, 2) unit = rng.choice(units) - + # Scale ranges by difficulty while maintaining integer division diff = int(rng.randrange(20, int(200 * difficulty), 10)) total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) - + # Ensure conditions are met while total - diff <= 10 or (total - diff) % 2 != 0: diff = int(rng.randrange(20, int(200 * difficulty), 10)) total = int(rng.randrange(diff + 20, int(1000 * difficulty), 20)) - + 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'] - } + "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]: + 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}" + + 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': str(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 - } + "question": question, + "answer": str(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) - + time_cold = int(rng.randint(10, int(50 * difficulty))) extra_time = int(rng.randint(1, int(10 * difficulty))) multiplier = 2.0 # "twice" specified in original distance = int(rng.randint(2, int(10 * difficulty))) - + # Check conditions - while time_cold >= 60 or \ - extra_time + multiplier * time_cold >= 60 or \ - distance * (extra_time + multiplier * time_cold) - distance * time_cold <= 0: + while ( + time_cold >= 60 + or extra_time + multiplier * time_cold >= 60 + or distance * (extra_time + multiplier * time_cold) - distance * time_cold <= 0 + ): time_cold = int(rng.randint(10, int(50 * difficulty))) extra_time = int(rng.randint(1, int(10 * difficulty))) distance = int(rng.randint(2, int(10 * difficulty))) - + 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'] - } + "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 + 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}" + + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -5722,38 +6136,52 @@ def generate_85(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: room_type = rng.choice(room_types) unit1 = rng.choice(units) unit2 = "yards" if unit1 == "feet" else "meters" - + length = int(rng.randint(5, int(44 * difficulty))) - + # Ensure width is larger than length and area calculation results in integer - conversion = 3 if unit1 == 'feet' and unit2 == 'yards' else 1 + conversion = 3 if unit1 == "feet" and unit2 == "yards" else 1 width = int(rng.randint(length * conversion + 1, int(100 * difficulty))) 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'] - } + "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]: + 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 + carrot_weight = n3 * w3 hay_weight = n1 * w1 oat_weight = n2 * w2 total_weight = sugar_weight + carrot_weight + hay_weight + oat_weight @@ -5764,204 +6192,226 @@ def generate_86(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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']) + 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): + 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 + 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) - + + 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'] - } + "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]: - + 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)}" + + 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': str(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 - } + "question": question, + "answer": str(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) - + 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'] - } + "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': str(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 - } + "question": question, + "answer": str(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'] - } + "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]: + 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_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 @@ -5977,49 +6427,63 @@ def generate_89(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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"] - + 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()): + 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))) @@ -6029,158 +6493,174 @@ def generate_89(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + 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'] - } + "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]: + 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': str(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) - } + "question": question, + "answer": str(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 = ['$', '£', '€'] - + devices = ["payphone", "phone booth", "hotel room phone"] + currencies = ["$", "£", "€"] + device = rng.choice(devices) currency = rng.choice(currencies) - + # Generate rates ensuring rate2 < rate1 rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) rate2 = round(rng.uniform(0.1, rate1), 2) - + threshold = int(rng.randint(10, int(50 * difficulty))) total_mins = int(rng.randint(threshold + 10, int(100 * difficulty))) - + # Ensure calculations result in integers while not (threshold * rate1).is_integer() or not ((total_mins - threshold) * rate2).is_integer(): rate1 = round(rng.uniform(0.2, 0.5 * difficulty), 2) rate2 = round(rng.uniform(0.1, rate1), 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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"] + 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'] - } + "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]: - + 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_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?" @@ -6194,30 +6674,30 @@ def generate_92(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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 = ['$', '£', '€'] + 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) @@ -6235,32 +6715,45 @@ def generate_92(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) + 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'] - } + "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]: - + 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_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?" @@ -6268,29 +6761,29 @@ def generate_93(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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': str(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 - } + "question": question, + "answer": str(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]: @@ -6311,131 +6804,141 @@ def generate_93(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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(): + 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) + 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'] - } + "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]: + 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 + 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)}" + + 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': str(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) - } + "question": question, + "answer": str(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'] + 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(): + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -6443,39 +6946,40 @@ def generate_95(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + 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'] - } + "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]: + 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 @@ -6483,30 +6987,32 @@ def generate_96(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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}" + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -6522,9 +7028,9 @@ def generate_96(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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: + while 2 * n1 - n2 <= 0: n1 = int(rng.randint(3, int(15 * difficulty))) n2 = int(rng.randint(1, int(10 * difficulty))) @@ -6534,22 +7040,24 @@ def generate_96(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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'] - } + "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]: + 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 @@ -6570,166 +7078,186 @@ def generate_97(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: #### {total_dist}""" return { - 'question': question, - 'answer': str(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 - } + "question": question, + "answer": str(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) - + mult_run = rng.randint(2, int(6 * difficulty)) - frac_skip = 0.5 # Keep simple fraction + frac_skip = 0.5 # Keep simple fraction skip_speed = rng.randint(2, int(10 * difficulty)) total_time = rng.randrange(4, int(12 * difficulty), 2) - + # Ensure fractions add to 1 - frac_run = 1/3 # Keep simple fraction - frac_walk = 2/3 # Keep simple fraction + frac_run = 1 / 3 # Keep simple fraction + frac_walk = 2 / 3 # Keep simple fraction # Validate conditions - while not (skip_speed / frac_skip < 13 and - (total_time * frac_walk * (skip_speed / frac_skip / mult_run)).is_integer() and - (skip_speed / frac_skip).is_integer() and - (total_time * frac_run).is_integer() and - (total_time * frac_walk).is_integer()): + while not ( + skip_speed / frac_skip < 13 + and (total_time * frac_walk * (skip_speed / frac_skip / mult_run)).is_integer() + and (skip_speed / frac_skip).is_integer() + and (total_time * frac_run).is_integer() + and (total_time * frac_walk).is_integer() + ): skip_speed = rng.randint(2, int(10 * difficulty)) total_time = rng.randrange(4, int(12 * difficulty), 2) - result = generate_from_variables(name, mult_run, frac_skip, skip_speed, - total_time, frac_run, frac_walk) + 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'] - } + "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]: - + 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': str(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 - } + "question": question, + "answer": str(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'] - + 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) - + weight_vehicle = int(rng.randrange(1000, int(3000 * difficulty), 50)) weight_item = int(rng.randrange(100, int(500 * difficulty), 25)) weight_passenger = int(rng.randrange(50, int(100 * difficulty), 5)) num_passengers = int(rng.randint(2, int(5 * difficulty))) force_percent = int(rng.randint(1, int(6 * difficulty))) - + # Ensure force calculation results in integer total_weight = weight_vehicle + weight_item + (num_passengers * weight_passenger) while (total_weight * force_percent) % 100 != 0: force_percent = int(rng.randint(1, int(6 * difficulty))) - - result = generate_from_variables(name, vehicle, weight_vehicle, item, weight_item, - passenger_type, num_passengers, weight_passenger, - unit, force_percent) - + + 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'] - } + "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]: + 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': str(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 - } + "question": question, + "answer": str(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]: @@ -6737,33 +7265,32 @@ def generate_99(rng: Random, difficulty: float = 1.0) -> Dict[str, Any]: 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) - + + 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'] - } + "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) diff --git a/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py b/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py index 904af8c9..95f38bda 100644 --- a/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py +++ b/reasoning_gym/arithmetic/gsm_symbolic/gsm_symbolic_datasets.py @@ -1,15 +1,18 @@ """GSM Symblic dataset generator""" -from . import generators from dataclasses import dataclass from random import Random from typing import List, Optional from reasoning_gym.factory import ProceduralDataset, register_dataset +from . import generators + + @dataclass class GSMSymbolicDatasetConfig: """Configuration for GSM symbolic task generation""" + seed: Optional[int] = None size: int = 500 @@ -17,9 +20,10 @@ class GSMSymbolicDatasetConfig: """Validate configuration parameters""" pass + class GSMSymbolicDataset(ProceduralDataset): - def __init__(self, config, seed = None, size = 500): + def __init__(self, config, seed=None, size=500): super().__init__(config, seed, size) # Initialize as None self._generators = None @@ -35,13 +39,11 @@ class GSMSymbolicDataset(ProceduralDataset): """ Generates mapper from task identifiers (keys) to example generator functions """ - prefix = 'generate_' - return { - self.strip_prefix(n, prefix): getattr(generators, n) for n in dir(generators) if n.startswith(prefix) - } + prefix = "generate_" + return {self.strip_prefix(n, prefix): getattr(generators, n) for n in dir(generators) if n.startswith(prefix)} def strip_prefix(self, s, prefix): - return s[len(prefix):] + return s[len(prefix) :] def __getitem__(self, idx) -> dict: """Generate a single GSM symbolic dataset""" @@ -49,8 +51,9 @@ class GSMSymbolicDataset(ProceduralDataset): # Stringify the random integer generated from the random number generator generator_idx = str(rng.randint(0, len(self.generators) - 1)) generator = self.generators[generator_idx] - # Here the res is a dictionary of + # Here the res is a dictionary of res = generator(rng) return res - -register_dataset("gsm_symbolic", GSMSymbolicDataset, GSMSymbolicDatasetConfig) \ No newline at end of file + + +register_dataset("gsm_symbolic", GSMSymbolicDataset, GSMSymbolicDatasetConfig)