Как найти сумму всех делителей числа питон

чуть-чуть короче (нет)

версия 1:

n = int(input())
for i in range(11, n + 1):
    print(i, '+' * len(list(filter(lambda x: i % x == 0, range(1, i + 1)))), sep='')

версия 2:

n = int(input())
for i in range(11, n + 1):
    print(i, '+' * len(list(filter(lambda x: not(i % x), range(1, i + 1)))), sep='')

версия 3:

Хватит разврата и откопал стюардессу

n = int(input())
print("n".join(map(lambda i: str(f'{i}' + '+' * len(list(filter(lambda x: not(i % x), range(1, i + 1))))), range(11, n + 1))))

версия 4:

print("n".join(map(lambda i: str(f'{i}' + '+' * len(list(filter(lambda x: not(i % x), range(1, i + 1))))), range(11, int(input()) + 1))))

версия 5, окончательная (покороче):

print("n".join(map(lambda i: f'{i}' + '+' * len(list(filter(lambda x: not(i % x), range(1, i + 1)))), range(11, int(input()) + 1))))

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

Нахождение делителей числа

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

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

Алгоритм нахождения очень простой. В цикле перебираются значения от делимого минус единица до двух включительно. Если делимое нацело делится на текущее значение, то оно является делителем.

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

numb = int(input("Введите целое число: "))
print("Результат:", end = " ")
for i in range(numb - 1, 1, -1):
    if (numb % i == 0):
        print(i, end = " ")

Например, пользователь ввёл число 625. Программа начинает цикл со значения 624, в цикле проверяется, делится ли нацело 625 на 624, затем цикл переходит на следующую итерацию и работает уже с числом 623 и так до двух. Таким образом, вывод программы будет следующим:

Введите целое число: 625
Результат: 125 25 5

Простые делители числа

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

Программа построена по следующему алгоритму:

1. Обнулить счётчик.
2. В цикле искать делители.
3. Если найден, искать во вложенном цикле его делители. Это для того, чтобы определить: является ли он простым.
4. Если найден, увеличить счётчик.
5. Если счётчик равен нулю, то число простое и надо вывести значение делителя в консоль.
6. Перейти на следующую итерацию внешнего цикла.

Цикл теперь выглядит так:

numb = int(input("Введите целое число: "))
print("Простые:", end = " ")
for i in range(numb - 1, 1, -1):
    is_simple = 0 # Счётчик
    if (numb % i == 0):
        for j in range(i - 1, 1, -1):
            if (i % j == 0):
                is_simple = is_simple + 1 # Увеличиваем, если находим делитель
        if (is_simple == 0): # Если делителей не было найдено, выводим
            print(i, end = " ")

Понятно, что если значение счётчика больше нуля — то число точно не простое. Можно оптимизировать немного код и сразу завершать вложенный цикл после увеличения счётчика. Для этого можно воспользоваться оператором break в условном операторе, находящемся во вложенном цикле.

Результат работы программы:

Введите целое число: 63
Простые: 7 3

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

Сумма делителей

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

Код программы:

numb = int(input("Введите целое число: "))
sum_of_dividers = 0
for i in range(numb - 1, 1, -1):
    if (numb % i == 0):
        sum_of_dividers += i
print("Сумма:", sum_of_dividers)

Результат выполнения кода:

Введите целое число: 63
Сумма: 40

Количество делителей

Этот вариант программы также лишь незначительно отличается от изначального. Для подсчёта делителей нужно ввести переменную-счётчик, к которой будет прибавляться единица каждый раз, когда условие «numb % i == 0» будет выполняться.

numb = int(input("Введите целое число: "))
count_of_dividers = 0
for i in range(numb - 1, 1, -1):
    if (numb % i == 0):
        count_of_dividers += 1
print("Количество равно:", count_of_dividers)

Результаты выполнения программы:

Введите целое число: 63
Количество равно: 4

Максимальный и минимальный делитель

Для нахождения минимального и максимального делителя в код на Python нужно добавить две переменные: min_divider и max_divider. В цикле делитель будет сравниваться со значением этих переменных и, если необходимо, записываться в них.

Код программы:

numb = int(input("Введите целое число: "))
min_divider = numb
max_divider = 1
for i in range(numb - 1, 1, -1):
    if (numb % i == 0):
        if (min_divider > i):
            min_divider = i
        if (max_divider < i):
            max_divider = i
print("Минимальный равен:", min_divider)
print("Максимальный равен:", max_divider)

Результат выполнения:

Введите целое число: 63
Минимальный равен: 3
Максимальный равен: 21

Нахождение наименьшего и наибольшего делителя, подсчёт суммы делителей и их количества можно объединить в одну программу на Python. Это не должно вызвать каких-либо проблем или конфликтов, потому что программа работает с 4 независимыми переменными.

We need to find the divisors of the number first, and then sum them. Finding out if a number is a divisor of another number is pretty simple:

if x % y == 0:
  is_divisor = True

Modulo — % — returns the remainder of a division. 9 % 2 = 1. 10 % 3 = 1. However, we’ll need to know which numbers to check. We could just loop through every number up to our input:

for i in range(n):
  if n % i == 0:
    is_divisor = True

…but that’s too much. For example, we know that the highest possible divisor of n that isn’t n itself, is 1/2n if n is even, and lower if it’s not. Instead, let’s focus on getting each pair, and then check if we should continue. We also need to store all of these numbers, so lets create some lists:

lower_divisors = []
upper_divisors = []

We’ll want to know what our current highest lower divisor and lowest highest divisor are, and also know where to start. We can populate the lower divisor list with 1 and the highest with n. We can worry about removing n later.

lower_divisors = [1]
upper_divisors = [n]

continu = True

while continu:
  # Let's get the last item in each list
  highest_low = lower_divisors[-1]
  lowest_high = upper_divisors[-1]

  for i in range(highest_low + 1, lowest_high):
    if n % i == 0:
      lower_divisors.append(i)
      upper_divisors.append(n // i)
      break
  continu = False

# If we've left the loop, we have all of our divisors.
lower_sum = sum(lower_divisors)
higher_sum = sum(upper_divisors) - n   #Gotta take it back out!
sm = lower_sum + higher_sum
return sm

That should be a fast way to achieve your goal, without making your computer work harder — but… it’s a lot more steps to write. I wrote it in far more steps to make it clear what I was doing and to be readable, but it could definitely be trimmed up a lot.

Upon running the code, the simple method of looping through each number from 1 to n starts to really add up when n is over 8 digits. 9 digit numbers were taking around 12-16 seconds on my machine. The longer approach above returns 32-digit values for n in under 1/10th of a second.

1

Нахождение количества делителей и их сумму для вводимого числа по формулам

12.10.2020, 12:57. Показов 12464. Ответов 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

def is_Prime(n):
    if n < 2:
        return False
    for divider in range(2, int(n ** 0.5 + 1)):
        if n % divider == 0:
            return False
    return True
 
 
def get_list_of_prime_number(Number):
    list0 = []
    for divider in range(2, Number + 1):
        if is_Prime(divider):
            list0.append(divider)
    return list0
 
 
N = int(input())
list_of_prime_number_for_N = get_list_of_prime_number(N) #создали список простых чисел числа N
list_of_power_of_prime_number = [0 for _ in range(len(list_of_prime_number_for_N))]# создаём список из степеней простых чисел, образующих в случае умножения N
power = 0 # будет работать как ссылка на степень из списка степеней всех простых делителей числа N
for prime_number in list_of_prime_number_for_N:  #читать после строки 27: а потом переходим к большему простому делителю
    while N % prime_number == 0:#Если число N делится на простое число не превышающее само N, тоесть является его делителем
        N //= prime_number # то делим
        list_of_power_of_prime_number[power] += 1 # и записываем сколько раз делится, тоесть степень
    power += 1
g0 = 1
for p in list_of_power_of_prime_number: # По формуле 1 для степеней простых делителей
    g0 *= (p + 1) #вычисляем количсетво делителей
g1 = 1
i = 0 #итерируемая переменная
for p in list_of_prime_number_for_N: #
    sum = 0 #
    for power in range(list_of_power_of_prime_number[i] + 1): # по формуле 2 находим одну скобку, состоящую из
        sum += p ** power #сумм одного простого делителя в степени от 0 до той которую применяет в формле 0
    i += 1
    g1 *= sum
print(g0, g1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

def get_list_of_prime_number(n):
    prime = [True] * (n + 1)
    prime[0] = prime[1] = False
    for i in range(2, n + 1):
        if not prime[i]:
            continue
        for j in range(i*i, n + 1, i):
            prime[j] = False
    list0 = []
    for i in range(int(len(prime)//2 + 1)):
        if prime[i]:
            list0.append(i)
    return list0
 
N =int(input())
list_of_prime_number_for_N = get_list_of_prime_number(N) #создали список простых чисел числа N
list_of_power_of_prime_number = [0 for _ in range(len(list_of_prime_number_for_N))]# создаём список из степеней простых чисел, образующих в случае умножения N
power = 0 # будет работать как ссылка на степень из списка степеней всех простых делителей числа N
for prime_number in list_of_prime_number_for_N:  #читать после строки 27: а потом переходим к большему простому делителю
    while N % prime_number == 0:#Если число N делится на простое число не превышающее само N, тоесть является его делителем
        N //= prime_number # то делим
        list_of_power_of_prime_number[power] += 1 # и записываем сколько раз делится, тоесть степень
    power += 1
g0 = 1
for p in list_of_power_of_prime_number: # По формуле 1 для степеней простых делителей
    g0 *= (p + 1) #вычисляем количество делителей
g1 = 1
i = 0 #итерируемая переменная
for p in list_of_prime_number_for_N: #
    sum = 0 #
    for power in range(list_of_power_of_prime_number[i] + 1): # по формуле 2 находим одну скобку, состоящую из
        sum += p ** power #сумм одного простого делителя в степени от 0 до той которую применяет в формуле 0
    i += 1
    g1 *= sum
print(g0, g1)

0