function findMinMax(a, b, c) {
    // Находим минимальное число
    const min = Math.min(a, b, c);
    
    // Находим максимальное число
    const max = Math.max(a, b, c);
    
    console.log(`Наименьшее: ${min}`);
    console.log(`Наибольшее: ${max}`);
    
    return { min, max };
}

// Примеры использования:
findMinMax(5, 3, 8);
/*
Наименьшее: 3
Наибольшее: 8
*/

findMinMax(-2, -5, 1);
/*
Наименьшее: -5
Наибольшее: 1
*/

findMinMax(10, 10, 5);
/*
Наименьшее: 5
Наибольшее: 10
*/

function integerDivision(N, K) {
    // Проверка входных данных
    if (N <= 0 || K <= 0) {
        console.log("Ошибка: оба числа должны быть положительными");
        return;
    }
    if (!Number.isInteger(N) || !Number.isInteger(K)) {
        console.log("Ошибка: оба числа должны быть целыми");
        return;
    }

    let quotient = 0;  // частное
    let remainder = N; // остаток (изначально равно N)

    // Вычитаем K из остатка, пока это возможно
    while (remainder >= K) {
        remainder -= K; // вычитаем K
        quotient++;     // увеличиваем частное на 1
    }

    console.log(`N = ${N}, K = ${K}`);
    console.log(`Частное: ${quotient}`);
    console.log(`Остаток: ${remainder}`);
    console.log(`Проверка: ${N} = ${K} * ${quotient} + ${remainder}`);

    return { quotient, remainder };
}

// Примеры использования:
integerDivision(10, 3);
/*
N = 10, K = 3
Частное: 3
Остаток: 1
Проверка: 10 = 3 * 3 + 1
*/

integerDivision(15, 4);
/*
N = 15, K = 4
Частное: 3
Остаток: 3
Проверка: 15 = 4 * 3 + 3
*/

integerDivision(20, 5);
/*
N = 20, K = 5
Частное: 4
Остаток: 0
Проверка: 20 = 5 * 4 + 0
*/

integerDivision(7, 10);
/*
N = 7, K = 10
Частное: 0
Остаток: 7
Проверка: 7 = 10 * 0 + 7
*/

function checkAtLeastOnePositive(A, B, C) {
    // Проверяем, что все числа целые
    if (!Number.isInteger(A) || !Number.isInteger(B) || !Number.isInteger(C)) {
        console.log("Ошибка: все числа должны быть целыми");
        return false;
    }

    // Проверяем, что хотя бы одно число положительное
    const result = A > 0 || B > 0 || C > 0;
    
    return result;
}

// Примеры использования:
console.log(checkAtLeastOnePositive(5, -3, -8));   // true (A положительное)
console.log(checkAtLeastOnePositive(-2, 4, -7));   // true (B положительное)
console.log(checkAtLeastOnePositive(-1, -2, 3));   // true (C положительное)
console.log(checkAtLeastOnePositive(0, 5, -9));    // true (B положительное)
console.log(checkAtLeastOnePositive(2, 3, 4));     // true (все положительные)
console.log(checkAtLeastOnePositive(-1, 0, -5));   // false (нет положительных)
console.log(checkAtLeastOnePositive(0, 0, 0));     // false (все нули)
console.log(checkAtLeastOnePositive(-3, -4, -5));  // false (все отрицательные)

function transformVariables(A, B, C) {
    // Проверка, что все значения являются числами
    if (typeof A !== 'number' || typeof B !== 'number' || typeof C !== 'number' || 
        isNaN(A) || isNaN(B) || isNaN(C)) {
        console.log("Ошибка: все переменные должны быть вещественными числами");
        return;
    }

    console.log(`Исходные значения: A = ${A}, B = ${B}, C = ${C}`);

    // Проверяем упорядоченность по возрастанию или убыванию
    const isAscending = A <= B && B <= C;
    const isDescending = A >= B && B >= C;
    const isOrdered = isAscending || isDescending;

    if (isOrdered) {
        // Упорядочены - удваиваем значения
        A *= 2;
        B *= 2;
        C *= 2;
        console.log("Значения упорядочены - удваиваем их");
    } else {
        // Не упорядочены - меняем на противоположные
        A = -A;
        B = -B;
        C = -C;
        console.log("Значения не упорядочены - меняем на противоположные");
    }

    console.log(`Новые значения: A = ${A}, B = ${B}, C = ${C}`);
    return { A, B, C };
}

// Примеры использования:
transformVariables(1.0, 2.0, 3.0);
/*
Исходные значения: A = 1, B = 2, C = 3
Значения упорядочены - удваиваем их
Новые значения: A = 2, B = 4, C = 6
*/

transformVariables(5.5, 3.2, 1.1);
/*
Исходные значения: A = 5.5, B = 3.2, C = 1.1
Значения упорядочены - удваиваем их
Новые значения: A = 11, B = 6.4, C = 2.2
*/

transformVariables(2.0, 4.0, 3.0);
/*
Исходные значения: A = 2, B = 4, C = 3
Значения не упорядочены - меняем на противоположные
Новые значения: A = -2, B = -4, C = -3
*/

transformVariables(0, 0, 0);
/*
Исходные значения: A = 0, B = 0, C = 0
Значения упорядочены - удваиваем их
Новые значения: A = 0, B = 0, C = 0
*/

function findPowerOfTwo(N) {
    // Проверка входных данных
    if (!Number.isInteger(N) || N <= 0) {
        console.log("Ошибка: N должно быть целым положительным числом");
        return null;
    }

    // Проверяем, является ли число степенью двойки
    // Число является степенью двойки, если (N & (N-1)) === 0
    if ((N & (N - 1)) !== 0) {
        console.log(`Ошибка: ${N} не является степенью числа 2`);
        return null;
    }

    let K = 0;
    let temp = N;
    
    // Делим N на 2, пока не получим 1
    while (temp > 1) {
        temp >>= 1; // Побитовый сдвиг вправо (деление на 2)
        K++;
    }

    console.log(`N = ${N} = 2^${K}`);
    return K;
}

// Примеры использования:
console.log(findPowerOfTwo(1));    // 0 (2^0 = 1)
console.log(findPowerOfTwo(2));    // 1 (2^1 = 2)
console.log(findPowerOfTwo(4));    // 2 (2^2 = 4)
console.log(findPowerOfTwo(8));    // 3 (2^3 = 8)
console.log(findPowerOfTwo(16));   // 4 (2^4 = 16)
console.log(findPowerOfTwo(32));   // 5 (2^5 = 32)
console.log(findPowerOfTwo(256));  // 8 (2^8 = 256)
console.log(findPowerOfTwo(1024)); // 10 (2^10 = 1024)

function checkExactlyOnePositive(A, B, C) {
    // Проверяем, что все числа целые
    if (!Number.isInteger(A) || !Number.isInteger(B) || !Number.isInteger(C)) {
        console.log("Ошибка: все числа должны быть целыми");
        return false;
    }

    // Считаем количество положительных чисел
    let positiveCount = 0;
    if (A > 0) positiveCount++;
    if (B > 0) positiveCount++;
    if (C > 0) positiveCount++;

    // Ровно одно положительное
    const result = positiveCount === 1;
    
    return result;
}

// Примеры использования:
console.log(checkExactlyOnePositive(5, -3, -8));   // true (только A положительное)
console.log(checkExactlyOnePositive(-2, 4, -7));   // true (только B положительное)
console.log(checkExactlyOnePositive(-1, -2, 3));   // true (только C положительное)
console.log(checkExactlyOnePositive(2, -4, 6));    // false (два положительных)
console.log(checkExactlyOnePositive(2, 3, 4));     // false (три положительных)
console.log(checkExactlyOnePositive(-1, 0, -5));   // false (нет положительных)
console.log(checkExactlyOnePositive(0, 0, 0));     // false (нет положительных)
console.log(checkExactlyOnePositive(-3, -4, -5));  // false (нет положительных)
console.log(checkExactlyOnePositive(0, 5, -9));    // true (только B положительное)
console.log(checkExactlyOnePositive(0, 0, 3));     // true (только C положительное)

function findClosestPoint(A, B, C) {
    // Проверка, что все значения являются числами
    if (typeof A !== 'number' || typeof B !== 'number' || typeof C !== 'number' ||
        isNaN(A) || isNaN(B) || isNaN(C)) {
        console.log("Ошибка: все точки должны быть числами");
        return;
    }

    // Вычисляем расстояния от A до B и от A до C
    const distanceAB = Math.abs(B - A);
    const distanceAC = Math.abs(C - A);

    console.log(`Точка A: ${A}`);
    console.log(`Точка B: ${B}, расстояние от A: ${distanceAB.toFixed(2)}`);
    console.log(`Точка C: ${C}, расстояние от A: ${distanceAC.toFixed(2)}`);

    // Сравниваем расстояния
    if (distanceAB < distanceAC) {
        console.log(`Ближе точка B`);
        console.log(`Расстояние от A до B: ${distanceAB.toFixed(2)}`);
        return { closestPoint: 'B', pointValue: B, distance: distanceAB };
    } 
    else if (distanceAC < distanceAB) {
        console.log(`Ближе точка C`);
        console.log(`Расстояние от A до C: ${distanceAC.toFixed(2)}`);
        return { closestPoint: 'C', pointValue: C, distance: distanceAC };
    }
    else {
        console.log(`Точки B и C находятся на одинаковом расстоянии от A`);
        console.log(`Расстояние: ${distanceAB.toFixed(2)}`);
        return { closestPoint: 'B и C равноудалены', pointValue: null, distance: distanceAB };
    }
}

// Примеры использования:
findClosestPoint(0, 5, 8);
/*
Точка A: 0
Точка B: 5, расстояние от A: 5.00
Точка C: 8, расстояние от A: 8.00
Ближе точка B
Расстояние от A до B: 5.00
*/

findClosestPoint(10, 3, 15);
/*
Точка A: 10
Точка B: 3, расстояние от A: 7.00
Точка C: 15, расстояние от A: 5.00
Ближе точка C
Расстояние от A до C: 5.00
*/

findClosestPoint(5, 2, 8);
/*
Точка A: 5
Точка B: 2, расстояние от A: 3.00
Точка C: 8, расстояние от A: 3.00
Точки B и C находятся на одинаковом расстоянии от A
Расстояние: 3.00
*/

findClosestPoint(-3, 0, -5);
/*
Точка A: -3
Точка B: 0, расстояние от A: 3.00
Точка C: -5, расстояние от A: 2.00
Ближе точка C
Расстояние от A до C: 2.00
*/

function findSmallestK(N) {
    // Проверка входных данных
    if (!Number.isInteger(N) || N <= 0) {
        console.log("Ошибка: N должно быть целым положительным числом");
        return;
    }

    let K = 1;
    
    // Ищем наименьшее K, такое что K^2 > N
    while (K * K <= N) {
        K++;
    }

    console.log(`N = ${N}`);
    console.log(`K = ${K} (проверка: ${K-1}² = ${(K-1)*(K-1)} ≤ ${N} < ${K}² = ${K*K})`);
    return K;
}

// Примеры использования:
findSmallestK(10);
/*
N = 10
K = 4 (проверка: 3² = 9 ≤ 10 < 4² = 16)
*/

findSmallestK(25);
/*
N = 25
K = 6 (проверка: 5² = 25 ≤ 25 < 6² = 36)
*/

findSmallestK(1);
/*
N = 1
K = 2 (проверка: 1² = 1 ≤ 1 < 2² = 4)
*/

findSmallestK(50);
/*
N = 50
K = 8 (проверка: 7² = 49 ≤ 50 < 8² = 64)
*/

findSmallestK(100);
/*
N = 100
K = 11 (проверка: 10² = 100 ≤ 100 < 11² = 121)
*/

function checkExactlyTwoPositive(A, B, C) {
    // Проверяем, что все числа целые
    if (!Number.isInteger(A) || !Number.isInteger(B) || !Number.isInteger(C)) {
        console.log("Ошибка: все числа должны быть целыми");
        return false;
    }

    // Считаем количество положительных чисел
    let positiveCount = 0;
    if (A > 0) positiveCount++;
    if (B > 0) positiveCount++;
    if (C > 0) positiveCount++;

    // Проверяем, что ровно два числа положительные
    const result = positiveCount === 2;
    
    return result;
}

// Примеры использования:
console.log(checkExactlyTwoPositive(5, 3, -8));   // true (A и B положительные)
console.log(checkExactlyTwoPositive(-2, 4, 7));   // true (B и C положительные)
console.log(checkExactlyTwoPositive(1, -2, 3));   // true (A и C положительные)
console.log(checkExactlyTwoPositive(2, 3, 4));    // false (три положительных)
console.log(checkExactlyTwoPositive(5, -3, -8));  // false (одно положительное)
console.log(checkExactlyTwoPositive(-1, 0, -5));  // false (нет положительных)
console.log(checkExactlyTwoPositive(0, 0, 3));    // false (одно положительное)
console.log(checkExactlyTwoPositive(0, 5, 6));    // true (B и C положительные)
console.log(checkExactlyTwoPositive(-3, -4, -5)); // false (нет положительных)

function determinePointPosition(x, y) {
    // Проверка, что координаты целые
    if (!Number.isInteger(x) || !Number.isInteger(y)) {
        console.log("Ошибка: координаты должны быть целыми числами");
        return;
    }

    console.log(`Точка с координатами: (${x}, ${y})`);

    let result;
    if (x === 0 && y === 0) {
        result = 0;
        console.log("Точка совпадает с началом координат");
    } 
    else if (x === 0) {
        result = 2; // лежит на оси OY
        console.log("Точка лежит на оси OY (ось ординат)");
    } 
    else if (y === 0) {
        result = 1; // лежит на оси OX
        console.log("Точка лежит на оси OX (ось абсцисс)");
    } 
    else {
        result = 3; // не лежит на осях
        console.log("Точка не лежит на координатных осях");
    }

    console.log(`Результат: ${result}`);
    return result;
}

// Примеры использования:
determinePointPosition(0, 0);
/*
Точка с координатами: (0, 0)
Точка совпадает с началом координат
Результат: 0
*/

determinePointPosition(5, 0);
/*
Точка с координатами: (5, 0)
Точка лежит на оси OX (ось абсцисс)
Результат: 1
*/

determinePointPosition(0, -3);
/*
Точка с координатами: (0, -3)
Точка лежит на оси OY (ось ординат)
Результат: 2
*/

determinePointPosition(2, 3);
/*
Точка с координатами: (2, 3)
Точка не лежит на координатных осях
Результат: 3
*/

determinePointPosition(-4, 5);
/*
Точка с координатами: (-4, 5)
Точка не лежит на координатных осях
Результат: 3
*/

determinePointPosition(-7, 0);
/*
Точка с координатами: (-7, 0)
Точка лежит на оси OX (ось абсцисс)
Результат: 1
*/

function calculateSumAndProduct(N, numbers) {
    // Проверка входных данных
    if (!Number.isInteger(N) || N <= 0) {
        console.log("Ошибка: N должно быть целым положительным числом");
        return;
    }
    
    if (!Array.isArray(numbers) || numbers.length !== N) {
        console.log(`Ошибка: необходимо предоставить массив из ${N} чисел`);
        return;
    }
    
    // Проверка, что все элементы - числа
    for (let i = 0; i < numbers.length; i++) {
        if (typeof numbers[i] !== 'number' || isNaN(numbers[i])) {
            console.log(`Ошибка: элемент с индексом ${i} не является числом`);
            return;
        }
    }

    // Вычисление суммы
    let sum = 0;
    for (let i = 0; i < numbers.length; i++) {
        sum += numbers[i];
    }

    // Вычисление произведения
    let product = 1;
    for (let i = 0; i < numbers.length; i++) {
        product *= numbers[i];
    }

    console.log(`N = ${N}`);
    console.log(`Набор чисел: [${numbers.join(', ')}]`);
    console.log(`Сумма: ${sum.toFixed(2)}`);
    console.log(`Произведение: ${product.toFixed(2)}`);
    
    return { sum, product };
}

// Примеры использования:
calculateSumAndProduct(5, [1.5, 2.3, 3.7, 4.1, 5.9]);
/*
N = 5
Набор чисел: [1.5, 2.3, 3.7, 4.1, 5.9]
Сумма: 17.50
Произведение: 308.79
*/

calculateSumAndProduct(3, [-2.5, 0, 4.2]);
/*
N = 3
Набор чисел: [-2.5, 0, 4.2]
Сумма: 1.70
Произведение: 0.00
*/

calculateSumAndProduct(4, [1.1, 2.2, 3.3, 4.4]);
/*
N = 4
Набор чисел: [1.1, 2.2, 3.3, 4.4]
Сумма: 11.00
Произведение: 35.14
*/

function isEvenTwoDigit(number) {
    // Проверка, что число целое положительное
    if (!Number.isInteger(number) || number <= 0) {
        console.log("Ошибка: число должно быть целым положительным");
        return false;
    }

    // Проверяем, что число двузначное (от 10 до 99 включительно)
    const isTwoDigit = number >= 10 && number <= 99;
    
    // Проверяем, что число четное
    const isEven = number % 2 === 0;

    // Проверяем оба условия
    const result = isTwoDigit && isEven;
    
    return result;
}

// Примеры использования:
console.log(isEvenTwoDigit(10));   // true (четное двузначное)
console.log(isEvenTwoDigit(25));   // false (нечетное двузначное)
console.log(isEvenTwoDigit(98));   // true (четное двузначное)
console.log(isEvenTwoDigit(5));    // false (однозначное)
console.log(isEvenTwoDigit(100));  // false (трехзначное)
console.log(isEvenTwoDigit(0));    // false (не положительное)
console.log(isEvenTwoDigit(-12));  // false (отрицательное)
console.log(isEvenTwoDigit(12.5)); // false (не целое)

function determineQuadrant(x, y) {
    // Проверка, что координаты являются числами
    if (typeof x !== 'number' || typeof y !== 'number' || isNaN(x) || isNaN(y)) {
        console.log("Ошибка: координаты должны быть числами");
        return;
    }

    // Проверка, что точка не лежит на осях координат
    if (x === 0 || y === 0) {
        console.log("Ошибка: точка не должна лежать на координатных осях");
        console.log(`Точка (${x}, ${y}) лежит на ${x === 0 ? 'оси OY' : 'оси OX'}`);
        return;
    }

    let quadrant;
    
    // Определение координатной четверти
    if (x > 0 && y > 0) {
        quadrant = 1;
    } else if (x < 0 && y > 0) {
        quadrant = 2;
    } else if (x < 0 && y < 0) {
        quadrant = 3;
    } else if (x > 0 && y < 0) {
        quadrant = 4;
    }

    console.log(`Точка с координатами: (${x}, ${y})`);
    console.log(`Находится в ${quadrant}-й координатной четверти`);
    
    return quadrant;
}

// Примеры использования:
determineQuadrant(3, 4);
/*
Точка с координатами: (3, 4)
Находится в 1-й координатной четверти
*/

determineQuadrant(-2, 5);
/*
Точка с координатами: (-2, 5)
Находится в 2-й координатной четверти
*/

determineQuadrant(-3, -2);
/*
Точка с координатами: (-3, -2)
Находится в 3-й координатной четверти
*/

determineQuadrant(4, -1);
/*
Точка с координатами: (4, -1)
Находится в 4-й координатной четверти
*/

determineQuadrant(0, 5);
/*
Ошибка: точка не должна лежать на координатных осях
Точка (0, 5) лежит на оси OY
*/

determineQuadrant(3, 0);
/*
Ошибка: точка не должна лежать на координатных осях
Точка (3, 0) лежит на оси OX
*/

function processNumbers(N, numbers) {
    // Проверка входных данных
    if (!Number.isInteger(N) || N <= 0) {
        console.log("Ошибка: N должно быть целым положительным числом");
        return;
    }
    
    if (!Array.isArray(numbers) || numbers.length !== N) {
        console.log(`Ошибка: необходимо предоставить массив из ${N} чисел`);
        return;
    }
    
    // Проверка, что все элементы - положительные числа
    for (let i = 0; i < numbers.length; i++) {
        if (typeof numbers[i] !== 'number' || isNaN(numbers[i]) || numbers[i] <= 0) {
            console.log(`Ошибка: элемент с индексом ${i} не является положительным числом`);
            return;
        }
    }

    // Массив для хранения целых частей
    let integerParts = [];
    let sum = 0;
    
    // Вычисление целых частей и их суммы
    for (let i = 0; i < numbers.length; i++) {
        const integerPart = Math.floor(numbers[i]); // целая часть числа
        integerParts.push(integerPart);
        sum += integerPart;
    }
    
    // Вывод результатов
    console.log(`N = ${N}`);
    console.log(`Исходные числа: [${numbers.join(', ')}]`);
    console.log(`Целые части: [${integerParts.join(', ')}]`);
    console.log(`Сумма целых частей: ${sum}`);
    
    return { integerParts, sum };
}

// Примеры использования:
processNumbers(5, [3.14, 2.71, 5.99, 1.01, 4.5]);
/*
N = 5
Исходные числа: [3.14, 2.71, 5.99, 1.01, 4.5]
Целые части: [3, 2, 5, 1, 4]
Сумма целых частей: 15
*/

processNumbers(4, [10.9, 7.3, 0.5, 12.1]);
/*
N = 4
Исходные числа: [10.9, 7.3, 0.5, 12.1]
Целые части: [10, 7, 0, 12]
Сумма целых частей: 29
*/

processNumbers(3, [2.0, 8.0, 5.0]);
/*
N = 3
Исходные числа: [2, 8, 5]
Целые части: [2, 8, 5]
Сумма целых частей: 15
*/