script.js

// 小学生口算题生成器

// 保存当前题目
let currentQuestions = [];

const gradeSettings = {
    1: {
        name: '一年级',
        maxNumber: 10,
        operations: ['+', '-'],
        hasDecimals: false,
        hasMultipleOperations: false
    },
    2: {
        name: '二年级',
        maxNumber: 20,
        operations: ['+', '-'],
        hasDecimals: false,
        hasMultipleOperations: false
    },
    3: {
        name: '三年级',
        maxNumber: 100,
        operations: ['+', '-', '×'],
        hasDecimals: false,
        hasMultipleOperations: false
    },
    4: {
        name: '四年级',
        maxNumber: 1000,
        operations: ['+', '-', '×', '÷'],
        hasDecimals: false,
        hasMultipleOperations: true
    },
    5: {
        name: '五年级',
        maxNumber: 100,
        operations: ['+', '-', '×', '÷'],
        hasDecimals: true,
        hasMultipleOperations: true
    },
    6: {
        name: '六年级',
        maxNumber: 1000,
        operations: ['+', '-', '×', '÷'],
        hasDecimals: true,
        hasMultipleOperations: true
    }
};

// 生成随机整数
function randomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

// 生成随机小数
function randomDecimal(min, max, decimalPlaces = 1) {
    const num = Math.random() * (max - min) + min;
    return Math.round(num * Math.pow(10, decimalPlaces)) / Math.pow(10, decimalPlaces);
}

// 生成加法题
function generateAddition(settings) {
    const hasDecimal = settings.hasDecimals && Math.random() > 0.7;
    let a, b;
    
    if (hasDecimal) {
        a = randomDecimal(0.1, settings.maxNumber, 1);
        b = randomDecimal(0.1, settings.maxNumber, 1);
    } else {
        a = randomInt(1, settings.maxNumber);
        b = randomInt(1, settings.maxNumber);
    }
    
    const result = a + b;
    // 处理精度问题
    const finalResult = Math.round(result * 100) / 100;
    
    return {
        question: `${a} + ${b} =`,
        answer: finalResult
    };
}

// 生成减法题
function generateSubtraction(settings) {
    const hasDecimal = settings.hasDecimals && Math.random() > 0.7;
    let a, b;
    
    if (hasDecimal) {
        a = randomDecimal(1, settings.maxNumber, 1);
        b = randomDecimal(0.1, a, 1);
    } else {
        a = randomInt(2, settings.maxNumber);
        b = randomInt(1, a - 1);
    }
    
    const result = a - b;
    const finalResult = Math.round(result * 100) / 100;
    
    return {
        question: `${a} - ${b} =`,
        answer: finalResult
    };
}

// 生成乘法题
function generateMultiplication(settings) {
    const hasDecimal = settings.hasDecimals && Math.random() > 0.7;
    let a, b, factor;
    
    // 根据年级调整乘数范围
    if (settings.name === '三年级') {
        factor = 9;
    } else if (settings.name === '四年级') {
        factor = 20;
    } else {
        factor = settings.hasDecimals ? 10 : 100;
    }
    
    if (hasDecimal) {
        a = randomDecimal(0.1, factor, 1);
        b = randomDecimal(0.1, 10, 1);
    } else {
        a = randomInt(1, factor);
        b = randomInt(1, 10);
    }
    
    const result = a * b;
    const finalResult = Math.round(result * 100) / 100;
    
    return {
        question: `${a} × ${b} =`,
        answer: finalResult
    };
}

// 生成除法题
function generateDivision(settings) {
    // 除法要生成能整除的题目
    const hasDecimal = settings.hasDecimals && Math.random() > 0.7;
    let b, quotient;
    
    if (hasDecimal) {
        b = randomDecimal(0.1, 10, 1);
        quotient = randomDecimal(0.1, settings.maxNumber / b, 1);
    } else {
        b = randomInt(1, settings.maxNumber / 10);
        quotient = randomInt(1, Math.floor(settings.maxNumber / b));
    }
    
    const a = b * quotient;
    const finalResult = Math.round(quotient * 100) / 100;
    
    return {
        question: `${a} ÷ ${b} =`,
        answer: finalResult
    };
}

// 生成混合运算题
function generateMixedOperation(settings) {
    const ops = ['+', '-', '×'];
    const op1 = ops[randomInt(0, ops.length - 1)];
    const op2 = ops[randomInt(0, ops.length - 1)];
    
    const a = randomInt(1, 20);
    const b = randomInt(1, 20);
    const c = randomInt(1, 20);
    
    let question, answer;
    
    if (op1 === '×' || op2 === '×') {
        // 简化混合运算，优先处理乘法
        question = `${a} × ${b} + ${c} =`;
        answer = a * b + c;
    } else {
        question = `${a} + ${b} - ${c} =`;
        answer = a + b - c;
    }
    
    return {
        question: question,
        answer: answer
    };
}

// 获取选中的运算类型
function getSelectedOperations() {
    const operations = [];
    if (document.getElementById('addition').checked) operations.push('+');
    if (document.getElementById('subtraction').checked) operations.push('-');
    if (document.getElementById('multiplication').checked) operations.push('×');
    if (document.getElementById('division').checked) operations.push('÷');
    return operations;
}

// 生成单个题目
function generateQuestion(settings) {
    const selectedOps = getSelectedOperations();
    
    if (selectedOps.length === 0) {
        return null;
    }
    
    // 决定是否生成混合运算
    if (settings.hasMultipleOperations && Math.random() > 0.8 && selectedOps.length > 1) {
        return generateMixedOperation(settings);
    }
    
    const operation = selectedOps[randomInt(0, selectedOps.length - 1)];
    
    switch (operation) {
        case '+':
            return generateAddition(settings);
        case '-':
            return generateSubtraction(settings);
        case '×':
            return generateMultiplication(settings);
        case '÷':
            return generateDivision(settings);
        default:
            return generateAddition(settings);
    }
}

// 生成题目列表
function generateQuestions() {
    const grade = parseInt(document.getElementById('grade').value);
    const count = parseInt(document.getElementById('questionCount').value);
    const showAnswers = document.getElementById('showAnswers').checked;
    
    const settings = gradeSettings[grade];
    const questions = [];
    
    // 生成题目
    for (let i = 0; i < count; i++) {
        const question = generateQuestion(settings);
        if (question) {
            questions.push({
                number: i + 1,
                userAnswer: null,
                ...question
            });
        }
    }
    
    // 保存当前题目
    currentQuestions = questions;
    
    // 显示题目（如果显示答案被勾选，就显示答案，否则显示输入框）
    displayQuestions(questions, showAnswers);
    
    // 显示提交按钮（只有在非显示答案模式下才显示）
    document.getElementById('submitBtn').style.display = showAnswers ? 'none' : 'inline-block';
    
    // 隐藏结果面板
    document.getElementById('resultPanel').style.display = 'none';
}

// 显示题目
function displayQuestions(questions, showAnswers) {
    const container = document.getElementById('questionsContainer');
    
    if (questions.length === 0) {
        container.innerHTML = '<p class="placeholder">请至少选择一种运算类型</p>';
        return;
    }
    
    const grid = document.createElement('div');
    grid.className = 'questions-grid';
    
    questions.forEach((q, index) => {
        const card = document.createElement('div');
        card.className = 'question-card';
        card.id = `question-${index}`;
        
        let html = `
            <div class="question-number">${index + 1}.</div>
            <div class="question-text">${q.question}</div>
        `;
        
        if (showAnswers) {
            // 显示答案模式：直接显示答案
            html += `<div class="answer-text">${q.answer}</div>`;
        } else {
            // 答题模式：显示输入框
            html += `<input type="number" class="user-answer" id="answer-${index}" placeholder="答案" step="any">`;
        }
        
        card.innerHTML = html;
        grid.appendChild(card);
    });
    
    container.innerHTML = '';
    container.appendChild(grid);
}

// 打印题目
function printQuestions() {
    window.print();
}

// 提交答案并判卷
function submitAnswers() {
    const questions = currentQuestions;
    let correctCount = 0;
    let unansweredCount = 0;
    const results = [];
    
    questions.forEach((q, index) => {
        const inputElement = document.getElementById(`answer-${index}`);
        const cardElement = document.getElementById(`question-${index}`);
        
        if (inputElement) {
            const userAnswer = inputElement.value.trim();
            
            if (userAnswer === '') {
                // 未作答
                unansweredCount++;
                results.push({
                    question: q.question,
                    userAnswer: null,
                    correctAnswer: q.answer,
                    status: 'unanswered'
                });
                cardElement.querySelector('.user-answer').classList.add('unanswered');
            } else {
                const userNum = parseFloat(userAnswer);
                const correctNum = parseFloat(q.answer);
                const isCorrect = Math.abs(userNum - correctNum) < 0.001; // 处理浮点数精度
                
                if (isCorrect) {
                    correctCount++;
                    results.push({
                        question: q.question,
                        userAnswer: userAnswer,
                        correctAnswer: q.answer,
                        status: 'correct'
                    });
                    cardElement.querySelector('.user-answer').classList.add('correct');
                } else {
                    results.push({
                        question: q.question,
                        userAnswer: userAnswer,
                        correctAnswer: q.answer,
                        status: 'incorrect'
                    });
                    cardElement.querySelector('.user-answer').classList.add('incorrect');
                }
            }
        }
    });
    
    // 显示结果
    displayResults(correctCount, questions.length, unansweredCount, results);
}

// 显示判卷结果
function displayResults(correctCount, totalCount, unansweredCount, results) {
    const resultPanel = document.getElementById('resultPanel');
    const resultContent = document.getElementById('resultContent');
    
    const incorrectCount = totalCount - correctCount - unansweredCount;
    const score = Math.round((correctCount / totalCount) * 100);
    
    // 确定成绩等级
    let scoreClass = 'pass';
    if (score === 100) {
        scoreClass = 'perfect';
    } else if (score >= 80) {
        scoreClass = 'good';
    } else if (score < 60) {
        scoreClass = 'fail';
    }
    
    let html = `
        <div class="score-summary">
            <div class="score-title">📊 成绩单</div>
            <div class="score-details">
                <div class="score-item">
                    <div class="score-value ${scoreClass}">${score}分</div>
                    <div class="score-label">总分</div>
                </div>
                <div class="score-item">
                    <div class="score-value">${correctCount}</div>
                    <div class="score-label">正确</div>
                </div>
                <div class="score-item">
                    <div class="score-value">${incorrectCount}</div>
                    <div class="score-label">错误</div>
                </div>
                <div class="score-item">
                    <div class="score-value">${unansweredCount}</div>
                    <div class="score-label">未作答</div>
                </div>
            </div>
        </div>
        
        <div class="detailed-results">
            <h3>📝 详细结果</h3>
    `;
    
    results.forEach((r, index) => {
        let statusText, statusClass;
        if (r.status === 'correct') {
            statusText = '✅ 正确';
            statusClass = 'correct';
        } else if (r.status === 'incorrect') {
            statusText = '❌ 错误';
            statusClass = 'incorrect';
        } else {
            statusText = '⚠️ 未作答';
            statusClass = 'unanswered';
        }
        
        html += `
            <div class="detailed-item ${statusClass}">
                <div class="detailed-question">${index + 1}. ${r.question} ${r.userAnswer !== null ? r.userAnswer : ''}</div>
                <div class="detailed-answers">
                    <span class="result-badge ${statusClass}">${statusText}</span>
                    ${r.status !== 'correct' ? `<span class="correct-answer-text">正确答案: ${r.correctAnswer}</span>` : ''}
                </div>
            </div>
        `;
    });
    
    html += '</div>';
    
    resultContent.innerHTML = html;
    resultPanel.style.display = 'block';
    
    // 滚动到结果区域
    resultPanel.scrollIntoView({ behavior: 'smooth' });
}

// 事件监听
document.getElementById('generateBtn').addEventListener('click', generateQuestions);
document.getElementById('printBtn').addEventListener('click', printQuestions);
document.getElementById('submitBtn').addEventListener('click', submitAnswers);

// 年级变化时自动调整运算类型选项
document.getElementById('grade').addEventListener('change', function() {
    const grade = parseInt(this.value);
    const settings = gradeSettings[grade];
    
    // 根据年级设置运算类型
    document.getElementById('addition').checked = settings.operations.includes('+');
    document.getElementById('subtraction').checked = settings.operations.includes('-');
    document.getElementById('multiplication').checked = settings.operations.includes('×');
    document.getElementById('division').checked = settings.operations.includes('÷');
    
    // 根据年级调整建议题目数量
    const counts = {1: 20, 2: 20, 3: 20, 4: 15, 5: 10, 6: 10};
    document.getElementById('questionCount').value = counts[grade];
});

// 页面加载时生成一次示例
window.addEventListener('load', function() {
    // 自动生成一些示例题目
    generateQuestions();
    
    // 添加输入框的快捷键支持
    document.addEventListener('keydown', function(e) {
        if (e.key === 'Enter') {
            const activeElement = document.activeElement;
            if (activeElement && activeElement.classList.contains('user-answer')) {
                e.preventDefault();
                const allInputs = document.querySelectorAll('.user-answer');
                const currentIndex = Array.from(allInputs).indexOf(activeElement);
                if (currentIndex < allInputs.length - 1) {
                    allInputs[currentIndex + 1].focus();
                }
            }
        }
    });
});