Интерактивные примеры

function calculateFactorial(n) {
    if (n < 0) return "Факториал отрицательного числа не определён";
    
    let factorial = 1;
    let steps = [];
    
    for (let i = 1; i <= n; i++) {
        factorial *= i;
        steps.push(`${i}! = ${factorial}`);
    }
    
    return { result: factorial, steps: steps };
}

function generateMultiplicationTable(size) {
    let table = [];
    
    for (let i = 1; i <= size; i++) {
        let row = [];
        for (let j = 1; j <= size; j++) {
            row.push(i * j);
        }
        table.push(row);
    }
    
    return table;
}

function generateFibonacci(count) {
    let fibonacci = [];
    
    if (count >= 1) fibonacci.push(0);
    if (count >= 2) fibonacci.push(1);
    
    for (let i = 2; i < count; i++) {
        let next = fibonacci[i - 1] + fibonacci[i - 2];
        fibonacci.push(next);
    }
    
    return fibonacci;
}

function findPrimeNumbers(limit) {
    let primes = [];
    
    for (let num = 2; num <= limit; num++) {
        let isPrime = true;
        
        for (let div = 2; div <= Math.sqrt(num); div++) {
            if (num % div === 0) {
                isPrime = false;
                break;
            }
        }
        
        if (isPrime) {
            primes.push(num);
        }
    }
    
    return primes;
}

function calculateSeries(type, n) {
    let sum = 0;
    let terms = [];
    
    for (let i = 1; i <= n; i++) {
        let term;
        
        switch(type) {
            case 'arithmetic':
                term = i;
                break;
            case 'geometric':
                term = Math.pow(2, i - 1);
                break;
            case 'harmonic':
                term = 1 / i;
                break;
            case 'squares':
                term = i * i;
                break;
        }
        
        sum += term;
        terms.push(term);
    }
    
    return { sum, terms };
}

function processArray(array) {
    let stats = {
        min: array[0],
        max: array[0],
        sum: 0,
        average: 0,
        even: [],
        odd: []
    };
    
    // Один проход для всех вычислений
    for (let i = 0; i < array.length; i++) {
        let value = array[i];
        
        stats.sum += value;
        
        if (value < stats.min) stats.min = value;
        if (value > stats.max) stats.max = value;
        
        if (value % 2 === 0) {
            stats.even.push(value);
        } else {
            stats.odd.push(value);
        }
    }
    
    stats.average = stats.sum / array.length;
    
    return stats;
}

function drawPattern(type, size) {
    let pattern = [];
    
    switch(type) {
        case 'triangle':
            for (let i = 1; i <= size; i++) {
                let row = '';
                for (let j = 1; j <= i; j++) {
                    row += '* ';
                }
                pattern.push(row);
            }
            break;
            
        case 'pyramid':
            for (let i = 1; i <= size; i++) {
                let spaces = ' '.repeat(size - i);
                let stars = '*'.repeat(2 * i - 1);
                pattern.push(spaces + stars);
            }
            break;
            
        case 'diamond':
            // Верхняя часть
            for (let i = 1; i <= size; i++) {
                let spaces = ' '.repeat(size - i);
                let stars = '*'.repeat(2 * i - 1);
                pattern.push(spaces + stars);
            }
            // Нижняя часть
            for (let i = size - 1; i >= 1; i--) {
                let spaces = ' '.repeat(size - i);
                let stars = '*'.repeat(2 * i - 1);
                pattern.push(spaces + stars);
            }
            break;
    }
    
    return pattern;
}

function guessNumberGame() {
    let secretNumber = Math.floor(Math.random() * 100) + 1;
    let attempts = 0;
    let maxAttempts = 7;
    let history = [];
    
    while (attempts < maxAttempts) {
        let guess = getUserGuess(); // Получение ввода
        attempts++;
        
        if (guess === secretNumber) {
            return {
                success: true,
                attempts: attempts,
                number: secretNumber
            };
        }
        
        let hint = guess < secretNumber ? 'больше' : 'меньше';
        history.push({ guess, hint });
        
        if (attempts === maxAttempts) {
            return {
                success: false,
                attempts: attempts,
                number: secretNumber
            };
        }
    }
}

function binarySearch(array, target) {
    let left = 0;
    let right = array.length - 1;
    let steps = [];
    
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        
        steps.push({
            left: left,
            right: right,
            mid: mid,
            value: array[mid]
        });
        
        if (array[mid] === target) {
            return { found: true, index: mid, steps };
        } else if (array[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return { found: false, steps };
}

function createMatrix(rows, cols, type) {
    let matrix = [];
    
    // Инициализация матрицы
    for (let i = 0; i < rows; i++) {
        matrix[i] = [];
        for (let j = 0; j < cols; j++) {
            matrix[i][j] = 0;
        }
    }
    
    // Заполнение в зависимости от типа
    switch(type) {
        case 'identity':
            for (let i = 0; i < Math.min(rows, cols); i++) {
                matrix[i][i] = 1;
            }
            break;
            
        case 'diagonal':
            for (let i = 0; i < rows; i++) {
                for (let j = 0; j < cols; j++) {
                    if (i === j) {
                        matrix[i][j] = i + 1;
                    }
                }
            }
            break;
            
        case 'random':
            for (let i = 0; i < rows; i++) {
                for (let j = 0; j < cols; j++) {
                    matrix[i][j] = Math.floor(Math.random() * 10);
                }
            }
            break;
    }
    
    return matrix;
}

function demonstrateBreakContinue(limit, operation) {
    let result = [];
    
    switch(operation) {
        case 'skip-even':
            for (let i = 1; i <= limit; i++) {
                if (i % 2 === 0) continue;
                result.push(i);
            }
            break;
            
        case 'stop-at':
            let stopAt = Math.floor(limit / 2);
            for (let i = 1; i <= limit; i++) {
                if (i === stopAt) break;
                result.push(i);
            }
            break;
            
        case 'skip-multiples':
            for (let i = 1; i <= limit; i++) {
                if (i % 3 === 0) continue;
                result.push(i);
            }
            break;
    }
    
    return result;
}

function euclideanAlgorithm(a, b) {
    let steps = [];
    
    // Метод вычитания
    while (a !== b) {
        steps.push({ a, b, operation: a > b ? 'a-b' : 'b-a' });
        
        if (a > b) {
            a = a - b;
        } else {
            b = b - a;
        }
    }
    
    return { gcd: a, steps };
}

// Оптимизированный метод с делением
function euclideanDivision(a, b) {
    let steps = [];
    
    while (b !== 0) {
        let remainder = a % b;
        steps.push({ a, b, remainder });
        a = b;
        b = remainder;
    }
    
    return { gcd: a, steps };
}