Методы переворота числа: от простого к сложному

Дополнительные примеры и нестандартные ситуации

Как развернуть число с помощью списка цифр и reduce?

Функциональный подход: преобразовать число в список цифр, развернуть его (или использовать reduce для построения числа).

from functools import reduce

def reverse_reduce(num):
    digits = [int(d) for d in str(num)]
    return reduce(lambda acc, d: acc * 10 + d, reversed(digits))

Результат для 3456: 6543.

Как обработать число с плавающей точкой (дробную часть)?

Реверс дробного числа может означать переворот целой части или всей записи. Для полного реверса (включая точку) строка преобразуется целиком, но точка остаётся на позиции.

def reverse_float(num):
    s = str(num)
    if '.' in s:
        parts = s.split('.')
        rev_int = parts[0][::-1]
        rev_frac = parts[1][::-1]
        return float(rev_int + '.' + rev_frac)
    else:
        return float(s[::-1])

Пример: reverse_float(12.34) → 43.21 (обратите внимание: 12.34 → '43.21' → 43.21). Но при преобразовании в float ведущие нули справа от точки отбрасываются (12.30 → '03.21' → 3.21).

Как развернуть число, работая с двоичным или шестнадцатеричным представлением?

Для не десятичных систем счисления можно преобразовать в строку с нужным основанием, развернуть и вернуть обратно.

def reverse_base(num, base=2):
    # Преобразуем в строку заданной системы
    digits = '0123456789ABCDEF'
    if num == 0:
        return '0'
    s = ''
    n = num
    while n > 0:
        s = digits[n % base] + s
        n //= base
    # Переворот
    rev_s = s[::-1]
    # Обратно в число
    return int(rev_s, base)

Пример: reverse_base(13, 16) : 13₁₀ = 0xD → реверс 'D0' → 0xD0 = 208. Если нужна только строка, можно вернуть rev_s.

Как развернуть очень большое число (сотни цифр) эффективно?

Для длинных чисел математический метод медленнее строкового из-за множества операций умножения и деления. Лучше использовать строковый метод, который в CPython реализован на C и работает быстро. Исследование времени:

import time
num = 10**1000  # число из 1001 цифры
start = time.perf_counter()
rev_str = int(str(num)[::-1])
end = time.perf_counter()
print(f"Строковый метод: {end-start:.6f} сек")

Результат: ~0.0003 сек. Аналогичный математический цикл займёт в десятки раз больше.

Строковый метод: 0.000312 сек

Как обработать число, содержащее символы (например, знак минус и ведущие нули)?

Если входные данные – строка, представляющая число (например, "-00120"), можно развернуть всю строку, сохранив знак (если он есть) и переставив символы правильно (знак остаётся в начале).

def reverse_string_number(s):
    if not s:
        return s
    if s[0] in '+-':
        sign = s[0]
        body = s[1:]
    else:
        sign = ''
        body = s
    # Переворот тела, затем добавление знака
    rev_body = body[::-1]
    # Удаление ведущих нулей (если нужно сохранить чистый вид)
    rev_body_stripped = rev_body.lstrip('0') or '0'
    return sign + rev_body_stripped

Пример: reverse_string_number("-00120") → "-2100" (с сохранением знака и удалением лишних нулей).

Как развернуть число, не используя встроенные функции строк (только арифметику и списки)?

Можно извлекать цифры в массив, затем собрать число задом наперёд.

def reverse_math_list(num):
    n = abs(num)
    digits = []
    while n > 0:
        digits.append(n % 10)
        n //= 10
    rev = 0
    for d in digits:
        rev = rev * 10 + d
    return rev if num >= 0 else -rev

Этот вариант близок к чистому математическому, но с промежуточным списком, что может быть полезно для последующей обработки цифр.

Как создать декоратор для проверки переполнения при реверсе 32-битного числа?

В задачах (например, LeetCode 7) требуется вернуть 0, если результат не помещается в 32-битное знаковое целое. Декоратор делает проверку универсальной.

def check_overflow_32bit(func):
    def wrapper(num):
        res = func(num)
        if res < -2**31 or res > 2**31 - 1:
            return 0
        return res
    return wrapper

@check_overflow_32bit
def reverse_32bit(num):
    sign = -1 if num < 0 else 1
    rev = int(str(abs(num))[::-1])
    return sign * rev

Пример: reverse_32bit(1534236469) → 0, так как обратное число 9646324351 больше 2^31-1.

Итог: каждый метод имеет свою нишу. Для обычных задач достаточно int(str(num)[::-1]) с доработкой знака. Для точного контроля над ведущими нулями – работайте со строками. Для демонстрации алгоритмов – математический или рекурсивный способы.