❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Дана площадь S круга. Найти его диаметр D и длину L окружности, ограничивающей этот круг, учитывая, что L = π*D, S = π*(D^2)/4. В качестве значения π использовать 3.14

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function calculateFromArea(S) {
    const π = 3.14;
    
    // Проверка на положительную площадь
    if (S <= 0) {
        console.log("Ошибка: площадь круга должна быть положительным числом");
        return;
    }

    // Вычисление диаметра из формулы площади: S = π*(D²)/4
    // D² = (4*S)/π
    // D = √((4*S)/π)
    const D = Math.sqrt((4 * S) / π);
    
    // Вычисление длины окружности: L = π*D
    const L = π * D;

    // Вывод результатов с округлением до 2 знаков после запятой
    console.log(`Для круга площадью S = ${S}:`);
    console.log(`Диаметр D = √(4S/π) = ${D.toFixed(2)}`);
    console.log(`Длина окружности L = πD = ${L.toFixed(2)}`);
}

// Примеры использования:
calculateFromArea(78.5);
/*
Для круга площадью S = 78.5:
Диаметр D = √(4S/π) = 10.00
Длина окружности L = πD = 31.40
*/

calculateFromArea(314);
/*
Для круга площадью S = 314:
Диаметр D = √(4S/π) = 20.00
Длина окружности L = πD = 62.80
*/

calculateFromArea(12.56);
/*
Для круга площадью S = 12.56:
Диаметр D = √(4S/π) = 4.00
Длина окружности L = πD = 12.56
*/

calculateFromArea(0); // Ошибка: площадь круга должна быть положительным числом

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Дано трехзначное число. В нем зачеркнули первую слева цифру и приписали ее справа. Вывести полученное число

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function rotateThreeDigitNumber(number) {
    // Проверка, что число трёхзначное
    if (number < 100 || number > 999) {
        console.log("Ошибка: введите трёхзначное число (100-999)");
        return;
    }

    // Получаем цифры числа
    const hundreds = Math.floor(number / 100);     // первая цифра (сотни)
    const tens = Math.floor((number % 100) / 10); // вторая цифра (десятки)
    const units = number % 10;                    // третья цифра (единицы)

    // Формируем новое число: зачеркиваем первую цифру и приписываем её справа
    const newNumber = tens * 100 + units * 10 + hundreds;

    // Выводим результат
    console.log(`Исходное число: ${number}`);
    console.log(`Цифры: ${hundreds}, ${tens}, ${units}`);
    console.log(`Новое число: ${newNumber}`);
}

// Примеры использования:
rotateThreeDigitNumber(123);
/*
Исходное число: 123
Цифры: 1, 2, 3
Новое число: 231
*/

rotateThreeDigitNumber(456);
/*
Исходное число: 456
Цифры: 4, 5, 6
Новое число: 564
*/

rotateThreeDigitNumber(780);
/*
Исходное число: 780
Цифры: 7, 8, 0
Новое число: 807
*/

rotateThreeDigitNumber(999);
/*
Исходное число: 999
Цифры: 9, 9, 9
Новое число: 999
*/

rotateThreeDigitNumber(50); // Ошибка: введите трёхзначное число (100-999)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Дана строка. Если она представляет собой запись целого числа, то вывести 1, если вещественного (с дробной частью) — вывести 2; если строку нельзя преобразовать в число, то вывести 0. Считать, что дробная часть вещественного числа отделяется от его целой части десятичной точкой «.»

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function checkNumberType(str) {
    // Проверка на пустую строку или строку только из точки
    if (str === '' || str === '.') {
        return 0;
    }

    // Проверка на целое число
    if (/^-?\d+$/.test(str)) {
        return 1;
    }

    // Проверка на вещественное число
    if (/^-?\d+\.\d+$/.test(str)) {
        return 2;
    }

    // Проверка на вещественное число, начинающееся с точки
    if (/^-?\.\d+$/.test(str)) {
        return 2;
    }

    // Если не подходит ни под один шаблон
    return 0;
}

// Примеры использования:
console.log(checkNumberType("123"));     // 1 (целое)
console.log(checkNumberType("-456"));    // 1 (целое отрицательное)
console.log(checkNumberType("3.14"));    // 2 (вещественное)
console.log(checkNumberType("-2.5"));    // 2 (вещественное отрицательное)
console.log(checkNumberType(".75"));     // 2 (вещественное без целой части)
console.log(checkNumberType("abc"));     // 0 (не число)
console.log(checkNumberType("12.3.4"));  // 0 (не число)
console.log(checkNumberType("12a"));     // 0 (не число)
console.log(checkNumberType(""));        // 0 (пустая строка)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Найти расстояние между двумя точками с заданными координатами x1 и x2 на числовой оси: |x2 – x1|

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function calculateDistanceWithDetails(x1, x2) {
    const distance = Math.abs(x2 - x1);
    
    console.log(`Точка 1: x1 = ${x1}`);
    console.log(`Точка 2: x2 = ${x2}`);
    console.log(`Расстояние: |x2 - x1| = |${x2} - ${x1}| = ${distance}`);
    
    return distance;
}

// Примеры использования:
calculateDistanceWithDetails(5, 10);
/*
Точка 1: x1 = 5
Точка 2: x2 = 10
Расстояние: |x2 - x1| = |10 - 5| = 5
*/

calculateDistanceWithDetails(-3, 7);
/*
Точка 1: x1 = -3
Точка 2: x2 = 7
Расстояние: |x2 - x1| = |7 - (-3)| = 10
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Дано трехзначное число. В нем зачеркнули первую справа цифру и приписали ее слева. Вывести полученное число.

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function rotateRightToLeft(number) {
    // Проверка, что число трёхзначное
    if (number < 100 || number > 999) {
        console.log("Ошибка: введите трёхзначное число (100-999)");
        return;
    }

    // Получаем цифры числа
    const hundreds = Math.floor(number / 100);     // первая цифра (сотни)
    const tens = Math.floor((number % 100) / 10); // вторая цифра (десятки)
    const units = number % 10;                    // третья цифра (единицы)

    // Формируем новое число: зачеркиваем последнюю цифру и приписываем её слева
    const newNumber = units * 100 + hundreds * 10 + tens;

    // Выводим результат
    console.log(`Исходное число: ${number}`);
    console.log(`Цифры: ${hundreds}, ${tens}, ${units}`);
    console.log(`Новое число: ${newNumber}`);
}

// Примеры использования:
rotateRightToLeft(123);
/*
Исходное число: 123
Цифры: 1, 2, 3
Новое число: 312
*/

rotateRightToLeft(456);
/*
Исходное число: 456
Цифры: 4, 5, 6
Новое число: 645
*/

rotateRightToLeft(780);
/*
Исходное число: 780
Цифры: 7, 8, 0
Новое число: 78
*/

rotateRightToLeft(999);
/*
Исходное число: 999
Цифры: 9, 9, 9
Новое число: 999
*/

rotateRightToLeft(50); // Ошибка: введите трёхзначное число (100-999)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны два целых числа: A, B. Проверить истинность высказывания: «Числа A и B имеют одинаковую четность»

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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

    // Проверяем одинаковую четность
    // Оба числа четные или оба нечетные
    const result = (A % 2 === 0 && B % 2 === 0) || (A % 2 !== 0 && B % 2 !== 0);
    
    return result;
}

// Примеры использования:
console.log(checkSameParity(4, 8));   // true (оба четные)
console.log(checkSameParity(3, 7));   // true (оба нечетные)
console.log(checkSameParity(4, 7));   // false (разная четность)
console.log(checkSameParity(2, 5));   // false (разная четность)
console.log(checkSameParity(0, 6));   // true (оба четные)
console.log(checkSameParity(-3, -5)); // true (оба нечетные)
console.log(checkSameParity(-4, 3));  // false (разная четность)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны две переменные целого типа: A и B. Если их значения не равны, то присвоить каждой переменной большее из этих значений, а если равны, то присвоить переменным нулевые значения. Вывести новые значения переменных A и B

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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

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

    // Проверяем равенство значений
    if (A !== B) {
        // Если значения не равны, находим максимальное
        const maxValue = Math.max(A, B);
        A = maxValue;
        B = maxValue;
        console.log("Значения не равны - присваиваем максимальное значение");
    } else {
        // Если значения равны, присваиваем нули
        A = 0;
        B = 0;
        console.log("Значения равны - присваиваем нулевые значения");
    }

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

// Примеры использования:
updateVariables(5, 3);
/*
Исходные значения: A = 5, B = 3
Значения не равны - присваиваем максимальное значение
Новые значения: A = 5, B = 5
*/

updateVariables(2, 7);
/*
Исходные значения: A = 2, B = 7
Значения не равны - присваиваем максимальное значение
Новые значения: A = 7, B = 7
*/

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

updateVariables(-3, -1);
/*
Исходные значения: A = -3, B = -1
Значения не равны - присваиваем максимальное значение
Новые значения: A = -1, B = -1
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны положительные числа A и B (A > B). На отрезке длины A размещено максимально возможное количество отрезков длины B (без наложений). Не используя операции умножения и деления, найти количество отрезков B, размещенных на отрезке A

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

function countSegments(A, B) {
    // Проверка условий задачи
    if (A <= 0 || B <= 0) {
        console.log("Ошибка: числа должны быть положительными");
        return;
    }
    if (A <= B) {
        console.log("Ошибка: A должно быть больше B");
        return;
    }

    let count = 0;
    let currentLength = 0;

    // Пока можем добавить еще один отрезок B без превышения длины A
    while (currentLength + B <= A) {
        currentLength += B;
        count++;
    }

    console.log(`На отрезке длины A = ${A}`);
    console.log(`Размещено отрезков длины B = ${B}: ${count}`);
    return count;
}

// Примеры использования:
countSegments(10, 3);
/*
На отрезке длины A = 10
Размещено отрезков длины B = 3: 3
*/

countSegments(15, 4);
/*
На отрезке длины A = 15
Размещено отрезков длины B = 4: 3
*/

countSegments(20, 6);
/*
На отрезке длины A = 20
Размещено отрезков длины B = 6: 3
*/

countSegments(8, 2);
/*
На отрезке длины A = 8
Размещено отрезков длины B = 2: 4
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны три целых числа: A, B, C. Проверить истинность высказывания: «Каждое из чисел A, B, C положительное»

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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

    const AIsPositive = A > 0;
    const BIsPositive = B > 0;
    const CIsPositive = C > 0;
    const result = AIsPositive && BIsPositive && CIsPositive;

    console.log(`A = ${A}, положительное: ${AIsPositive}`);
    console.log(`B = ${B}, положительное: ${BIsPositive}`);
    console.log(`C = ${C}, положительное: ${CIsPositive}`);
    console.log(`Все числа A, B, C положительные: ${result}`);

    return result;
}

// Примеры использования:
checkAllPositiveDetailed(5, 3, 8);
/*
A = 5, положительное: true
B = 3, положительное: true
C = 8, положительное: true
Все числа A, B, C положительные: true
*/

checkAllPositiveDetailed(4, -2, 7);
/*
A = 4, положительное: true
B = -2, положительное: false
C = 7, положительное: true
Все числа A, B, C положительные: false
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны три числа. Вывести вначале наименьшее, а затем наибольшее из данных чисел

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны целые положительные числа N и K. Используя только операции сложения и вычитания, найти частное от деления нацело N на K , а также остаток от этого деления

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны три целых числа: A, B, C. Проверить истинность высказывания: «Хотя бы одно из чисел A, B, C положительное»

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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 (все отрицательные)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны три переменные вещественного типа: A, B, C . Если их значения упорядочены по возрастанию или убыванию, то удвоить их; в противном случае заменить значение каждой переменной на противоположное. Вывести новые значения переменных A, B, C

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Дано целое число N (> 0), являющееся некоторой степенью числа 2: N = 2^K. Найти целое число K — показатель этой степени

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Даны три целых числа: A, B, C. Проверить истинность высказывания: «Ровно одно из чисел A, B, C положительное».

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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 положительное)

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: На числовой оси расположены три точки: A, B, C. Определить, какая из двух последних точек (B или C) расположена ближе к A, и вывести эту точку и ее расстояние от точки A.

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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
*/

❗️ Ответ сгенерирован чат-ботом DeepSeek

⚙️ Запрос: Напиши программу на языке JavaScript которая будет решать задачу: Дано целое число N (> 0). Найти наименьшее целое положительное число K, квадрат которого превосходит N: K^2 > N. Функцию извлечения квадратного корня не использовать.

✔️ Задание: попробовать запустить этот код, проверить всё ли корректно работает, если нет исправить ошибки. При желании предложить свой вариант кода. Практикуемся в современных реалиях.

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)
*/