337 lines
13 KiB
TypeScript
337 lines
13 KiB
TypeScript
import type { MathProblem, Difficulty } from "../types";
|
||
import { randomInt, randomChoice } from "@/lib/utils";
|
||
import { Fraction, lcm } from "@/lib/math/fractions";
|
||
|
||
let counter = 0;
|
||
function nextId() {
|
||
return `fp-${++counter}-${Date.now()}`;
|
||
}
|
||
|
||
export function generateFractionAddSubtract(difficulty: Difficulty): MathProblem {
|
||
const operation = randomChoice(["add", "subtract"] as const);
|
||
const op = operation === "add" ? "+" : "-";
|
||
|
||
let n1: number, d1: number, n2: number, d2: number;
|
||
|
||
if (difficulty === 1) {
|
||
// Common denominators
|
||
d1 = randomChoice([2, 3, 4, 5, 6, 8, 10, 12]);
|
||
d2 = d1;
|
||
n1 = randomInt(1, d1 - 1);
|
||
n2 = operation === "subtract" ? randomInt(1, n1) : randomInt(1, d1 - n1);
|
||
} else if (difficulty === 2) {
|
||
// One denominator is a multiple of the other
|
||
d1 = randomChoice([2, 3, 4, 5, 6]);
|
||
const multiplier = randomChoice([2, 3]);
|
||
d2 = d1 * multiplier;
|
||
n1 = randomInt(1, d1 - 1);
|
||
n2 = randomInt(1, d2 - 1);
|
||
} else {
|
||
// Unlike denominators
|
||
d1 = randomChoice([3, 4, 5, 7, 8, 9]);
|
||
d2 = randomChoice([3, 4, 5, 7, 8, 9].filter((d) => d !== d1));
|
||
n1 = randomInt(1, d1 - 1);
|
||
n2 = randomInt(1, d2 - 1);
|
||
}
|
||
|
||
const prompt = `\\frac{${n1}}{${d1}} ${op} \\frac{${n2}}{${d2}}`;
|
||
const commonDen = lcm(d1, d2);
|
||
const convertedN1 = n1 * (commonDen / d1);
|
||
const convertedN2 = n2 * (commonDen / d2);
|
||
const rawNum = operation === "add"
|
||
? convertedN1 + convertedN2
|
||
: convertedN1 - convertedN2;
|
||
const { n: ansNum, d: ansDen } = new Fraction(rawNum, commonDen).simplified();
|
||
|
||
const steps = d1 === d2
|
||
? [
|
||
{
|
||
explanation: `The denominators already match, so keep ${d1} as the denominator.`,
|
||
math: `\\frac{${n1}}{${d1}} ${op} \\frac{${n2}}{${d2}}`,
|
||
},
|
||
{
|
||
explanation: `${operation === "add" ? "Add" : "Subtract"} the numerators and keep the denominator the same.`,
|
||
math: `\\frac{${n1}}{${d1}} ${op} \\frac{${n2}}{${d2}} = \\frac{${rawNum}}{${d1}}`,
|
||
},
|
||
...(ansNum !== rawNum || ansDen !== d1
|
||
? [{
|
||
explanation: "Simplify the fraction.",
|
||
math: `\\frac{${rawNum}}{${d1}} = \\frac{${ansNum}}{${ansDen}}`,
|
||
}]
|
||
: []),
|
||
]
|
||
: [
|
||
{
|
||
explanation: `Find the lowest common denominator: LCM(${d1}, ${d2}) = ${commonDen}.`,
|
||
math: `\\text{LCD} = ${commonDen}`,
|
||
},
|
||
{
|
||
explanation: "Rewrite both fractions with that denominator.",
|
||
math: `\\frac{${n1}}{${d1}} = \\frac{${convertedN1}}{${commonDen}} \\quad \\frac{${n2}}{${d2}} = \\frac{${convertedN2}}{${commonDen}}`,
|
||
},
|
||
{
|
||
explanation: `${operation === "add" ? "Add" : "Subtract"} the numerators and keep the common denominator.`,
|
||
math: `\\frac{${convertedN1}}{${commonDen}} ${op} \\frac{${convertedN2}}{${commonDen}} = \\frac{${rawNum}}{${commonDen}}`,
|
||
},
|
||
...(ansNum !== rawNum || ansDen !== commonDen
|
||
? [{
|
||
explanation: "Simplify the fraction.",
|
||
math: `\\frac{${rawNum}}{${commonDen}} = \\frac{${ansNum}}{${ansDen}}`,
|
||
}]
|
||
: []),
|
||
];
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt,
|
||
answer: { kind: "fraction", numerator: ansNum, denominator: ansDen },
|
||
hints: [
|
||
d1 === d2 ? "The denominators are already the same!" : "Find a common denominator first",
|
||
d1 !== d2 ? "Rewrite both fractions using that denominator" : `Just ${operation} the numerators`,
|
||
],
|
||
steps,
|
||
};
|
||
}
|
||
|
||
export function generateFractionMultiply(difficulty: Difficulty): MathProblem {
|
||
const denChoices = difficulty === 1 ? [2, 3, 4, 5] : difficulty === 2 ? [2, 3, 4, 5, 6, 7, 8] : [3, 5, 7, 9, 11, 12, 15];
|
||
const d1 = randomChoice(denChoices);
|
||
const d2 = randomChoice(denChoices);
|
||
const n1 = randomInt(1, d1 - 1);
|
||
const n2 = randomInt(1, d2 - 1);
|
||
|
||
const { n: ansNum, d: ansDen } = Fraction.of(n1, d1).times(Fraction.of(n2, d2)).simplified();
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `\\frac{${n1}}{${d1}} \\times \\frac{${n2}}{${d2}}`,
|
||
answer: { kind: "fraction", numerator: ansNum, denominator: ansDen },
|
||
hints: [
|
||
"Multiply numerator × numerator",
|
||
"Multiply denominator × denominator",
|
||
"Simplify if possible",
|
||
],
|
||
steps: [
|
||
{ explanation: `Multiply numerators: ${n1} × ${n2} = ${n1 * n2}` },
|
||
{ explanation: `Multiply denominators: ${d1} × ${d2} = ${d1 * d2}` },
|
||
{ explanation: "Simplify", math: `\\frac{${ansNum}}{${ansDen}}` },
|
||
],
|
||
};
|
||
}
|
||
|
||
export function generateFractionDivide(difficulty: Difficulty): MathProblem {
|
||
const denChoices = difficulty === 1 ? [2, 3, 4, 5] : difficulty === 2 ? [2, 3, 4, 5, 6, 7, 8] : [3, 5, 7, 9, 11, 14, 15];
|
||
const d1 = randomChoice(denChoices);
|
||
const d2 = randomChoice(denChoices);
|
||
const n1 = randomInt(1, d1 - 1);
|
||
const n2 = randomInt(1, d2 - 1);
|
||
|
||
const { n: ansNum, d: ansDen } = Fraction.of(n1, d1).dividedBy(Fraction.of(n2, d2)).simplified();
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `\\frac{${n1}}{${d1}} \\div \\frac{${n2}}{${d2}}`,
|
||
answer: { kind: "fraction", numerator: ansNum, denominator: ansDen },
|
||
hints: [
|
||
"Keep the first fraction the same",
|
||
"Flip the second fraction (reciprocal)",
|
||
"Then multiply",
|
||
],
|
||
steps: [
|
||
{ explanation: `Keep ${n1}/${d1}, flip ${n2}/${d2} to ${d2}/${n2}` },
|
||
{ explanation: `Multiply: ${n1}×${d2} / ${d1}×${n2}` },
|
||
{ explanation: "Simplify", math: `\\frac{${ansNum}}{${ansDen}}` },
|
||
],
|
||
};
|
||
}
|
||
|
||
export function generateFractionOfQuantity(difficulty: Difficulty): MathProblem {
|
||
const denChoices = difficulty === 1 ? [2, 4, 5, 10] : difficulty === 2 ? [3, 4, 5, 6, 8] : [7, 8, 9, 12, 15];
|
||
const den = randomChoice(denChoices);
|
||
const num = randomInt(1, den - 1);
|
||
const multiplier = randomChoice(difficulty === 1 ? [2, 4, 5, 10] : [3, 6, 7, 8, 9, 12]);
|
||
const quantity = den * multiplier;
|
||
const answer = num * multiplier;
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `\\frac{${num}}{${den}} \\text{ of } ${quantity}`,
|
||
answer: { kind: "integer", value: answer },
|
||
hints: [
|
||
`Divide ${quantity} by ${den} first`,
|
||
`Then multiply by ${num}`,
|
||
],
|
||
steps: [
|
||
{ explanation: `Divide the quantity by the denominator: ${quantity} ÷ ${den} = ${quantity / den}` },
|
||
{ explanation: `Multiply by the numerator: ${quantity / den} × ${num} = ${answer}` },
|
||
],
|
||
};
|
||
}
|
||
|
||
/** A proper-fraction numerator with a random sign, magnitude 1..den-1. */
|
||
function signedProperNum(den: number): number {
|
||
const mag = randomInt(1, Math.max(1, den - 1));
|
||
return Math.random() < 0.5 ? -mag : mag;
|
||
}
|
||
|
||
/** Two proper fractions where at least one is negative (this is the negative-fractions topic). */
|
||
function signedFractionPair(d1: number, d2: number): [Fraction, Fraction] {
|
||
let n1 = signedProperNum(d1);
|
||
let n2 = signedProperNum(d2);
|
||
if (n1 > 0 && n2 > 0) {
|
||
if (Math.random() < 0.5) n1 = -n1;
|
||
else n2 = -n2;
|
||
}
|
||
return [new Fraction(n1, d1), new Fraction(n2, d2)];
|
||
}
|
||
|
||
function signedOperand(f: Fraction): string {
|
||
return f.n < 0 ? `\\left(${f.toSignedKatex()}\\right)` : f.toSignedKatex();
|
||
}
|
||
|
||
export function generateSignedFractionAddSubtract(difficulty: Difficulty): MathProblem {
|
||
const operation = randomChoice(["+", "-"] as const);
|
||
const dens = difficulty === 1 ? [2, 3, 4] : difficulty === 2 ? [2, 3, 4, 5, 6] : [3, 4, 5, 6, 8];
|
||
const d1 = randomChoice(dens);
|
||
const d2 = randomChoice(dens);
|
||
const [a, b] = signedFractionPair(d1, d2);
|
||
const result = (operation === "+" ? a.plus(b) : a.minus(b)).simplified();
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `${a.toSignedKatex()} ${operation} ${signedOperand(b)}`,
|
||
answer: { kind: "fraction", numerator: result.n, denominator: result.d },
|
||
hints: [
|
||
d1 === d2 ? "The denominators already match." : "Find a common denominator first.",
|
||
"Combine the numerators using the integer sign rules (subtracting a negative adds).",
|
||
"Simplify your answer.",
|
||
],
|
||
steps: [
|
||
{
|
||
explanation: d1 === d2 ? `Keep the denominator ${d1}.` : `Use a common denominator: LCM(${d1}, ${d2}) = ${lcm(d1, d2)}.`,
|
||
},
|
||
{ explanation: `${operation === "+" ? "Add" : "Subtract"} the numerators, watching the signs.` },
|
||
{ explanation: "Simplify to lowest terms.", math: result.toSignedKatex() },
|
||
],
|
||
};
|
||
}
|
||
|
||
export function generateSignedFractionMultiplyDivide(difficulty: Difficulty): MathProblem {
|
||
const operation = randomChoice(["\\times", "\\div"] as const);
|
||
const dens = difficulty === 1 ? [2, 3, 4] : difficulty === 2 ? [2, 3, 4, 5] : [3, 4, 5, 6, 7];
|
||
const d1 = randomChoice(dens);
|
||
const d2 = randomChoice(dens);
|
||
const [a, b] = signedFractionPair(d1, d2);
|
||
const result = (operation === "\\times" ? a.times(b) : a.dividedBy(b)).simplified();
|
||
const sameSign = a.n < 0 === b.n < 0;
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `${a.toSignedKatex()} ${operation} ${signedOperand(b)}`,
|
||
answer: { kind: "fraction", numerator: result.n, denominator: result.d },
|
||
hints: [
|
||
operation === "\\div" ? "Keep, change, flip: multiply by the reciprocal." : "Multiply numerators and denominators.",
|
||
`The signs are ${sameSign ? "the same, so the answer is positive" : "different, so the answer is negative"}.`,
|
||
"Simplify your answer.",
|
||
],
|
||
steps: [
|
||
operation === "\\div"
|
||
? { explanation: "Multiply by the reciprocal of the second fraction (keep, change, flip)." }
|
||
: { explanation: "Multiply the numerators and multiply the denominators." },
|
||
{ explanation: `Same signs give positive, different signs give negative — here the answer is ${result.n < 0 ? "negative" : "positive"}.` },
|
||
{ explanation: "Simplify to lowest terms.", math: result.toSignedKatex() },
|
||
],
|
||
};
|
||
}
|
||
|
||
export function generateFractionBodmas(difficulty: Difficulty): MathProblem {
|
||
const dens = difficulty === 1 ? [2, 3, 4] : difficulty === 2 ? [2, 3, 4, 5] : [2, 3, 4, 5, 6];
|
||
const mk = () => {
|
||
const d = randomChoice(dens);
|
||
return new Fraction(randomInt(1, d - 1), d);
|
||
};
|
||
const f1 = mk(), f2 = mk(), f3 = mk();
|
||
const multFirst = Math.random() < 0.5;
|
||
|
||
let prompt: string;
|
||
let result: Fraction;
|
||
if (multFirst) {
|
||
const prod = f2.times(f3);
|
||
// avoid a negative answer in this (positive-fractions) unit
|
||
const op = f1.toDecimal() >= prod.toDecimal() && Math.random() < 0.5 ? "-" : "+";
|
||
result = (op === "+" ? f1.plus(prod) : f1.minus(prod)).simplified();
|
||
prompt = `${f1.toKatex()} ${op} ${f2.toKatex()} \\times ${f3.toKatex()}`;
|
||
} else {
|
||
const prod = f1.times(f2);
|
||
const op = prod.toDecimal() >= f3.toDecimal() && Math.random() < 0.5 ? "-" : "+";
|
||
result = (op === "+" ? prod.plus(f3) : prod.minus(f3)).simplified();
|
||
prompt = `${f1.toKatex()} \\times ${f2.toKatex()} ${op} ${f3.toKatex()}`;
|
||
}
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt,
|
||
answer: { kind: "fraction", numerator: result.n, denominator: result.d },
|
||
hints: [
|
||
"BODMAS: do the multiplication before the addition or subtraction.",
|
||
"Multiply the two fractions first, then combine with a common denominator.",
|
||
],
|
||
steps: [
|
||
{ explanation: "Multiply first (that's the B-O-D-M before A-S)." },
|
||
{ explanation: "Then add or subtract, using a common denominator." },
|
||
{ explanation: "Simplify.", math: result.toKatex() },
|
||
],
|
||
};
|
||
}
|
||
|
||
/** Combined signed-fraction practice covering +, -, x and / (Unit 5 topic). */
|
||
export function generateSignedFraction(difficulty: Difficulty): MathProblem {
|
||
const operation = randomChoice(["+", "-", "\\times", "\\div"] as const);
|
||
const dens = difficulty === 1 ? [2, 3, 4] : difficulty === 2 ? [2, 3, 4, 5] : [3, 4, 5, 6];
|
||
const [a, b] = signedFractionPair(randomChoice(dens), randomChoice(dens));
|
||
|
||
let result: Fraction;
|
||
if (operation === "+") result = a.plus(b);
|
||
else if (operation === "-") result = a.minus(b);
|
||
else if (operation === "\\times") result = a.times(b);
|
||
else result = a.dividedBy(b);
|
||
result = result.simplified();
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `${a.toSignedKatex()} ${operation} ${signedOperand(b)}`,
|
||
answer: { kind: "fraction", numerator: result.n, denominator: result.d },
|
||
hints: [
|
||
"Apply the integer sign rules as you work.",
|
||
"Give your answer in its simplest form.",
|
||
],
|
||
steps: [
|
||
{ explanation: "Work through the operation, watching the signs." },
|
||
{ explanation: "Simplify.", math: result.toSignedKatex() },
|
||
],
|
||
};
|
||
}
|
||
|
||
export function generateWholeFromFraction(difficulty: Difficulty): MathProblem {
|
||
const denChoices = difficulty === 1 ? [2, 3, 4, 5] : difficulty === 2 ? [3, 5, 6, 8] : [7, 8, 9, 12];
|
||
const den = randomChoice(denChoices);
|
||
const num = randomInt(1, den - 1);
|
||
const whole = den * randomChoice(difficulty === 1 ? [2, 3, 4, 5] : [3, 5, 6, 7, 8, 10]);
|
||
const part = (num / den) * whole;
|
||
|
||
return {
|
||
id: nextId(),
|
||
prompt: `\\frac{${num}}{${den}} \\text{ of a number is } ${part}\\text{. Find the number.}`,
|
||
answer: { kind: "integer", value: whole },
|
||
hints: [
|
||
`If ${num}/${den} of the number is ${part}...`,
|
||
`Find 1/${den} first by dividing ${part} by ${num}`,
|
||
`Then multiply by ${den} to get the whole`,
|
||
],
|
||
steps: [
|
||
{ explanation: `1/${den} of the number = ${part} ÷ ${num} = ${part / num}` },
|
||
{ explanation: `The whole number = ${part / num} × ${den} = ${whole}` },
|
||
],
|
||
};
|
||
}
|