feat(worksheets): add operator selection and subtraction problem generation
Phase 1: Operator Selection UI
- Added WorksheetOperator type ('addition' | 'subtraction' | 'mixed')
- Added operator field to V4 config schema with default 'addition'
- Added operator selector UI in ConfigPanel with 3 buttons
- Unified problem types (AdditionProblem, SubtractionProblem, WorksheetProblem)
Phase 2: Subtraction Problem Generation
- Implemented generateNonBorrow() - no borrowing in any place
- Implemented generateOnesOnlyBorrow() - borrow in ones place only
- Implemented generateBothBorrow() - multiple borrows
- Implemented generateSubtractionProblems() - main generation with digit ranges
- Implemented generateMixedProblems() - 50/50 addition/subtraction mix
- All functions ensure minuend ≥ subtrahend (no negative results)
- Borrow detection works across all place values (1-5 digits)
Next phases will add:
- Subtraction problem analysis
- Typst rendering for subtraction (borrow boxes, etc.)
- Display rules and smart mode support
- Auto-save persistence
- Preview/example routes
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Thomas Hallock
parent
3a45340caf
commit
ab87c6ebe7
|
|
@ -550,6 +550,127 @@ export function ConfigPanel({ formState, onChange }: ConfigPanelProps) {
|
|||
</div>
|
||||
</div>
|
||||
|
||||
{/* Operator Selector */}
|
||||
<div
|
||||
data-section="operator-selection"
|
||||
className={css({
|
||||
bg: 'gray.50',
|
||||
border: '1px solid',
|
||||
borderColor: 'gray.200',
|
||||
rounded: 'xl',
|
||||
p: '4',
|
||||
})}
|
||||
>
|
||||
<label
|
||||
className={css({
|
||||
fontSize: 'sm',
|
||||
fontWeight: 'semibold',
|
||||
color: 'gray.700',
|
||||
mb: '2',
|
||||
display: 'block',
|
||||
})}
|
||||
>
|
||||
Operation Type
|
||||
</label>
|
||||
|
||||
<div className={css({ display: 'flex', gap: '2', mb: '2' })}>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onChange({ operator: 'addition' })}
|
||||
className={css({
|
||||
flex: 1,
|
||||
px: '4',
|
||||
py: '2',
|
||||
rounded: 'lg',
|
||||
fontSize: 'sm',
|
||||
fontWeight: 'medium',
|
||||
border: '2px solid',
|
||||
transition: 'all 0.2s',
|
||||
...(formState.operator === 'addition' || !formState.operator
|
||||
? {
|
||||
bg: 'brand.600',
|
||||
borderColor: 'brand.600',
|
||||
color: 'white',
|
||||
}
|
||||
: {
|
||||
bg: 'white',
|
||||
borderColor: 'gray.300',
|
||||
color: 'gray.700',
|
||||
_hover: { borderColor: 'gray.400' },
|
||||
}),
|
||||
})}
|
||||
>
|
||||
Addition Only (+)
|
||||
</button>
|
||||
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onChange({ operator: 'subtraction' })}
|
||||
className={css({
|
||||
flex: 1,
|
||||
px: '4',
|
||||
py: '2',
|
||||
rounded: 'lg',
|
||||
fontSize: 'sm',
|
||||
fontWeight: 'medium',
|
||||
border: '2px solid',
|
||||
transition: 'all 0.2s',
|
||||
...(formState.operator === 'subtraction'
|
||||
? {
|
||||
bg: 'brand.600',
|
||||
borderColor: 'brand.600',
|
||||
color: 'white',
|
||||
}
|
||||
: {
|
||||
bg: 'white',
|
||||
borderColor: 'gray.300',
|
||||
color: 'gray.700',
|
||||
_hover: { borderColor: 'gray.400' },
|
||||
}),
|
||||
})}
|
||||
>
|
||||
Subtraction Only (−)
|
||||
</button>
|
||||
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onChange({ operator: 'mixed' })}
|
||||
className={css({
|
||||
flex: 1,
|
||||
px: '4',
|
||||
py: '2',
|
||||
rounded: 'lg',
|
||||
fontSize: 'sm',
|
||||
fontWeight: 'medium',
|
||||
border: '2px solid',
|
||||
transition: 'all 0.2s',
|
||||
...(formState.operator === 'mixed'
|
||||
? {
|
||||
bg: 'brand.600',
|
||||
borderColor: 'brand.600',
|
||||
color: 'white',
|
||||
}
|
||||
: {
|
||||
bg: 'white',
|
||||
borderColor: 'gray.300',
|
||||
color: 'gray.700',
|
||||
_hover: { borderColor: 'gray.400' },
|
||||
}),
|
||||
})}
|
||||
>
|
||||
Mixed (+/−)
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<p className={css({ fontSize: 'xs', color: 'gray.600' })}>
|
||||
{formState.operator === 'mixed'
|
||||
? 'Problems will randomly use addition or subtraction'
|
||||
: formState.operator === 'subtraction'
|
||||
? 'All problems will be subtraction'
|
||||
: 'All problems will be addition'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{/* Mode Selector */}
|
||||
<ModeSelector currentMode={formState.mode ?? 'smart'} onChange={handleModeChange} />
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,11 @@
|
|||
// Problem generation logic for double-digit addition worksheets
|
||||
// Problem generation logic for addition worksheets (supports 1-5 digit problems)
|
||||
|
||||
import type { AdditionProblem, ProblemCategory } from './types'
|
||||
import type {
|
||||
AdditionProblem,
|
||||
SubtractionProblem,
|
||||
WorksheetProblem,
|
||||
ProblemCategory,
|
||||
} from './types'
|
||||
|
||||
/**
|
||||
* Mulberry32 PRNG for reproducible random number generation
|
||||
|
|
@ -30,75 +35,178 @@ function randint(min: number, max: number, rand: () => number): number {
|
|||
}
|
||||
|
||||
/**
|
||||
* Generate a random number with the specified number of digits
|
||||
* For n digits, generates numbers in range [10^(n-1), 10^n - 1]
|
||||
* Examples:
|
||||
* - 1 digit: 0-9
|
||||
* - 2 digits: 10-99
|
||||
* - 3 digits: 100-999
|
||||
* - 5 digits: 10000-99999
|
||||
*/
|
||||
export function generateNumber(digits: number, rand: () => number): number {
|
||||
if (digits < 1 || digits > 5) {
|
||||
throw new Error(`Invalid digit count: ${digits}. Must be 1-5.`)
|
||||
}
|
||||
|
||||
// For 1 digit, range is 0-9 (allow 0 as first digit)
|
||||
if (digits === 1) {
|
||||
return randint(0, 9, rand)
|
||||
}
|
||||
|
||||
// For 2+ digits, range is [10^(n-1), 10^n - 1]
|
||||
const min = 10 ** (digits - 1)
|
||||
const max = 10 ** digits - 1
|
||||
return randint(min, max, rand)
|
||||
}
|
||||
|
||||
/**
|
||||
* DEPRECATED: Use generateNumber(2, rand) instead
|
||||
* Generate a random two-digit number (10-99)
|
||||
*/
|
||||
function twoDigit(rand: () => number): number {
|
||||
const tens = randint(1, 9, rand)
|
||||
const ones = randint(0, 9, rand)
|
||||
return tens * 10 + ones
|
||||
return generateNumber(2, rand)
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract digit at position from a number
|
||||
* position 0 = ones, 1 = tens, 2 = hundreds, etc.
|
||||
*/
|
||||
function getDigit(num: number, position: number): number {
|
||||
return Math.floor((num % 10 ** (position + 1)) / 10 ** position)
|
||||
}
|
||||
|
||||
/**
|
||||
* Count number of digits in a number (1-5)
|
||||
*/
|
||||
function countDigits(num: number): number {
|
||||
if (num === 0) return 1
|
||||
return Math.floor(Math.log10(Math.abs(num))) + 1
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a problem with NO regrouping
|
||||
* (ones sum < 10 AND tens sum < 10)
|
||||
* No carries in any place value
|
||||
*
|
||||
* @param minDigits Minimum number of digits per addend
|
||||
* @param maxDigits Maximum number of digits per addend
|
||||
*/
|
||||
export function generateNonRegroup(rand: () => number): [number, number] {
|
||||
export function generateNonRegroup(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const a = twoDigit(rand)
|
||||
const b = twoDigit(rand)
|
||||
const aT = Math.floor((a % 100) / 10)
|
||||
const aO = a % 10
|
||||
const bT = Math.floor((b % 100) / 10)
|
||||
const bO = b % 10
|
||||
const digitsA = randint(minDigits, maxDigits, rand)
|
||||
const digitsB = randint(minDigits, maxDigits, rand)
|
||||
const a = generateNumber(digitsA, rand)
|
||||
const b = generateNumber(digitsB, rand)
|
||||
|
||||
if (aO + bO < 10 && aT + bT < 10) {
|
||||
// Check all place values for carries
|
||||
const maxPlaces = Math.max(countDigits(a), countDigits(b))
|
||||
let hasCarry = false
|
||||
for (let pos = 0; pos < maxPlaces; pos++) {
|
||||
const digitA = getDigit(a, pos)
|
||||
const digitB = getDigit(b, pos)
|
||||
if (digitA + digitB >= 10) {
|
||||
hasCarry = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasCarry) {
|
||||
return [a, b]
|
||||
}
|
||||
}
|
||||
// Fallback
|
||||
return [12, 34]
|
||||
return minDigits === 1 ? [1, 2] : [12, 34]
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a problem with regrouping in ONES only
|
||||
* (ones sum >= 10 AND tens sum + carry < 10)
|
||||
* Carry from ones to tens, but no higher carries
|
||||
*
|
||||
* @param minDigits Minimum number of digits per addend
|
||||
* @param maxDigits Maximum number of digits per addend
|
||||
*/
|
||||
export function generateOnesOnly(rand: () => number): [number, number] {
|
||||
export function generateOnesOnly(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const a = twoDigit(rand)
|
||||
const b = twoDigit(rand)
|
||||
const aT = Math.floor((a % 100) / 10)
|
||||
const aO = a % 10
|
||||
const bT = Math.floor((b % 100) / 10)
|
||||
const bO = b % 10
|
||||
const digitsA = randint(minDigits, maxDigits, rand)
|
||||
const digitsB = randint(minDigits, maxDigits, rand)
|
||||
const a = generateNumber(digitsA, rand)
|
||||
const b = generateNumber(digitsB, rand)
|
||||
|
||||
if (aO + bO >= 10 && aT + bT + 1 < 10) {
|
||||
const onesA = getDigit(a, 0)
|
||||
const onesB = getDigit(b, 0)
|
||||
|
||||
// Must have ones carry
|
||||
if (onesA + onesB < 10) continue
|
||||
|
||||
// Check that no other place values carry
|
||||
const maxPlaces = Math.max(countDigits(a), countDigits(b))
|
||||
let carry = 1 // carry from ones
|
||||
let hasOtherCarry = false
|
||||
for (let pos = 1; pos < maxPlaces; pos++) {
|
||||
const digitA = getDigit(a, pos)
|
||||
const digitB = getDigit(b, pos)
|
||||
if (digitA + digitB + carry >= 10) {
|
||||
hasOtherCarry = true
|
||||
break
|
||||
}
|
||||
carry = 0 // no more carries after first position
|
||||
}
|
||||
|
||||
if (!hasOtherCarry) {
|
||||
return [a, b]
|
||||
}
|
||||
}
|
||||
// Fallback
|
||||
return [58, 31]
|
||||
return minDigits === 1 ? [5, 8] : [58, 31]
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a problem with regrouping in BOTH ones and tens
|
||||
* (ones sum >= 10 AND tens sum + carry >= 10)
|
||||
* Carries in at least two place values (ones and tens minimum)
|
||||
*
|
||||
* @param minDigits Minimum number of digits per addend
|
||||
* @param maxDigits Maximum number of digits per addend
|
||||
*/
|
||||
export function generateBoth(rand: () => number): [number, number] {
|
||||
export function generateBoth(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const a = twoDigit(rand)
|
||||
const b = twoDigit(rand)
|
||||
const aT = Math.floor((a % 100) / 10)
|
||||
const aO = a % 10
|
||||
const bT = Math.floor((b % 100) / 10)
|
||||
const bO = b % 10
|
||||
const digitsA = randint(minDigits, maxDigits, rand)
|
||||
const digitsB = randint(minDigits, maxDigits, rand)
|
||||
const a = generateNumber(digitsA, rand)
|
||||
const b = generateNumber(digitsB, rand)
|
||||
|
||||
if (aO + bO >= 10 && aT + bT + 1 >= 10) {
|
||||
// Check for carries in each place value
|
||||
const maxPlaces = Math.max(countDigits(a), countDigits(b))
|
||||
let carryCount = 0
|
||||
let carry = 0
|
||||
for (let pos = 0; pos < maxPlaces; pos++) {
|
||||
const digitA = getDigit(a, pos)
|
||||
const digitB = getDigit(b, pos)
|
||||
if (digitA + digitB + carry >= 10) {
|
||||
carryCount++
|
||||
carry = 1
|
||||
} else {
|
||||
carry = 0
|
||||
}
|
||||
}
|
||||
|
||||
// "Both" means at least 2 carries
|
||||
if (carryCount >= 2) {
|
||||
return [a, b]
|
||||
}
|
||||
}
|
||||
// Fallback
|
||||
return [68, 47]
|
||||
return minDigits === 1 ? [8, 9] : [68, 47]
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -117,18 +225,28 @@ function uniquePush(list: AdditionProblem[], a: number, b: number, seen: Set<str
|
|||
|
||||
/**
|
||||
* Generate a complete set of problems based on difficulty parameters
|
||||
*
|
||||
* @param total Total number of problems to generate
|
||||
* @param pAnyStart Starting probability of any regrouping (0-1)
|
||||
* @param pAllStart Starting probability of multiple regrouping (0-1)
|
||||
* @param interpolate If true, difficulty increases from start to end
|
||||
* @param seed Random seed for reproducible generation
|
||||
* @param digitRange Digit range for problem numbers (V4+)
|
||||
*/
|
||||
export function generateProblems(
|
||||
total: number,
|
||||
pAnyStart: number,
|
||||
pAllStart: number,
|
||||
interpolate: boolean,
|
||||
seed: number
|
||||
seed: number,
|
||||
digitRange: { min: number; max: number } = { min: 2, max: 2 }
|
||||
): AdditionProblem[] {
|
||||
const rand = createPRNG(seed)
|
||||
const problems: AdditionProblem[] = []
|
||||
const seen = new Set<string>()
|
||||
|
||||
const { min: minDigits, max: maxDigits } = digitRange
|
||||
|
||||
for (let i = 0; i < total; i++) {
|
||||
// Calculate position from start (0) to end (1)
|
||||
const frac = total <= 1 ? 0 : i / (total - 1)
|
||||
|
|
@ -158,11 +276,11 @@ export function generateProblems(
|
|||
while (tries++ < 3000 && !ok) {
|
||||
let a: number, b: number
|
||||
if (picked === 'both') {
|
||||
;[a, b] = generateBoth(rand)
|
||||
;[a, b] = generateBoth(rand, minDigits, maxDigits)
|
||||
} else if (picked === 'onesOnly') {
|
||||
;[a, b] = generateOnesOnly(rand)
|
||||
;[a, b] = generateOnesOnly(rand, minDigits, maxDigits)
|
||||
} else {
|
||||
;[a, b] = generateNonRegroup(rand)
|
||||
;[a, b] = generateNonRegroup(rand, minDigits, maxDigits)
|
||||
}
|
||||
ok = uniquePush(problems, a, b, seen)
|
||||
|
||||
|
|
@ -172,13 +290,318 @@ export function generateProblems(
|
|||
}
|
||||
}
|
||||
|
||||
// Last resort: add any valid two-digit problem
|
||||
// Last resort: add any valid problem in digit range
|
||||
if (!ok) {
|
||||
const a = twoDigit(rand)
|
||||
const b = twoDigit(rand)
|
||||
const digitsA = randint(minDigits, maxDigits, rand)
|
||||
const digitsB = randint(minDigits, maxDigits, rand)
|
||||
const a = generateNumber(digitsA, rand)
|
||||
const b = generateNumber(digitsB, rand)
|
||||
uniquePush(problems, a, b, seen)
|
||||
}
|
||||
}
|
||||
|
||||
return problems
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// SUBTRACTION PROBLEM GENERATION
|
||||
// =============================================================================
|
||||
|
||||
/**
|
||||
* Generate a subtraction problem with NO borrowing
|
||||
* No borrows in any place value (minuend digit >= subtrahend digit at each place)
|
||||
*
|
||||
* @param minDigits Minimum number of digits
|
||||
* @param maxDigits Maximum number of digits
|
||||
*/
|
||||
export function generateNonBorrow(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const digitsMinuend = randint(minDigits, maxDigits, rand)
|
||||
const digitsSubtrahend = randint(minDigits, maxDigits, rand)
|
||||
const minuend = generateNumber(digitsMinuend, rand)
|
||||
const subtrahend = generateNumber(digitsSubtrahend, rand)
|
||||
|
||||
// Ensure minuend >= subtrahend (no negative results)
|
||||
if (minuend < subtrahend) continue
|
||||
|
||||
// Check all place values for borrows
|
||||
const maxPlaces = Math.max(countDigits(minuend), countDigits(subtrahend))
|
||||
let hasBorrow = false
|
||||
for (let pos = 0; pos < maxPlaces; pos++) {
|
||||
const digitM = getDigit(minuend, pos)
|
||||
const digitS = getDigit(subtrahend, pos)
|
||||
if (digitM < digitS) {
|
||||
hasBorrow = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasBorrow) {
|
||||
return [minuend, subtrahend]
|
||||
}
|
||||
}
|
||||
// Fallback
|
||||
return minDigits === 1 ? [9, 2] : [89, 34]
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a subtraction problem with borrowing in ONES only
|
||||
* Borrow from tens to ones, but no higher borrows
|
||||
*
|
||||
* @param minDigits Minimum number of digits
|
||||
* @param maxDigits Maximum number of digits
|
||||
*/
|
||||
export function generateOnesOnlyBorrow(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const digitsMinuend = randint(minDigits, maxDigits, rand)
|
||||
const digitsSubtrahend = randint(minDigits, maxDigits, rand)
|
||||
const minuend = generateNumber(digitsMinuend, rand)
|
||||
const subtrahend = generateNumber(digitsSubtrahend, rand)
|
||||
|
||||
// Ensure minuend >= subtrahend
|
||||
if (minuend < subtrahend) continue
|
||||
|
||||
const onesM = getDigit(minuend, 0)
|
||||
const onesS = getDigit(subtrahend, 0)
|
||||
|
||||
// Must borrow in ones place
|
||||
if (onesM >= onesS) continue
|
||||
|
||||
// Check that no other place values borrow
|
||||
// Note: For subtraction, we need to track actual borrowing through the places
|
||||
const maxPlaces = Math.max(countDigits(minuend), countDigits(subtrahend))
|
||||
let tempMinuend = minuend
|
||||
let hasOtherBorrow = false
|
||||
|
||||
// Simulate the subtraction place by place
|
||||
for (let pos = 0; pos < maxPlaces; pos++) {
|
||||
let digitM = getDigit(tempMinuend, pos)
|
||||
const digitS = getDigit(subtrahend, pos)
|
||||
|
||||
if (digitM < digitS) {
|
||||
if (pos === 0) {
|
||||
// Expected borrow in ones
|
||||
// Borrow from tens
|
||||
const tensDigit = getDigit(tempMinuend, 1)
|
||||
if (tensDigit === 0) {
|
||||
// Can't borrow from zero - this problem is invalid
|
||||
hasOtherBorrow = true
|
||||
break
|
||||
}
|
||||
// Apply the borrow
|
||||
tempMinuend -= 10 ** 1 // Subtract 10 from tens place
|
||||
} else {
|
||||
// Borrow in higher place - not allowed for ones-only
|
||||
hasOtherBorrow = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasOtherBorrow) {
|
||||
return [minuend, subtrahend]
|
||||
}
|
||||
}
|
||||
// Fallback
|
||||
return minDigits === 1 ? [5, 7] : [52, 17]
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a subtraction problem with borrowing in BOTH ones and tens
|
||||
* Borrows in at least two different place values
|
||||
*
|
||||
* @param minDigits Minimum number of digits
|
||||
* @param maxDigits Maximum number of digits
|
||||
*/
|
||||
export function generateBothBorrow(
|
||||
rand: () => number,
|
||||
minDigits: number = 2,
|
||||
maxDigits: number = 2
|
||||
): [number, number] {
|
||||
for (let i = 0; i < 5000; i++) {
|
||||
const digitsMinuend = randint(minDigits, maxDigits, rand)
|
||||
const digitsSubtrahend = randint(minDigits, maxDigits, rand)
|
||||
const minuend = generateNumber(digitsMinuend, rand)
|
||||
const subtrahend = generateNumber(digitsSubtrahend, rand)
|
||||
|
||||
// Ensure minuend > subtrahend
|
||||
if (minuend <= subtrahend) continue
|
||||
|
||||
// Count how many places require borrowing
|
||||
const maxPlaces = Math.max(countDigits(minuend), countDigits(subtrahend))
|
||||
let borrowCount = 0
|
||||
|
||||
for (let pos = 0; pos < maxPlaces; pos++) {
|
||||
const digitM = getDigit(minuend, pos)
|
||||
const digitS = getDigit(subtrahend, pos)
|
||||
|
||||
if (digitM < digitS) {
|
||||
borrowCount++
|
||||
}
|
||||
}
|
||||
|
||||
// Need at least 2 borrows
|
||||
if (borrowCount >= 2) {
|
||||
return [minuend, subtrahend]
|
||||
}
|
||||
}
|
||||
// Fallback: 534 - 178 requires borrowing in ones and tens
|
||||
return minDigits <= 3 && maxDigits >= 3 ? [534, 178] : [93, 57]
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate subtraction problems with variable digit ranges (1-5 digits)
|
||||
* Similar to addition problem generation but for subtraction
|
||||
*
|
||||
* @param count Number of problems to generate
|
||||
* @param digitRange Digit range for problem generation
|
||||
* @param pAnyStart Initial probability that any place value requires borrowing
|
||||
* @param pAllStart Initial probability that all place values require borrowing
|
||||
* @param interpolate If true, difficulty increases linearly from start to end
|
||||
* @param seed Random seed for reproducibility
|
||||
*/
|
||||
export function generateSubtractionProblems(
|
||||
count: number,
|
||||
digitRange: { min: number; max: number },
|
||||
pAnyBorrow: number,
|
||||
pAllBorrow: number,
|
||||
interpolate: boolean,
|
||||
seed: number
|
||||
): SubtractionProblem[] {
|
||||
const rand = createPRNG(seed)
|
||||
const problems: SubtractionProblem[] = []
|
||||
const seen = new Set<string>()
|
||||
const minDigits = digitRange.min
|
||||
const maxDigits = digitRange.max
|
||||
|
||||
function uniquePush(minuend: number, subtrahend: number): boolean {
|
||||
const key = `${minuend}-${subtrahend}`
|
||||
if (!seen.has(key)) {
|
||||
seen.add(key)
|
||||
problems.push({ minuend, subtrahend, operator: '−' })
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
const t = i / Math.max(1, count - 1) // 0.0 to 1.0
|
||||
const difficultyMultiplier = interpolate ? t : 1
|
||||
|
||||
// Effective probabilities at this position
|
||||
const pAll = Math.max(0, Math.min(1, pAllBorrow * difficultyMultiplier))
|
||||
const pAny = Math.max(0, Math.min(1, pAnyBorrow * difficultyMultiplier))
|
||||
const pOnesOnly = Math.max(0, pAny - pAll)
|
||||
const pNon = Math.max(0, 1 - pAny)
|
||||
|
||||
// Sample category based on probabilities
|
||||
const r = rand()
|
||||
let picked: ProblemCategory
|
||||
if (r < pAll) {
|
||||
picked = 'both'
|
||||
} else if (r < pAll + pOnesOnly) {
|
||||
picked = 'onesOnly'
|
||||
} else {
|
||||
picked = 'non'
|
||||
}
|
||||
|
||||
// Generate problem with retries for uniqueness
|
||||
let tries = 0
|
||||
let ok = false
|
||||
while (tries++ < 3000 && !ok) {
|
||||
let minuend: number, subtrahend: number
|
||||
if (picked === 'both') {
|
||||
;[minuend, subtrahend] = generateBothBorrow(rand, minDigits, maxDigits)
|
||||
} else if (picked === 'onesOnly') {
|
||||
;[minuend, subtrahend] = generateOnesOnlyBorrow(rand, minDigits, maxDigits)
|
||||
} else {
|
||||
;[minuend, subtrahend] = generateNonBorrow(rand, minDigits, maxDigits)
|
||||
}
|
||||
ok = uniquePush(minuend, subtrahend)
|
||||
|
||||
// If stuck, try a different category
|
||||
if (!ok && tries % 50 === 0) {
|
||||
picked = pick(['both', 'onesOnly', 'non'], rand)
|
||||
}
|
||||
}
|
||||
|
||||
// Last resort: add any valid problem in digit range
|
||||
if (!ok) {
|
||||
const digitsM = randint(minDigits, maxDigits, rand)
|
||||
const digitsS = randint(minDigits, maxDigits, rand)
|
||||
let minuend = generateNumber(digitsM, rand)
|
||||
let subtrahend = generateNumber(digitsS, rand)
|
||||
|
||||
// Ensure minuend >= subtrahend
|
||||
if (minuend < subtrahend) {
|
||||
;[minuend, subtrahend] = [subtrahend, minuend]
|
||||
}
|
||||
|
||||
uniquePush(minuend, subtrahend)
|
||||
}
|
||||
}
|
||||
|
||||
return problems
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate mixed addition and subtraction problems
|
||||
* Randomly alternates between addition and subtraction (50/50)
|
||||
*
|
||||
* @param count Number of problems to generate
|
||||
* @param digitRange Digit range for problem generation
|
||||
* @param pAnyRegroup Probability any place needs regrouping (carry or borrow)
|
||||
* @param pAllRegroup Probability all places need regrouping
|
||||
* @param interpolate If true, difficulty increases linearly
|
||||
* @param seed Random seed
|
||||
*/
|
||||
export function generateMixedProblems(
|
||||
count: number,
|
||||
digitRange: { min: number; max: number },
|
||||
pAnyRegroup: number,
|
||||
pAllRegroup: number,
|
||||
interpolate: boolean,
|
||||
seed: number
|
||||
): WorksheetProblem[] {
|
||||
const rand = createPRNG(seed)
|
||||
const problems: WorksheetProblem[] = []
|
||||
|
||||
// Generate half addition, half subtraction (alternating with randomness)
|
||||
for (let i = 0; i < count; i++) {
|
||||
const useAddition = rand() < 0.5
|
||||
|
||||
if (useAddition) {
|
||||
// Generate single addition problem
|
||||
const addProblems = generateProblems(
|
||||
1,
|
||||
pAnyRegroup,
|
||||
pAllRegroup,
|
||||
false, // Don't interpolate individual problems
|
||||
seed + i,
|
||||
digitRange
|
||||
)
|
||||
problems.push(addProblems[0])
|
||||
} else {
|
||||
// Generate single subtraction problem
|
||||
const subProblems = generateSubtractionProblems(
|
||||
1,
|
||||
digitRange,
|
||||
pAnyRegroup,
|
||||
pAllRegroup,
|
||||
false, // Don't interpolate individual problems
|
||||
seed + i + 1000000 // Different seed space
|
||||
)
|
||||
problems.push(subProblems[0])
|
||||
}
|
||||
}
|
||||
|
||||
return problems
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,20 +1,22 @@
|
|||
// Type definitions for double-digit addition worksheet creator
|
||||
// Type definitions for addition worksheet creator (supports 1-5 digit problems)
|
||||
|
||||
import type {
|
||||
AdditionConfigV3,
|
||||
AdditionConfigV3Smart,
|
||||
AdditionConfigV3Manual,
|
||||
AdditionConfigV4,
|
||||
AdditionConfigV4Smart,
|
||||
AdditionConfigV4Manual,
|
||||
} from '../config-schemas'
|
||||
|
||||
/**
|
||||
* Complete, validated configuration for worksheet generation
|
||||
* Extends V3 config with additional derived fields needed for rendering
|
||||
* Extends V4 config with additional derived fields needed for rendering
|
||||
*
|
||||
* V3 uses discriminated union on 'mode':
|
||||
* V4 uses discriminated union on 'mode':
|
||||
* - Smart mode: Uses displayRules for conditional per-problem scaffolding
|
||||
* - Manual mode: Uses boolean flags for uniform display across all problems
|
||||
*
|
||||
* V4 adds digitRange field to support 1-5 digit problems
|
||||
*/
|
||||
export type WorksheetConfig = AdditionConfigV3 & {
|
||||
export type WorksheetConfig = AdditionConfigV4 & {
|
||||
// Problem set - DERIVED state
|
||||
total: number // total = problemsPerPage * pages
|
||||
rows: number // rows = (problemsPerPage / cols) * pages
|
||||
|
|
@ -38,9 +40,9 @@ export type WorksheetConfig = AdditionConfigV3 & {
|
|||
|
||||
/**
|
||||
* Partial form state - user may be editing, fields optional
|
||||
* Based on V3 config with additional derived state
|
||||
* Based on V4 config with additional derived state
|
||||
*
|
||||
* V3 supports two modes via discriminated union:
|
||||
* V4 supports two modes via discriminated union:
|
||||
* - Smart mode: Has displayRules and optional difficultyProfile
|
||||
* - Manual mode: Has boolean display flags and optional manualPreset
|
||||
*
|
||||
|
|
@ -50,8 +52,8 @@ export type WorksheetConfig = AdditionConfigV3 & {
|
|||
* This type is intentionally permissive during form editing to allow fields from
|
||||
* both modes to exist temporarily. Validation will enforce mode consistency.
|
||||
*/
|
||||
export type WorksheetFormState = Partial<Omit<AdditionConfigV3Smart, 'version'>> &
|
||||
Partial<Omit<AdditionConfigV3Manual, 'version'>> & {
|
||||
export type WorksheetFormState = Partial<Omit<AdditionConfigV4Smart, 'version'>> &
|
||||
Partial<Omit<AdditionConfigV4Manual, 'version'>> & {
|
||||
// DERIVED state (calculated from primary state)
|
||||
rows?: number
|
||||
total?: number
|
||||
|
|
@ -59,14 +61,34 @@ export type WorksheetFormState = Partial<Omit<AdditionConfigV3Smart, 'version'>>
|
|||
seed?: number
|
||||
}
|
||||
|
||||
/**
|
||||
* Worksheet operator type
|
||||
*/
|
||||
export type WorksheetOperator = 'addition' | 'subtraction' | 'mixed'
|
||||
|
||||
/**
|
||||
* A single addition problem
|
||||
*/
|
||||
export interface AdditionProblem {
|
||||
a: number
|
||||
b: number
|
||||
operator: '+'
|
||||
}
|
||||
|
||||
/**
|
||||
* A single subtraction problem
|
||||
*/
|
||||
export interface SubtractionProblem {
|
||||
minuend: number
|
||||
subtrahend: number
|
||||
operator: '−' // Proper minus sign (U+2212)
|
||||
}
|
||||
|
||||
/**
|
||||
* Unified problem type (addition or subtraction)
|
||||
*/
|
||||
export type WorksheetProblem = AdditionProblem | SubtractionProblem
|
||||
|
||||
/**
|
||||
* Validation result
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ import { getProfileFromConfig } from './addition/difficultyProfiles'
|
|||
// =============================================================================
|
||||
|
||||
/** Current schema version for addition worksheets */
|
||||
const ADDITION_CURRENT_VERSION = 3
|
||||
const ADDITION_CURRENT_VERSION = 4
|
||||
|
||||
/**
|
||||
* Addition worksheet config - Version 1
|
||||
|
|
@ -227,26 +227,145 @@ export type AdditionConfigV3 = z.infer<typeof additionConfigV3Schema>
|
|||
export type AdditionConfigV3Smart = z.infer<typeof additionConfigV3SmartSchema>
|
||||
export type AdditionConfigV3Manual = z.infer<typeof additionConfigV3ManualSchema>
|
||||
|
||||
/**
|
||||
* Addition worksheet config - Version 4
|
||||
* Adds support for variable digit ranges (1-5 digits per number)
|
||||
*/
|
||||
|
||||
// Shared base fields for V4
|
||||
const additionConfigV4BaseSchema = z.object({
|
||||
version: z.literal(4),
|
||||
|
||||
// Core worksheet settings
|
||||
problemsPerPage: z.number().int().min(1).max(100),
|
||||
cols: z.number().int().min(1).max(10),
|
||||
pages: z.number().int().min(1).max(20),
|
||||
orientation: z.enum(['portrait', 'landscape']),
|
||||
name: z.string(),
|
||||
fontSize: z.number().int().min(8).max(32),
|
||||
|
||||
// V4: Digit range for problem generation
|
||||
digitRange: z
|
||||
.object({
|
||||
min: z.number().int().min(1).max(5),
|
||||
max: z.number().int().min(1).max(5),
|
||||
})
|
||||
.refine((data) => data.min <= data.max, {
|
||||
message: 'min must be less than or equal to max',
|
||||
}),
|
||||
|
||||
// V4: Operator selection (addition, subtraction, or mixed)
|
||||
operator: z.enum(['addition', 'subtraction', 'mixed']).default('addition'),
|
||||
|
||||
// Regrouping probabilities (shared between modes)
|
||||
pAnyStart: z.number().min(0).max(1),
|
||||
pAllStart: z.number().min(0).max(1),
|
||||
interpolate: z.boolean(),
|
||||
})
|
||||
|
||||
// Smart Difficulty Mode for V4
|
||||
const additionConfigV4SmartSchema = additionConfigV4BaseSchema.extend({
|
||||
mode: z.literal('smart'),
|
||||
|
||||
// Conditional display rules
|
||||
displayRules: z.object({
|
||||
carryBoxes: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
answerBoxes: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
placeValueColors: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
tenFrames: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
problemNumbers: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
cellBorders: z.enum([
|
||||
'always',
|
||||
'never',
|
||||
'whenRegrouping',
|
||||
'whenMultipleRegroups',
|
||||
'when3PlusDigits',
|
||||
]),
|
||||
}),
|
||||
|
||||
// Optional: Which smart difficulty profile is selected
|
||||
difficultyProfile: z.string().optional(),
|
||||
})
|
||||
|
||||
// Manual Control Mode for V4
|
||||
const additionConfigV4ManualSchema = additionConfigV4BaseSchema.extend({
|
||||
mode: z.literal('manual'),
|
||||
|
||||
// Simple boolean toggles
|
||||
showCarryBoxes: z.boolean(),
|
||||
showAnswerBoxes: z.boolean(),
|
||||
showPlaceValueColors: z.boolean(),
|
||||
showTenFrames: z.boolean(),
|
||||
showProblemNumbers: z.boolean(),
|
||||
showCellBorder: z.boolean(),
|
||||
showTenFramesForAll: z.boolean(),
|
||||
|
||||
// Optional: Which manual preset is selected
|
||||
manualPreset: z.string().optional(),
|
||||
})
|
||||
|
||||
// V4 uses discriminated union on 'mode'
|
||||
export const additionConfigV4Schema = z.discriminatedUnion('mode', [
|
||||
additionConfigV4SmartSchema,
|
||||
additionConfigV4ManualSchema,
|
||||
])
|
||||
|
||||
export type AdditionConfigV4 = z.infer<typeof additionConfigV4Schema>
|
||||
export type AdditionConfigV4Smart = z.infer<typeof additionConfigV4SmartSchema>
|
||||
export type AdditionConfigV4Manual = z.infer<typeof additionConfigV4ManualSchema>
|
||||
|
||||
/** Union of all addition config versions (add new versions here) */
|
||||
export const additionConfigSchema = z.discriminatedUnion('version', [
|
||||
additionConfigV1Schema,
|
||||
additionConfigV2Schema,
|
||||
additionConfigV3Schema,
|
||||
additionConfigV4Schema,
|
||||
])
|
||||
|
||||
export type AdditionConfig = z.infer<typeof additionConfigSchema>
|
||||
|
||||
/**
|
||||
* Default addition config (always latest version - V3 Smart Mode)
|
||||
* Default addition config (always latest version - V4 Smart Mode)
|
||||
*/
|
||||
export const defaultAdditionConfig: AdditionConfigV3Smart = {
|
||||
version: 3,
|
||||
export const defaultAdditionConfig: AdditionConfigV4Smart = {
|
||||
version: 4,
|
||||
mode: 'smart',
|
||||
problemsPerPage: 20,
|
||||
cols: 5,
|
||||
pages: 1,
|
||||
orientation: 'landscape',
|
||||
name: '',
|
||||
digitRange: { min: 2, max: 2 }, // V4: Default to 2-digit problems (backward compatible)
|
||||
pAnyStart: 0.25,
|
||||
pAllStart: 0,
|
||||
interpolate: true,
|
||||
|
|
@ -347,10 +466,53 @@ function migrateAdditionV2toV3(v2: AdditionConfigV2): AdditionConfigV3 {
|
|||
}
|
||||
|
||||
/**
|
||||
* Migrate addition config from any version to latest (V3)
|
||||
* Migrate V3 config to V4
|
||||
* Adds digitRange field with default of { min: 2, max: 2 } for backward compatibility
|
||||
*/
|
||||
function migrateAdditionV3toV4(v3: AdditionConfigV3): AdditionConfigV4 {
|
||||
// V3 configs didn't have digitRange, so default to 2-digit problems
|
||||
const baseFields = {
|
||||
version: 4 as const,
|
||||
problemsPerPage: v3.problemsPerPage,
|
||||
cols: v3.cols,
|
||||
pages: v3.pages,
|
||||
orientation: v3.orientation,
|
||||
name: v3.name,
|
||||
fontSize: v3.fontSize,
|
||||
digitRange: { min: 2, max: 2 }, // V4: Default to 2-digit for backward compatibility
|
||||
pAnyStart: v3.pAnyStart,
|
||||
pAllStart: v3.pAllStart,
|
||||
interpolate: v3.interpolate,
|
||||
}
|
||||
|
||||
if (v3.mode === 'smart') {
|
||||
return {
|
||||
...baseFields,
|
||||
mode: 'smart',
|
||||
displayRules: v3.displayRules,
|
||||
difficultyProfile: v3.difficultyProfile,
|
||||
}
|
||||
} else {
|
||||
return {
|
||||
...baseFields,
|
||||
mode: 'manual',
|
||||
showCarryBoxes: v3.showCarryBoxes,
|
||||
showAnswerBoxes: v3.showAnswerBoxes,
|
||||
showPlaceValueColors: v3.showPlaceValueColors,
|
||||
showTenFrames: v3.showTenFrames,
|
||||
showProblemNumbers: v3.showProblemNumbers,
|
||||
showCellBorder: v3.showCellBorder,
|
||||
showTenFramesForAll: v3.showTenFramesForAll,
|
||||
manualPreset: v3.manualPreset,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Migrate addition config from any version to latest (V4)
|
||||
* @throws {Error} if config is invalid or migration fails
|
||||
*/
|
||||
export function migrateAdditionConfig(rawConfig: unknown): AdditionConfigV3 {
|
||||
export function migrateAdditionConfig(rawConfig: unknown): AdditionConfigV4 {
|
||||
// First, try to parse as any known version
|
||||
const parsed = additionConfigSchema.safeParse(rawConfig)
|
||||
|
||||
|
|
@ -365,14 +527,18 @@ export function migrateAdditionConfig(rawConfig: unknown): AdditionConfigV3 {
|
|||
// Migrate to latest version
|
||||
switch (config.version) {
|
||||
case 1:
|
||||
// Migrate V1 → V2 → V3
|
||||
return migrateAdditionV2toV3(migrateAdditionV1toV2(config))
|
||||
// Migrate V1 → V2 → V3 → V4
|
||||
return migrateAdditionV3toV4(migrateAdditionV2toV3(migrateAdditionV1toV2(config)))
|
||||
|
||||
case 2:
|
||||
// Migrate V2 → V3
|
||||
return migrateAdditionV2toV3(config)
|
||||
// Migrate V2 → V3 → V4
|
||||
return migrateAdditionV3toV4(migrateAdditionV2toV3(config))
|
||||
|
||||
case 3:
|
||||
// Migrate V3 → V4
|
||||
return migrateAdditionV3toV4(config)
|
||||
|
||||
case 4:
|
||||
// Already latest version
|
||||
return config
|
||||
|
||||
|
|
@ -385,9 +551,9 @@ export function migrateAdditionConfig(rawConfig: unknown): AdditionConfigV3 {
|
|||
|
||||
/**
|
||||
* Parse and validate addition config from JSON string
|
||||
* Automatically migrates old versions to latest (V3)
|
||||
* Automatically migrates old versions to latest (V4)
|
||||
*/
|
||||
export function parseAdditionConfig(jsonString: string): AdditionConfigV3 {
|
||||
export function parseAdditionConfig(jsonString: string): AdditionConfigV4 {
|
||||
try {
|
||||
const raw = JSON.parse(jsonString)
|
||||
return migrateAdditionConfig(raw)
|
||||
|
|
@ -399,13 +565,13 @@ export function parseAdditionConfig(jsonString: string): AdditionConfigV3 {
|
|||
|
||||
/**
|
||||
* Serialize addition config to JSON string
|
||||
* Ensures version field is set to current version (V3)
|
||||
* Ensures version field is set to current version (V4)
|
||||
*/
|
||||
export function serializeAdditionConfig(config: Omit<AdditionConfigV3, 'version'>): string {
|
||||
const versioned: AdditionConfigV3 = {
|
||||
export function serializeAdditionConfig(config: Omit<AdditionConfigV4, 'version'>): string {
|
||||
const versioned: AdditionConfigV4 = {
|
||||
...config,
|
||||
version: ADDITION_CURRENT_VERSION,
|
||||
} as AdditionConfigV3
|
||||
} as AdditionConfigV4
|
||||
return JSON.stringify(versioned)
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue