Подсчет цифр в числе

Решение: Подсчет цифр в числе

Описание задачи

Требуется реализовать метод для определения количества цифр в заданном числе (count digits). Эта операция часто используется в обработке числовых данных, валидации формата чисел, работе с логирование и тестировании обработки числовых входных данных. Задача может показаться простой, но требует аккуратной обработки граничных случаев: отрицательные числа, ноль, очень большие числа.

Решение на Python

def count_digits(n):
    """
    Подсчитывает количество цифр в числе.
    
    Args:
        n: целое число (может быть положительным, отрицательным или нулём)
    
    Returns:
        количество цифр в числе (без учёта знака минус)
    """
    # Преобразуем число в строку и удаляем минус
    return len(str(abs(n)))

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

1. Математический подход с логарифмом

import math

def count_digits_math(n):
    """
    Использует математическую формулу с логарифмом.
    Работает только для положительных чисел!
    """
    if n == 0:
        return 1
    
    if n < 0:
        n = -n
    
    # Формула: количество цифр = floor(log10(n)) + 1
    return int(math.log10(n)) + 1

2. Итеративный подход с делением

def count_digits_iterative(n):
    """
    Подсчитывает цифры делением на 10.
    Более низкоуровневый подход.
    """
    if n == 0:
        return 1
    
    # Работаем с абсолютным значением
    n = abs(n)
    count = 0
    
    while n > 0:
        count += 1
        n //= 10
    
    return count

3. С использованием рекурсии

def count_digits_recursive(n):
    """
    Рекурсивный подход к подсчёту цифр.
    """
    if n == 0:
        return 1
    
    n = abs(n)
    
    def count_recursive_helper(num):
        if num < 10:
            return 1
        return 1 + count_recursive_helper(num // 10)
    
    return count_recursive_helper(n)

4. С использованием битовых операций (для двоичного представления)

def count_digits_binary(n):
    """
    Подсчитывает цифры в двоичном представлении.
    Показывает альтернативный подход.
    """
    if n == 0:
        return 1
    
    n = abs(n)
    binary_str = bin(n)[2:]  # Удаляем '0b'
    return len(binary_str)

5. С детальным анализом

def count_digits_detailed(n):
    """
    Возвращает не только количество цифр,
    но и другую информацию о числе.
    """
    if n == 0:
        return {'count': 1, 'value': n, 'is_negative': False}
    
    is_negative = n < 0
    n = abs(n)
    count = len(str(n))
    
    return {
        'count': count,
        'value': n,
        'is_negative': is_negative,
        'first_digit': int(str(n)[0]),
        'last_digit': n % 10
    }

Тестовые примеры

import unittest

class TestCountDigits(unittest.TestCase):
    
    def test_basic_case_1(self):
        # Первый базовый случай из условия
        assert count_digits(12345) == 5
    
    def test_basic_case_2(self):
        # Второй базовый случай из условия
        assert count_digits(100) == 3
    
    def test_zero(self):
        # Ноль имеет одну цифру
        assert count_digits(0) == 1
    
    def test_single_digit(self):
        # Однозначное число
        assert count_digits(5) == 1
    
    def test_two_digits(self):
        # Двузначное число
        assert count_digits(42) == 2
    
    def test_negative_single_digit(self):
        # Отрицательное однозначное число
        assert count_digits(-7) == 1
    
    def test_negative_multiple_digits(self):
        # Отрицательное многозначное число
        assert count_digits(-12345) == 5
    
    def test_large_number(self):
        # Очень большое число
        assert count_digits(123456789) == 9
    
    def test_very_large_number(self):
        # Экстремально большое число
        big_num = 10**100  # Число с 101 цифрой
        assert count_digits(big_num) == 101
    
    def test_power_of_ten(self):
        # Степени числа 10
        assert count_digits(10) == 2
        assert count_digits(100) == 3
        assert count_digits(1000) == 4
    
    def test_negative_zero(self):
        # В Python -0 == 0
        assert count_digits(-0) == 1
    
    def test_all_nines(self):
        # Числа из всех девяток
        assert count_digits(9) == 1
        assert count_digits(99) == 2
        assert count_digits(999) == 3
        assert count_digits(9999) == 4

# Тестирование производительности
class TestCountDigitsPerformance(unittest.TestCase):
    
    def test_all_methods_match(self):
        # Все методы должны давать одинаковые результаты
        test_values = [0, 1, 10, 100, 1000, 12345, -12345, 999999, 10**10]
        
        for val in test_values:
            result1 = count_digits(val)
            result2 = count_digits_iterative(val)
            result3 = count_digits_recursive(val)
            
            assert result1 == result2 == result3, f'Мismatch for {val}'

Анализ сложности

*В Python строковое преобразование быстрее всех потому что это оптимизированная операция

Применение в QA Automation

• Валидация форматов — проверка, что числа имеют правильное количество цифр
• Обработка данных — работа с PIN кодами, телефонными номерами, постальными кодами
• Граничные случаи — ноль, отрицательные числа, очень большие числа
• Тестирование обработки чисел — проверка корректности работы с различными форматами
• Генерация тестовых данных — автоматическое создание чисел с определённым количеством цифр

Основные граничные случаи

# Важные edge cases для тестирования:
- count_digits(0) == 1          # Ноль имеет 1 цифру
- count_digits(-5) == 1         # Отрицательные игнорируют знак
- count_digits(10**n) == n + 1  # Степени 10
- count_digits(-0) == 1         # В Python -0 это 0

Рекомендация

Для стандартного использования в QA рекомендуется подход со строкой — он самый понятный, читаемый и быстрый в Python. Для интервью и демонстрации алгоритмического мышления используйте итеративное деление на 10, так как оно показывает понимание работы с числами. Математический подход с логарифмом более сложный и требует обработки исключений, поэтому менее рекомендуется для практического использования.