Как найти сумму чисел в числе python

Сумма и произведение цифр числа в Python

Сложить или перемножить цифры числа — задача, встречающаяся почти каждому программисту. Она позволяет не только проверить умение писать код и придумывать правильные алгоритмы, но и даёт возможность оценить синтаксис и функционал используемого языка.

Сумма цифр

Реализация программы на разных языках программирования мало чем отличается. Но из-за концепций и особенностей синтаксиса решение на языке Python получается более коротким и простым, чем, например, решение на C++.

Полный код программы нахождения суммы цифр числа на Python выглядит так:

num = int(input("Введите целое: ")) sum = 0 while (num != 0): sum = sum + num % 10 num = num // 10 print("Сумма цифр числа равна: ", sum)

В первой строке программа запрашивает ввод числа, цифры которого будут складываться.

Во второй строке объявляется переменная, в которую будет записываться сумма. Переменная обязательна должна быть равна нулю. Иначе полученная сумма будет отличаться от реальной (некоторые люди путают сложение и произведение чисел, поэтому пишут не ноль, а единицу).

В цикле while происходит суммирование цифр. В 4 строке программа получает младший разряд числа. Например, если число равно 125, программа получает 5. Полученный младший разряд прибавляется к переменной суммы.

Строка 5: использованный младший разряд отбрасывается (делится на 10), то есть если было 125, то станет 12. Обязательно необходимо использовать целочисленное деление, то есть деление без остатка, иначе цифра не отбросится, а уйдет в дробную часть результата.

В 6 строке программа выводит результат суммирования в консоль. Пример выполнения:

Введите целое: 555 Сумма цифр числа равна: 15

В этом примере мы посчитали с помощью Python сумму цифр трёхзначного числа 555.

Произведение цифр

Программа на Python для вычисления произведения цифр числа имеет похожую структуру и принцип работы. Однако есть некоторые важные отличия:

num = int(input("Введите целое: ")) mult = 1 while (num != 0): mult = mult * (num % 10) num = num // 10 print("Произведение цифр равно: ", mult)

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

Важный момент, из-за того что оператор умножения имеет более высокий приоритет выполнения, чем оператор остатка от деления, выражение «num % 10» помещается в круглые скобки. Если не сделать этого, программа сначала будет умножать переменную mult на число и только потом брать от неё остаток.

Пример работы программы:

Введите целое: 55 Произведение цифр равно: 25

Частные случаи

Рассмотренные варианты программ являются самыми простыми. Однако существует ещё много частных случаев.

Число задано строкой

Когда программа получает ввод с помощью input, интерпретатор автоматически присваивает переменной строковый тип, если попытаться использовать эту переменную в вычислениях, возникнет ошибка.

В рассмотренных скриптах эта проблема была решена следующим образом:

num = int(input("Введите целое: "))

Оператор input помещается в функцию int, которая преобразует полученную строку к целому числу. В некоторых случаях бывает удобнее не преобразовывать число сразу, а сделать это непосредственно перед вычислением. Пример такого случая представлен ниже.

Задано дробное

Если пользователь вводит дробное число, стандартная реализация перестаёт работать. Дробная часть не учитывается, т.к. в программе происходит деление на 10. Даже если преобразовывать введенное число к целому с помощью int , то будут отброшены все дробные цифры.

Рассмотрим программу для вычисления произведения цифр дробного числа (аналогично с суммой):

num = input("Введите дробное: ") # разделим введённое (тип данных строка) на две части x = num.split(".") a = int(x[0]) # целая часть b = int(x[1]) # дробная часть mult = 1 while (a != 0): # перемножаем числа целой части mult = mult * (a % 10) a = a // 10 while (b != 0): # перемножаем числа дробной части mult = mult * (b % 10) b = b // 10 print("Произведение цифр равно:", mult)

Пример выполнения программы:

Введите дробное: 55.5 Произведение цифр равно: 125

Эта программа правильно вычисляет произведение цифр любого числа:

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

При приведении к действительному

Подход, описанный выше выбран потому, что из-за неточного представления десятичных дробей в двоичном виде (в котором работает компьютер), реальное представление числа отличается от ожидаемого. В итоге, если пользователь вводит число 0.55, то если привести её к действительному числу с помощью float , в переменную записывается значение 0.54999…8. В итоге, результат получается неточным, если ограничить количество итераций цикла, либо цикл является бесконечным, пример:

num = float(input("Введите дробное: ")) # Преобразуем строку в дробное a = int(num) # целая часть, например, 5 b = num - int(num) # дробная часть, например, 0.55 print("a =", a) print("b =", b) mult = 1 while (a != 0): # перемножаем числа целой части mult = mult * (a % 10) a = a // 10 while (b != 0): # b никогда не будет равно 0 mult = mult * int(b*10) # 0.55 * 10 = 5.5, int(5.5) = 5 b = b * 10 - int(b * 10) print("Произведение цифр равно:", mult)

Если бы в переменной реально было бы записано значение 5.55, то программа работала бы нормально. Однако в переменную b на самом деле помещается 0,54999… Это приводит к бесконечному выделению и отбрасыванию старшего разряда.

Вот пример вывода полученной программы:

Введите дробное: 5.55 a = 5 b = 0.5499999999999998 Произведение цифр равно: 0

Программа вывела переменную b , как 0.5499999999999998, после умножения на 10, её значение уже будет равно 5.499999999999998. Если вычесть из этого числа 5, то получим 0.4999999999999982. На конце добавилась цифра 2!

Таким образом прошло много итераций и в итоге b стало равно 0. В ходе перемножений среди цифр из которых состояло b были и нули. Поэтому результат равен 0.

Python: сумма цифр в числе (1)

Это первая из трех статей, посвященная разбору одной интересной задачки из курса Stepik. Как обычно условие приведено на английском языке: По условию требуется найти все положительные целые числа меньше заданного N, в которых сумма цифр будет равняться сумме цифр числа N, и вывести количество таких чисел. Например, если дано число 123 (сумма цифр равна 6), то числами удовлетворяющими условию будут: 6, 15, 24, 33, 42, 51, 60, 105 и 114. То есть всего 9 чисел. Правильным ответом будет: 9 . Задача кажется сложной и запутанной, но давайте решать ее по частям. Для начала разберемся, как посчитать сумму цифр в заданном числе. Но не просто разберемся, а напишем три разных реализации и сравним их по скорости. Заготовка для функции с тестами будет выглядеть таким образом:

def digits_sum_v1(number: int) -> int: 
return 0

assert digits_sum_v1(2) == 2
assert digits_sum_v1(123) == 6
assert digits_sum_v1(99) == 18
assert digits_sum_v1(5381) == 17

Первое напрашивающееся решение — это преобразование числа к стороковому представлению и разбора получившейся строки посимвольно. Для преобразования строки в число в Python есть метод int() , а для обратного преобразования — str() .

def digits_sum_v1(number: int) -> int: 
res = 0 
for c in str(number): 
res += int(c) 
return res

Обратите внимание, что Python позволяет итерироваться по строке как по массиву с помощью цикла for c in str(number) , в котором переменная c принимает значение каждого символа по очереди. Если бы такой возможности не было, нам нужно было бы определить длину массива и обращаться к каждому символу по его индексу:

string = str(number)

for i in range(len(string)):

string[i]

Второй вариант решения, в котором отсутствует преобразование числа в строку и обратно — целочисленное деление числа на 10.

1. Разделить число нацело на 10 с остатком
2. Остаток от деление прибавить к сумме
3. Если результат деления больше 0, повторить операцию 1 с результатом
4. Если результат деления равен 0, вернуть сумму

В коде это выглядит таким образом:

def digits_sum_v2(number: int) -> int: 
res = 0 
while number > 0: 
res += number % 10 
number //= 10 
return res

И последним третьим вариантом решения будем модификация второго алгоритма с использованием рекурсии. Если говорить вкратце, рекурсия — это метод упрощения задачи вплоть до самой тривиальной методом вызова функцией самой себя:

def digits_sum_v3(number: int) -> int: 
if number == 0: 
return 0 
else: 
return number % 10 + digits_sum_v3(number // 10)

В этом коде функция digits_sum_v3 возвращает 0 если на вход передан 0 и вызывает сама себя с уменьшенным числом в противном случае. Если вам пока не понятно, как это работает, не огорчайтесь: чтобы понять, что такое рекурсия, нужно сначала понять, что такое рекурсия.

Давайте же сравним три функции по скорости их работы. Сохранив код в файле digits_sum.py , мы сможем обращаться к его функциям предварительно импортировав их:

from digits_sum import digits_sum_v1, digits_sum_v2, digits_sum_v3

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

from random import randint

test_input = []
for i in range(100_000): 
test_input.append(randint(0, 10_000_000))

Сам код с тестами будет выглядеть таким образом:

from time import perf_counter

begin_time = perf_counter()
for i in test_input: 
digits_sum_v1(i)
v1_time = perf_counter() - begin_time

begin_time = perf_counter()
for i in test_input: 
digits_sum_v2(i)
v2_time = perf_counter() - begin_time

begin_time = perf_counter()
for i in test_input: 
digits_sum_v3(i)
v3_time = perf_counter() - begin_time

print('First function: ', v1_time)
print('Second function:', v2_time)
print('Third function: ', v3_time)

И результат его выполнения немного варьируется от запуска к запуску (мы все-таки используем случайные исходные данные), но в среднем тенденция видна хорошо:

First function: 0.1837308 Second function: 0.0905128 Third function: 0.1306372

Второй вариант (с обычным циклом) работает быстрее двух других, при этом третий вариант с рекурсией отстает от него довольно значительно. Из этого можно сделать вывод, что рекурсию нужно использовать только там, где она необходима, так как явного улучшения производительности по сравнению с циклами она не дает (по крайней мере в этом случае).

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

В следующей статье мы продолжим решение задачи, используя нашу заготовку.

Как найти сумму и произведение цифр трехзначного числа в Python

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

Нахождение суммы и произведения цифр трехзначного числа с помощью арифметических операций

Решить данную задачу можно с помощью применения простых математических операций. Сначала посмотри код, а после разберём его подробнее:

num = int(input("Введите трехзначное число: ")) # Получение цифр числа digit1 = num // 100 digit2 = (num % 100) // 10 digit3 = num % 10 # Вычисление суммы цифр sum_of_digits = digit1 + digit2 + digit3 print(f"Сумма цифр числа равна ") # Вычисление произведения цифр product_of_digits = digit1 * digit2 * digit3 print(f"Произведение цифр числа равно ")

1. Сначала мы получаем трехзначное число от пользователя, используя функцию input() . Функция input() возвращает строку, которую мы преобразуем в целое число с помощью функции int() .
2. Затем мы получаем каждую цифру числа, используя операции целочисленного деления и остатка от деления. Для первой цифры мы используем целочисленное деление на 100, чтобы получить первую цифру числа. Для второй цифры мы используем операцию остатка от деления на 100, чтобы получить последние две цифры числа, а затем выполняем целочисленное деление на 10, чтобы получить вторую цифру числа. Для третьей цифры мы используем операцию остатка от деления на 10, чтобы получить последнюю цифру числа.
3. Затем мы вычисляем сумму цифр, складывая каждую цифру, и сохраняем ее в переменную sum_of_digits .
4. Мы также вычисляем произведение цифр, умножая каждую цифру, и сохраняем его в переменную product_of_digits .
5. Наконец, мы выводим сумму и произведение цифр с помощью функции print() . Мы используем символы форматирования <> для вставки переменных num , sum_of_digits и product_of_digits в строку.

Мы можем использовать цикл while и оптимизировать наш код для работы с целочисленными числами любого порядка:

# Получаем трехзначное число от пользователя num = int(input("Введите трехзначное число: ")) # Инициализируем переменные для хранения суммы и произведения цифр digit_sum = 0 digit_product = 1 # Разбиваем число на цифры с помощью операций деления и остатка от деления while num != 0: # Получаем последнюю цифру числа digit = num % 10 # Добавляем ее к сумме цифр digit_sum += digit # Умножаем ее на произведение цифр digit_product *= digit # Убираем последнюю цифру из числа num //= 10 # Выводим результаты на экран print("Сумма цифр:", digit_sum) print("Произведение цифр:", digit_product)

Нахождение суммы и произведения цифр трехзначного числа с помощью цикла for и извлечения символов строки

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

Вот пример решения нашей задачи:

num = input("Введите трехзначное число: ") sum = 0 product = 1 for digit in num: sum += int(digit) product *= int(digit) print("Сумма цифр:", sum) print("Произведение цифр:", product)

Здесь мы сначала создаем переменные sum и product для хранения суммы и произведения цифр соответственно.

Далее мы используем цикл for для обхода каждой цифры числа. Внутри цикла мы преобразуем каждую цифру из строки в целое число с помощью функции int() и добавляем его к переменной sum . Также мы умножаем каждую цифру на переменную product , чтобы накапливать их произведение.

Наконец, мы выводим результаты на экран с помощью функции print() .

Данный код будет работать для целых чисел любого порядка.

Python-сообщество

• Начало
• » Центр помощи
• » Найти сумму чисел в последовательности

#1 Ноя. 25, 2021 19:52:02

Anzhela-Firsova Зарегистрирован: 2021-11-25 Сообщения: 8 Репутация: 0 Профиль Отправить e-mail

Найти сумму чисел в последовательности

Добрый вечер, помогите пожалуйста, уже 4 часа схожу с ума, все перепробовала.
Необходимо найти сумму чисел в последовательности: 2, 22, 222, 2222, 22222, 2(n)
где n — количество 2 в числе, используя функции while и if (сейчас их изучаем).

получается 2,22, а дальше уже не 22, а куча 2. Почему так — я прекрасно понимаю, но как сделать правильно — не поняла.
почему не числами, а через строку — числами, правда, не понимаю как сделать. Учу всего 3 недели Python, так что, сложные решения плиз не предлагайте)))
Заранее спасибо)

Отредактировано Anzhela-Firsova (Ноя. 25, 2021 20:13:02)