Разворот числа

Разворот числа

Развернуть число — это перевернуть порядок его цифр. Например, 12345 становится 54321, а -123 становится -321 (знак остаётся на месте).

Решение 1: Использование строк

def reverse_number(n):
    """Разворот числа через преобразование в строку."""
    # Обработка отрицательных чисел
    sign = -1 if n < 0 else 1
    n = abs(n)
    
    # Преобразуем в строку, разворачиваем, преобразуем обратно
    reversed_n = int(str(n)[::-1])
    
    return sign * reversed_n

# Тесты
print(reverse_number(12345))   # 54321
print(reverse_number(-123))    # -321
print(reverse_number(100))     # 1 (ведущие нули отпадают)
print(reverse_number(0))       # 0
print(reverse_number(-1))      # -1

Решение 2: Математический подход (без строк)

def reverse_number_math(n):
    """Разворот числа через математические операции."""
    sign = -1 if n < 0 else 1
    n = abs(n)
    
    result = 0
    while n > 0:
        digit = n % 10  # Извлекаем последнюю цифру
        result = result * 10 + digit  # Добавляем цифру в результат
        n //= 10  # Убираем последнюю цифру
    
    return sign * result

# Тесты
print(reverse_number_math(12345))   # 54321
print(reverse_number_math(-123))    # -321
print(reverse_number_math(100))     # 1
print(reverse_number_math(0))       # 0

Решение 3: С проверкой переполнения (для интервью)

def reverse_number_safe(n, min_val=-2**31, max_val=2**31 - 1):
    """Разворот числа с проверкой на переполнение.
    
    В некоторых задачах нужно вернуть 0 если результат
    выходит за пределы диапазона целых чисел.
    """
    sign = -1 if n < 0 else 1
    n = abs(n)
    
    result = 0
    while n > 0:
        digit = n % 10
        
        # Проверка переполнения перед добавлением цифры
        if result > max_val // 10 or (result == max_val // 10 and digit > 7):
            return 0
        
        result = result * 10 + digit
        n //= 10
    
    final_result = sign * result
    
    # Финальная проверка
    if final_result < min_val or final_result > max_val:
        return 0
    
    return final_result

# Тесты
print(reverse_number_safe(12345))   # 54321
print(reverse_number_safe(-123))    # -321
print(reverse_number_safe(2147483647))  # 0 (переполнение)

Сравнение подходов

# Способ 1: Строковый (самый простой)
def reverse_str(n):
    return int(str(abs(n))[::-1]) * (1 if n >= 0 else -1)

# Способ 2: Математический (более трудозатратный)
def reverse_math(n):
    sign = 1 if n >= 0 else -1
    n = abs(n)
    result = 0
    while n:
        result = result * 10 + n % 10
        n //= 10
    return sign * result

# Тесты обоих методов
test_cases = [12345, -123, 100, 0, -1, 1, 999]

for test in test_cases:
    str_result = reverse_str(test)
    math_result = reverse_math(test)
    assert str_result == math_result, f"Ошибка для {test}"
    print(f"reverse({test}) = {str_result}")

Пошаговый пример (математический метод)

# Разбор алгоритма для числа 123
n = 123
result = 0

print("Шаг 1:")
digit = 123 % 10  # 3
result = 0 * 10 + 3  # 3
n = 123 // 10  # 12
print(f"  digit={digit}, result={result}, n={n}")

print("Шаг 2:")
digit = 12 % 10  # 2
result = 3 * 10 + 2  # 32
n = 12 // 10  # 1
print(f"  digit={digit}, result={result}, n={n}")

print("Шаг 3:")
digit = 1 % 10  # 1
result = 32 * 10 + 1  # 321
n = 1 // 10  # 0
print(f"  digit={digit}, result={result}, n={n}")

print(f"\nИтоговый результат: {result}")

Граничные случаи

# Проверка граничных случаев
def test_reverse():
    test_cases = [
        (12345, 54321),
        (-123, -321),
        (100, 1),         # Ведущие нули отпадают
        (0, 0),           # Ноль
        (-1, -1),         # Отрицательное число
        (1, 1),           # Одна цифра
        (-1000, -1),      # Отрицательное с нулями
        (1534236469, 9646324351),  # Большое число
    ]
    
    for input_val, expected in test_cases:
        # Используем строковый метод
        result = int(str(abs(input_val))[::-1]) * (1 if input_val >= 0 else -1)
        assert result == expected, f"Ошибка: reverse({input_val}) = {result}, ожидается {expected}"
        print(f"✓ reverse({input_val}) = {result}")
    
    print("\nВсе тесты пройдены!")

test_reverse()

Рекомендации для интервью

1. Сначала уточняйте:

   • Как обращаться с отрицательными числами?
   • Нужна ли проверка переполнения?
   • Какие граничные случаи рассмотреть?

2. Решение:

   • Начните с простого строкового подхода
   • Объясните, почему он работает
   • Если интервьюер просит, покажите математический способ

3. Оптимизация:

   • Временная сложность: O(log n) — количество цифр
   • Пространственная сложность: O(1) — математический метод без дополнительной памяти

Строковый способ проще и понятнее, математический способ показывает глубокое понимание алгоритмов.