25.01 Делители числа

def simple(x):# Функция,которая проверяет является число простым или нет
    return x > 1 and all(x % y for y in range(2,int(x**0.5)+1))
def divs(x):# Функция,которая возвращает делители определённого числа
    d = set()
    for i in range(2,int(x**0.5)+1):
        if x % i == 0:
            d |= {i,x//i}
    return sorted(d)
ans = []
for x in range(173225,217438):
    d = [i for i in divs(x) if simple(i)] #В списке d будут храниться делители числа x,которые при этом являются простыми числами
    if len(d) == 2 and (d[0] % 10 == d[1] % 10) and d[0]*d[1] == x:
        ans += [x]
print(len(ans),min(ans))

maxim = 0
minim = 10000000
count = 0
for i in range(1072, 8794):
    if i % 101 == 0 and i % 11 != 0:
        if i % 13 != 0 and i % 17 != 0:
            count += 1
            maxim = max(maxim, i)
            minim = min(minim, i)
print(count, int((maxim + minim) / 2))

Решение Python

Мы ищем числа с ровно двумя натуральными делителями. Такие числа — это простые числа: они делятся только на 1 и на само себя.

Алгоритм решения:

1. Задаём диапазон чисел от 12345 до 54321 включительно.

2. Для каждого числа проверяем, является ли оно простым:

   - Перебираем все возможные делители от 2 до включительно.

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

   - Если мы находим делитель , число не простое, ставим флаг в False и прерываем цикл.

3. Если флаг остался True, число простое, увеличиваем счётчик.

4. В конце выводим количество найденных простых чисел.

ans = 0  # Счётчик простых чисел

# Перебираем все числа в диапазоне от 12345 до 54321 включительно
for i in range(12345, 54322):
    flag = True  # Предполагаем, что число простое
    # Проверяем наличие делителей от 2 до корня числа включительно
    for j in range(2, int(i ** 0.5) + 1):
        if i % j == 0:  # Если найден делитель
            flag = False  # Число не простое
            break  # Прерываем проверку
    if flag:  # Если число простое
        ans += 1  # Увеличиваем счётчик

print(ans)  # Выводим количество простых чисел в диапазоне

def count_del(x):
    ans = [1, x]
    for i in range(2, int(x ** 0.5) + 1):
        if x % i == 0:
            ans += [i]
            if i != x // i:
                ans += [x // i]
        if len(ans) > 64:
            return False
    return len(ans) == 64
ans = []
for i in range(101010101, 1010100, -1):
    if count_del(i):
        ans += [i]
    if len(ans) == 5:
        print(*reversed(ans))
        break

Решение Python

Сначала мы задаём диапазон чисел от 100100 до 300100 включительно, которые будем проверять на наличие ровно четырёх различных натуральных делителей, не считая единицы и самого числа.

Для каждого числа из диапазона мы считаем количество делителей:

1. Любое число делится на само себя и на 1, но мы их не учитываем.

2. Чтобы найти остальные делители, достаточно перебирать числа от 2 до включительно, потому что:

     - Если делится на , то существует парный делитель .

     - Перебирая до корня, мы автоматически находим все делители числа.

3. Если и различны, мы увеличиваем счётчик на 2, иначе на 1. Это учитывает как сам делитель, так и парный делитель.

После проверки всех делителей:

     - Если количество найденных делителей равно 4, увеличиваем общий счётчик подходящих чисел.

В конце выводим результат — количество чисел, у которых ровно четыре различных делителя, кроме единицы и самого числа.

ans = 0  # Счётчик подходящих чисел

# Перебираем все числа в диапазоне от 100100 до 300100 включительно
for i in range(100100, 300100 + 1):
    k = 0  # Счётчик делителей числа i, кроме 1 и самого i
    # Перебираем возможные делители от 2 до корня числа включительно
    for j in range(2, int(i ** 0.5) + 1):
        if i % j == 0:  # Если j делитель числа i
            k += 1  # Учёт делителя j
            if j != i // j:  # Если парный делитель отличается
                k += 1  # Учёт парного делителя i / j
    if k == 4:  # Если ровно 4 делителя, кроме 1 и самого числа
        ans += 1  # Увеличиваем счётчик подходящих чисел

print(ans)  # Выводим количество чисел с ровно 4 делителями

def divs(n): # функция, которая возращает количество делителей числа
    k = 0
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            k += 1
            if i != n // i:
                k += 1
        if k > 5: # для оптимизации выходим из функции для текущего числа натуральных делителей, включая 1 и само число больше 5
            return 0
    return k

ans = 0
for i in range(100010, 321342):
    if divs(i) == 5:
        ans += 1
print(ans)

def count_divs(n): # функция для подсчёта количества делителей числа
    counter = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            counter += 1
            if i != n//i:
                counter += 1
    return counter


maxim = 0
maxim_counter = 0 # максимальное кол-во делителей определенного числа
for i in range(84052, 84130+1):
    temp = count_divs(i)
    if temp > maxim_counter: # если кол-во делителей текущего числа больше максимального кол-ва делителей
        maxim_counter = temp # обновляем максимальное кол-во делителей
        maxim = i # обновляем число
print(maxim_counter, maxim)

def divs(x): # функция возращающая список делителей определенного числа
    d = set()
    for i in range(1, int(x**0.5)+1):
        if x % i == 0:
            d.add(i)
            d.add(x//i)
    return sorted(d)
for x in range(287429, 319267+1):
    d = divs(x)
    if len(d) == 3: # если у определенного числа 3 делителя
        print(d[1]) # вывод второго делителя

def count(n):
    counter = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            counter += 1
            if i != n//i:
                counter += 1
    return counter


maxim = 0
max_ch = 0
for i in range(111213, 312111):
    temp = count(i)
    if temp >= maxim:
        max_ch = i
        maxim = temp
print(max_ch)

def prime(n): # функция, которая проверяет является ли число простым
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def divs(n): # функция,  которая возвращает список делителей
    d = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            d.add(i)
            d.add(n//i)
    return sorted(d)

counter = 0
for i in range(420001, 1000000000):
    d = [x for x in divs(i) if prime(x)] # список, в котором будут простые делители текущего числа
    if len(d) > 0: # если такие делители у числа есть
        avg = sum(d) // len(d) # вычисляем среднее арифметическое
        if avg % 42 == 24: # проверка по условию
            print(i)
            counter += 1
            if counter == 5: # если подходящих чисел набралось 5 штук
                break # прерываем выполнение программы

Решение через цикл:

Запустим цикл в рамках, заданных условием. Для каждого числа найдём делители от 1 до его корня, таким образом программа будет работать точно и быстро. Если нашли делитель - проверим, есть ли дополняющий к нему (поделив число на уже найденный). Берём только нечётные делители, вносим их в список, параллельно увеличивая счётчик. В конце, если попалось ровно 5 делителей, выведем их.

for x in range(543210, 563356): # Перебор по условию
    k = 0 # Счётчик числа делителей
    for i in range(1, int(x ** 0.5) + 1): # Ищем делители от 1 до корня числа
        # Проверяем что число является делителем и оно нечетное
        if x % i == 0:
            if i % 2 == 1:
                k += 1 # Увеличим счётчик
            if (x // i) != i and (x // i) % 2 == 1: # Проверим дополняющий делитель, если мы его ещё не добавили и он нечётный
                k += 1
    if k == 5: # Если нечётных делителей ровно 5
        print(x) # Вывод ответа

def count_divs(n):
    counter = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            counter += 1
            if i != n//i:
                counter += 1
    return counter


maxim = 0
ans = 0
for i in range(654321, 654521):
    temp = count_divs(i)
    if temp >= maxim:
        maxim = temp
        ans = i
print(maxim, ans)

def count_divs(n):
    counter = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            counter += 1 * (i % 2 == 0)
            if i != n//i:
                counter += 1 * (n//i % 2 == 0)
    return counter


ans = 0
for i in range(135792, 139449):
    temp = count_divs(i)
    if temp == 6:
        ans += 1
print(ans)

def count_divs(n): # функция, которая подсчитывает кол-во делителей числа
    counter = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            counter += 1
            if i != n//i:
                counter += 1
    return counter


maxim = 0 # максимальное кол-во делителей числа
ans = 0
for i in range(591645, 592845 + 1):
    temp = count_divs(i) # кол-во делителей текущего числа
    if temp > maxim:
        maxim = temp # обновляем максимальное кол-во делителей
        ans = i # обновляем число
print(maxim, ans)