Наибольшая и наименьшая цифра числа

сетка с цифрами, нарисованная мелом на земле

К чему стремится эта статья

В статье показаны простые и надёжные способы найти наибольшую и наименьшую цифру заданного целого числа. Примеры кода приведены для C++, Python, JavaScript, C и Java. Также обсуждены альтернативные подходы, типичные ошибки и критерии приёмки.

Задача

Дано целое число num. Нужно найти и вывести наибольшую и наименьшую цифру в num.

Примеры

num = 238627 → наибольшая цифра 8, наименьшая 2
num = 34552 → наибольшая цифра 5, наименьшая 2
num = 123 → наибольшая цифра 3, наименьшая 1

Общая идея (ментальная модель)

Если число отрицательное, берём его абсолютное значение.
Инициализируем largest = 0, smallest = 9.
Пока число > 0: извлекаем последнюю цифру digit = num % 10, обновляем largest и smallest, затем num = num / 10.
Учёт нуля: если исходное число == 0, оба результата — 0.

Важно: метод работает только для целых чисел без дробной части. Для строк с символами нужно фильтровать цифры.

C++ — итеративный способ (с учётом отрицательных чисел)

// C++ program to find the largest and smallest
// digit of a number
#include 
using namespace std;

void findLargestSmallest(long long num) {
    if (num == 0) {
        cout << "Largest Digit: 0\n";
        cout << "Smallest Digit: 0\n";
        return;
    }
    num = llabs(num);
    int largestDigit = 0;
    int smallestDigit = 9;
    while (num > 0) {
        int digit = num % 10;
        largestDigit = max(digit, largestDigit);
        smallestDigit = min(digit, smallestDigit);
        num /= 10;
    }
    cout << "Largest Digit: " << largestDigit << endl;
    cout << "Smallest Digit: " << smallestDigit << endl;
}

int main() {
    long long nums[] = {238627, 34552, 123, 45672, 76567, 0, -907};
    for (long long n : nums) {
        cout << "num: " << n << endl;
        findLargestSmallest(n);
    }
    return 0;
}

Ожидаемый вывод (фрагмент):

num: 238627
Largest Digit: 8
Smallest Digit: 2
num: 0
Largest Digit: 0
Smallest Digit: 0
num: -907
Largest Digit: 9
Smallest Digit: 0

Python — два подхода: арифметический и строковый

Арифметический: работает везде и быстро; строковый — компактный и читаемый.

# Арифметический подход
def find_largest_smallest(num: int):
    if num == 0:
        print("Largest Digit:", 0)
        print("Smallest Digit:", 0)
        return
    num = abs(num)
    largest_digit = 0
    smallest_digit = 9
    while num:
        digit = num % 10
        largest_digit = max(digit, largest_digit)
        smallest_digit = min(digit, smallest_digit)
        num //= 10
    print("Largest Digit:", largest_digit)
    print("Smallest Digit:", smallest_digit)

# Строковый компактный вариант
def find_largest_smallest_str(num: int):
    s = str(abs(num))
    digits = [int(ch) for ch in s]
    print("Largest Digit:", max(digits))
    print("Smallest Digit:", min(digits))

# Примеры
for n in [238627, 34552, 123, 0, -907]:
    print("num:", n)
    find_largest_smallest(n)
    # или find_largest_smallest_str(n)

Совет: строковый вариант полезен, если вход может содержать нечисловые символы — предварительно фильтруйте ch.isdigit().

JavaScript — варианты для Node/браузера

// Арифметический подход
function findLargestSmallest(num) {
  if (num === 0) {
    console.log("Largest Digit: 0");
    console.log("Smallest Digit: 0");
    return;
  }
  num = Math.abs(num);
  let largest = 0;
  let smallest = 9;
  while (num > 0) {
    let digit = num % 10;
    largest = Math.max(digit, largest);
    smallest = Math.min(digit, smallest);
    num = Math.floor(num / 10);
  }
  console.log("Largest Digit:", largest);
  console.log("Smallest Digit:", smallest);
}

// Строковый способ
function findLargestSmallestStr(num) {
  const digits = String(Math.abs(num)).split("").map(d => Number(d));
  console.log("Largest Digit:", Math.max(...digits));
  console.log("Smallest Digit:", Math.min(...digits));
}

[238627, 34552, 123, 0, -907].forEach(n => { console.log('num:', n); findLargestSmallest(n); });

C — компактный и быстрый

// C program to find the largest and smallest
#include 
#include 

void findLargestSmallest(long long num) {
    if (num == 0) {
        printf("Largest Digit: 0\n");
        printf("Smallest Digit: 0\n");
        return;
    }
    if (num < 0) num = llabs(num);
    int largestDigit = 0;
    int smallestDigit = 9;
    while (num > 0) {
        int digit = num % 10;
        if (digit > largestDigit) largestDigit = digit;
        if (digit < smallestDigit) smallestDigit = digit;
        num /= 10;
    }
    printf("Largest Digit: %d\n", largestDigit);
    printf("Smallest Digit: %d\n", smallestDigit);
}

int main() {
    long long nums[] = {238627, 34552, 123, 0, -907};
    for (int i = 0; i < 5; ++i) {
        printf("num: %lld\n", nums[i]);
        findLargestSmallest(nums[i]);
    }
    return 0;
}

Java — строгий вариант

public class Main {
    static void findLargestSmallest(long num) {
        if (num == 0) {
            System.out.println("Largest Digit: 0");
            System.out.println("Smallest Digit: 0");
            return;
        }
        num = Math.abs(num);
        int largest = 0;
        int smallest = 9;
        while (num != 0) {
            int digit = (int)(num % 10);
            largest = Math.max(digit, largest);
            smallest = Math.min(digit, smallest);
            num /= 10;
        }
        System.out.println("Largest Digit: " + largest);
        System.out.println("Smallest Digit: " + smallest);
    }

    public static void main(String[] args) {
        long[] nums = {238627, 34552, 123, 0, -907};
        for (long n : nums) {
            System.out.println("num: " + n);
            findLargestSmallest(n);
        }
    }
}

Альтернативные подходы и когда они полезны

Строковый подход (преобразование числа в строку) проще и читабельнее. Подходит, когда вы уверены, что вход — корректное целое. Также удобен при работе с большими числами, которые не помещаются в стандартные целочисленные типы (требуется работа со строками/BigInt).
Арифметический подход более «низкоуровневый» и не создаёт дополнительных массивов символов — обычно быстрее и использует меньше памяти.

Когда метод не подойдёт:

Если число имеет дробную часть — сначала нужно определить, что считать цифрами (целой части, дробной или всей последовательности символов).
Для строк с нелатинскими или непредвиденными символами требуется фильтрация: оставляйте только ‘0’..’9’.

Сложность и оценка затрат (impact × effort)

Время: O(d), где d — количество цифр в числе (линейно по числу цифр).
Память: O(1) для арифметического способа; O(d) для строкового (создаётся строка/массив цифр).

Impact × Effort: высокий эффект за маленькое усилие — простая и полезная операция для вопросов собеседований и утилит.

Критерии приёмки

Для любых целых входов функция возвращает корректные наибольшую и наименьшую цифры.
Для 0 возвращает 0 и 0.
Отрицательные числа обрабатываются корректно (по модулю).
Для строкового варианта поведение определено: либо предварительная валидация, либо фильтрация цифр.

Типичные ошибки и ловушки

Игнорирование нуля: многие алгоритмы падают на num == 0.
Необработанные отрицательные значения: берите abs.
Преобразование флота (float/double) напрямую в int без явного решения о том, что считать цифрами.

Шпаргалка (cheat sheet)

Быстрое решение на Python: digits = list(map(int, str(abs(n)))) → max(digits), min(digits)
Арифметика: while n: digit = n % 10; n //= 10
Инициализации: largest = 0, smallest = 9

Резюме

Поиск наибольшей и наименьшей цифры в числе — простая задача с небольшим набором краевых случаев: ноль, отрицательные числа и некорректные входы. Выбор между арифметическим и строковым подходом зависит от требований к производительности и читабельности. Практикуйте оба, чтобы быстро решать её на интервью или в задачах на кодирование.

Важно: если вход может быть очень большим (выходящим за пределы стандартных типов), используйте строковый подход или BigInt-подобные типы.