Как найти простое число в питоне while

As a first exercise with Python, I’m trying to write a program using loops to find primes. Everything works with a for loop so I am trying to use a while loop. This works but the program returns a few incorrect numbers.

import math
# looking for all primes below this number
max_num = int(input("max number?: "))

primes = [2]  # start with 2
test_num = 3  # which means testing starts with 3

while test_num < max_num:
    i = 0
    # It's only necessary to check with the primes smaller than the square
    # root of the test_num
    while primes[i] < math.sqrt(test_num):
        # using modulo to figure out if test_num is prime or not
        if (test_num % primes[i]) == 0:
            test_num += 1
            break
        else:
            i += 1
    else:
        primes.append(test_num)
        test_num += 1

print(primes)

So the weird thing is that for max_num=100 it returns:

[2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

which is correct except for 9, 25 and 49 and I can’t figure out why.

Подскажите, пожалуйста, как правильно написать функцию is_prime, принимающую 1 аргумент — число от 0 до 1000,
и возвращающую True, если оно простое, и False – иначе.”

def is_prime(a):
    if a % a == 0 and a != 0:
        return True
    else:
        return False

a = int(input("Enter a number: "))
print(is_prime(a))

Nowhere Man's user avatar

Nowhere Man

11.5k18 золотых знаков16 серебряных знаков27 бронзовых знаков

задан 29 окт 2019 в 23:26

Sherlock's user avatar

Попробуйте так :

def is_prime(a):
    if a % 2 == 0:
        return a == 2
    d = 3
    while d * d <= a and a % d != 0:
        d += 2
    return d * d > a

print(is_prime(int(input("Enter a number: "))))

print( [ '{} - True'.format(i) for i in range(2, 1001)  if is_prime(i)]) 

ответ дан 29 окт 2019 в 23:43

S. Nick's user avatar

S. NickS. Nick

70.2k96 золотых знаков36 серебряных знаков55 бронзовых знаков

1

Вот моё решение:

def is_prime(x):
    for i in range(2, (x//2)+1):
        if x % i == 0:
            return False
    return True

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

ответ дан 8 авг 2021 в 8:58

Exodus's user avatar

ExodusExodus

3311 серебряный знак10 бронзовых знаков

3

  • Простое число — натуральное (целое положительное) число, имеющее ровно два различных натуральных делителя — единицу и самого себя.

Будем проходить по циклу до корня числа, ведь если мы не найдём делитель до корня данного числа, то дальше нет смысла искать, не найдём делители.


Вот работающий код:

def is_prime(a):
    if a < 2:
        return False
    for i in range(2, int(a ** 0.5 + 1)):
        if a % i == 0:
            return False
    else:
        return True
print(is_prime(int(input())))

ответ дан 8 авг 2021 в 5:45

Semitron's user avatar

SemitronSemitron

3621 серебряный знак8 бронзовых знаков

8

Оптимизированный алгоритм поиска простых неотрицательных чисел:

  1. проверить на 0 и 1
  2. проверить на чётность и равенство 2 (исключается ~50% чисел)
  3. проверить на кратность 3 и равенство 3 (исключается ещё ~33% чисел)
  4. для проверки оставшихся чисел воспользоваться формулой 6n ± 1 (при n = 1, простыми будут 5 и 7, при n = 2: 11 и 13, и т.д.)
  5. как отмечено раньше, проверять делители следует до корня из заданного числа

код:

def is_prime(num):
    prime = num > 1 and (num % 2 != 0 or num == 2) and (num % 3 != 0 or num == 3)
    i = 5;
    d = 2;

    while prime and i * i <= num:
        prime = num % i != 0
        i += d
        d = 6 - d # чередование прироста 2 и 4: 5 + 2, 7 + 4, 11 + 2, и т.д.
    return prime

Тест:

print(*[ i for i in range(101) if is_prime(i)]) 
>> 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

ответ дан 30 дек 2021 в 23:46

Nowhere Man's user avatar

Nowhere ManNowhere Man

11.5k18 золотых знаков16 серебряных знаков27 бронзовых знаков

def is_prime(number):
    for i in range(2, int(number ** 0.5) + 1):
        if number % i == 0:
            return False
    return True

ответ дан 23 авг 2022 в 13:22

MIkhail's user avatar

MIkhailMIkhail

1678 бронзовых знаков

1

Описание задачи

Программа принимает на вход число и проверяет, простое оно или нет.

Решение задачи

  1. Принимаем на вход число и записываем его в отдельную переменную.
  2. Инициализируем переменную, которая будет выполнять роль счетчика, значением 0.
  3. Организуем цикл for в диапазоне от 2 до значения проверяемого числа, деленного на 2 (речь идет, конечно, о целочисленном делении).
  4. Затем находим количество делителей нашего числа. При помощи условного оператора if мы проверяем, делится ли число без остатка, и затем, если делится, увеличиваем наш счетчик на единицу.
  5. Если число делителей равно 0, то проверяемое число является простым.
  6. Выводим результат на экран.
  7. Конец.

Исходный код

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

a = int(input("Введите число: "))
k = 0
for i in range(2, a // 2+1):
    if (a % i == 0):
        k = k+1
if (k <= 0):
    print("Число простое")
else:
    print("Число не является простым")

Объяснение работы программы

  1. Пользователь вводит число, и оно сохраняется в переменную a.
  2. Инициализируем переменную k значением 0. Эта переменная будет выполнять роль счетчика.
  3. Запускаем цикл for в диапазоне от 2 до значения проверяемого числа, деленного на 2 (речь идет, конечно, о целочисленном делении). Напоминаем, что само число и 1 делителями мы считать не будем.
  4. Затем, при помощи инструкции if, на каждой итерации цикла мы проверяем, делится ли наше число без остатка на числа из выбранного диапазона цикла. Если делится, то переменная k, выполняющая роль счетчика, увеличивается на единицу.
  5. Если число делителей равно 0, то проверяемое число является простым.
  6. Выводим полученный результат на экран.

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

Пример 1:
Введите число: 7
Число простое
 
Пример 2:
Введите число: 35
Число не является простым

Еще более 50 задач на числа в нашем телеграм канале Python Turbo. Уютное сообщество Python разработчиков.

  1. Используйте простой метод итерации для определения простого числа в Python
  2. Используйте функцию sympy.isprime(), чтобы проверить, является ли данное число простым числом в Python

Проверьте, является ли число простым в Python

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

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

Используйте простой метод итерации для определения простого числа в Python

В этом методе мы используем простой метод итерации с использованием цикла for или while. Переберите числа, начиная с 2 и далее до K/2, и проверьте, делит ли какое-либо из этих чисел K.

Если найдено число, соответствующее этому критерию, то возвращается False. С другой стороны, если все числа не соответствуют этому критерию, данное число K является простым числом, и возвращается значение True.

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

k = 13

# 1 not being a prime number, is ignored
if k > 1:
    for i in range(2, int(k/2)+1):
         if (k % i) == 0:
            print("It is not a prime number")
            break
    else:
        print("It is a prime number")

else:
    print("It is not a prime number")

Выход:

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

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

  • Все простые числа существуют в форме 6n ± 1, за исключением 2 и 3. Следовательно, проверка делимости данного числа на 2 и 3, а затем проверка каждого числа, имеющего форму 6n ± 1, является более эффективным решением.

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

def isitPrime(k):
    if k==2 or k==3: return True
    if k%2==0 or k<2: return False
    for i in range(3, int(k**0.5)+1, 2):
        if k%i==0:
            return False

    return True
print(isitPrime(13))

Выход:

Оптимизированный метод итерации делает его быстрее и эффективнее, чем простой метод итерации, примерно на 30%.

Используйте функцию sympy.isprime(), чтобы проверить, является ли данное число простым числом в Python

SymPy – это библиотека на Python, используемая для реализации символьной математики. Это упрощенная система компьютерной алгебры (CAS), которая содержит все основные функции. Для этого метода необходима установка этого модуля, и его можно загрузить, просто используя команду pip.

sympy.isprime() – это встроенная функция модуля SymPy, которую можно использовать для проверки возможных простых чисел. Это прямая функция, которая возвращает True, если проверяемое число простое, и False, если число не простое.

Следующий код использует функцию sympy.isprime(), чтобы проверить, является ли данное число простым числом в Python.

from sympy import *
  
isprime(8)
isprime(11)

Выход:

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

Проверка простоты числа перебором делителей

Решение задачи на языке программирования Python

Простые числа – это натуральные числа больше единицы, которые делятся нацело только на единицу и на себя. Например, число 3 простое, так как нацело делится только на 1 и 3. Число 4 сложное, так как нацело делится не только на 1 и 4, но также на число 2.

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

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

from math import sqrt
 
n = int(input())
 
prime = True
 
i = 2
while i <= sqrt(n):
    if n % i == 0:
        prime = False
        break
    i += 1
 
if prime:
    print("Простое число")
else:
    print("Составное число")

В программе мы сначала предполагаем, что введенное число n является простым, и поэтому присваиваем переменной prime значение True. Далее в цикле перебираются делители (переменная i ) от 2-х до квадратного корня из числа n. Как только встречается первый делитель, на который n делится без остатка, меняем значение prime на False и прерываем работу цикла, так как дальнейшее тестирование числа на простоту смысла не имеет.

Если после выполнения цикла prime осталась истиной, сработает ветка if условного оператора. В случае False, поток выполнения заходит в ветку else.

Если знать о такой особенности циклов в Python как возможность иметь ветку else, то код можно упростить, избавившись от переменной prime и ее проверки условным оператором после завершения работы цикла.

from math import sqrt
 
n = int(input())
 
i = 2
while i <= sqrt(n):
    if n % i == 0:
        print("Составное число")
        break
    i += 1
else:
    print("Простое число")

Ветка else при циклах (как while, так и for) срабатывает, если в основном теле цикла не происходило прерывания с помощью break. Если break сработал, то тело else выполняться не будет. При использовании таких конструкций также следует помнить, что если условие в заголовке цикла сразу возвращает ложь (то есть тело цикла не должно выполняться ни разу), код тела else все-равно будет выполнен.

Программы выше будут определять числа 0 и 1 как простые. Это неправильно. Данные числа не являются ни простыми, ни сложными. Для проверки ввода пользователя, можно воспользоваться условным оператором или зациклить запрос числа, пока не будет введено корректное значение:

n = 0
while n < 2:
    n = int(input())

Рассмотрим функцию, которая определяет, является ли число простым:

from math import sqrt
 
 
def is_prime(n):
    i = 2
    while i <= sqrt(n):
        if n % i == 0:
            return False
        i += 1
    if n > 1:
        return True
 
 
a = int(input())
 
if is_prime(a):
    print("Простое число")
else:
    print("Число НЕ является простым")

Здесь нет необходимости в прерывании работы цикла с помощью break, так как оператор return выполняет выход из тела всей функции.

Если цикл полностью отработал, выполнится выражение return True, находящееся ниже цикла. Оно помещено в тело условного оператора, чтобы исключить возврат “истины”, когда в функцию передаются числа 0 или 1. В этом случае функция вернет объект None.

Программа не защищена от ввода отрицательного числа. При этом будет генерироваться ошибка на этапе извлечения квадратного корня.

Нарисуем блок-схему тестирования числа на простоту (без дополнительных проверок и оператора break):

from math import sqrt
 
n = int(input())
 
prime = True
 
i = 2
while i <= sqrt(n) and prime is True:
    if n % i == 0:
        prime = False
    i += 1
 
if prime:
    print("Простое число")
else:
    print("Составное число")

Больше задач в PDF

Добавить комментарий