Как проверить является ли число полным квадратом python

Почему второй вариант не проходит данные тесты? Нужен вариант, который занимает мало времени (не попадёт под ошибку Execution Timed Out (12000 ms) , а также не используются библиотеки.

Отслеживать
задан 6 июл 2022 в 5:06
user507635 user507635
if n ** 0.5 == 1 Что вы тут проверяете? ��
6 июл 2022 в 5:11
Почему не просто что-нить типа if ( (int) (n ** 0.5) ) ** 2 == n ?
6 июл 2022 в 5:16

@Akina В питоне приводить к инту надо вызывая его как функцию, это не C# ) Но так то вопрос совершенно точный

6 июл 2022 в 5:17
Если у вас питон 3.8: return math.isqrt(n) ** 2 == n
6 июл 2022 в 6:05
(n**.5).is_integer()
6 июл 2022 в 6:26

4 ответа 4

Сортировка: Сброс на вариант по умолчанию

Нет смысла делать цикл до n . Это примерно 100500 лишних операций в среднем. Если n равно 10001, то получится 9900 лишних итераций, ведь квадрат любого числа больше 100 уже больше 10000, так зачем их проверять. Нужно делать цикл до квадратного корня из n

if n == 0: return True else: for i in range(n + 1): i2 = i * i # квадрат очередного числа if i2 == n: return True elif i2 > n: # если квадрат больше n, то нет смысла проверять дальше break return False # тут я убрал else и перенес строчку на уровень выше. Разницы никакой нет, а читаемость улучшилась. 

Прибавление 1 позволяет убрать первую проверку на 0. Так что мы эту проверку лучше заменим на проверку отрицательных чисел:

if n < 0: return False else: for i in range(n + 1): i2 = i * i if i2 == n: return True elif i2 >n: break return False 

Отслеживать
ответ дан 6 июл 2022 в 7:36
26.1k 7 7 золотых знаков 31 31 серебряный знак 48 48 бронзовых знаков
Прежде чем я воспользуюсь функцией math.sqrt(), мне придётся совершить import, что запрещено.
– user507635
6 июл 2022 в 7:44
Ну сорян, в условиях этого не написано ��‍♂️
6 июл 2022 в 7:48
Да вообще непонятно, зачем нужен цикл, если можно просто взять корень и проверить, что он целый )
6 июл 2022 в 7:51

Дописал, а так же попробовал брать 2 - n, время сократилось на 0.04ms в тесте, но этого недостаточно.

– user507635
6 июл 2022 в 7:54
исправил на без квадратного корня
6 июл 2022 в 8:21

Простейшее быстрое решение для любого целого числа - двоичный поиск для получения целой части квадратного корня и прямая проверка что его квадрат равен исходному числу:

def isqrt(n): low = 0 high = n + 1 # + 1 to process 0, 1 properly while low < high - 1: mid = (low + high) // 2 if n < mid ** 2: high = mid else: low = mid return low def is_square(n): return n >= 0 and isqrt(n) ** 2 == n 

Отслеживать
ответ дан 6 июл 2022 в 11:57
Stanislav Volodarskiy Stanislav Volodarskiy
30.6k 3 3 золотых знака 19 19 серебряных знаков 55 55 бронзовых знаков

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

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

К примеру, в случае возведения трехзначного числа в трехзначную степень ** ещё работает быстрее, чем pow , а вот для четырехзначных - уже наооброт. См. пример ниже сделанный на моем (далеко не самом новом) ноуте.

import timeit import math print(timeit.timeit ('pow(5362, 2445)')) # 142 секунды print(timeit.timeit ('5362**2445')) # 147 секунд print(timeit.timeit ('(526 ** 252) % 10145')) # 2.87 секунды print(timeit.timeit ('pow(526, 252, 10145)')) # 0.90 секунд 

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

Примечание: Есть ещё pow в библиотеке math , но с ним вообще что-то странное. Например, pow(53, 244) считается без ошибок, а math.pow(53, 244) выдает OverflowError: math range error . Так что его тут не рассматриваю.

Проверка на целое число

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

a, b = map(int, input().split()) if int(a)/float(a)==1.0: print('является целым числом') else: print('не целое число.') if int(b)/float(b)==1.0: print('является целым числом') else: print('не целое число.') 

Отслеживать
76.8k 6 6 золотых знаков 55 55 серебряных знаков 123 123 бронзовых знака
задан 14 дек 2020 в 12:41
319 3 3 серебряных знака 13 13 бронзовых знаков
И что с твоим кодом?
14 дек 2020 в 12:44
float(a) - int(a) == 0
14 дек 2020 в 12:51
@Anton Nikolaev, 2.0 и 2 ?
14 дек 2020 в 12:53
@Zhihar 2.0 это с точки зрения математики не целое?
14 дек 2020 в 12:55
а это целое или с правающей запятой в рамках python?
14 дек 2020 в 12:58

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Не такая простая задача если решать её полностью. Есть три с половиной варианта:

1. целое число (0, -33, 16, 1_000_000)
2. • вещественное число (0.1, -123.4, 12e-1, 12.345e2).
   • вещественное число c целым значением (1.0, -16.0, 12.34e2)
3. непонятно что (123s, abracadabra, 1O0).

Целое число распознает int(s) . Если s строка с целым числом внутри, то вернётся его значение, иначе будет выброшено исключение ValueError .

Вещественное число распознает float(s) . И тоже выбросит исключение в случае неправильного формата.

Для проверки целочисленного значения вещественного числа пригодится метод is_integer .

В третий пункт попадает всё что вообще не выглядит как число.

Проверка на целое число должна идти до проверки на вещественное, иначе все целые числа будут записаны в вещественные.

def as_int(s): try: return int(s) except ValueError: return None def as_float(s): try: return float(s) except ValueError: return None def main(): s = input() i = as_int(s) if i is not None: print('int', repr(s), i) return f = as_float(s) if f is not None: print('float', repr(s), f) if f.is_integer(): print('. of integer value') return print('. ', repr(s)) main() 

$ python is_integer.py 1_000_000 int '1_000_000' 1000000 $ python is_integer.py 0 int '0' 0 $ python is_integer.py -33 int '-33' -33 $ python is_integer.py 16 int '16' 16 $ python is_integer.py 0.1 float '0.1' 0.1 $ python is_integer.py -123.4 float '-123.4' -123.4 $ python is_integer.py 12e-1 float '12e-1' 1.2 $ python is_integer.py 12.345e2 float '12.345e2' 1234.5 $ python is_integer.py 1.0 float '1.0' 1.0 . of integer value $ python is_integer.py -16.0 float '-16.0' -16.0 . of integer value $ python is_integer.py 12.34e2 float '12.34e2' 1234.0 . of integer value $ python is_integer.py 123s . '123s' $ python is_integer.py abracadabra . 'abracadabra' $ python is_integer.py 1O0 . '1O0' 

Как проверить является ли число полным квадратом python

Условие
Даны числа a и b. Необходимо найти все числа, являющиеся полными квадратами, на отрезке [a;b].

Формат входных данных
Вводится два целых числа a и b (1≤a,b≤215−1).

Формат выходных данных
Требуется вывести все числа, удовлетворяющие условию задачи.

входные данные выходные данные
1
5

Найти все числа, являющиеся полными квадратами, на заданном отрезке
Даны числа a и b. Необходимо найти все числа, являющиеся полными квадратами, на отрезке . Формат.

Найдите все числа, являющиеся полными квадратами, на отрезке от A до B
Найдите все числа на отрезке от A до B, являющиеся полными квадратами

Выведите все числа на отрезке от a до b, являющиеся полными квадратами
Вводятся целые числа a и b. Гарантируется, что a не превосходит b. Выведите все числа на отрезке.

Из файла f переписать в файл g все числа, являющиеся полными квадратами
Из файла f переписать в файл g все числа, являющиеся полными квадратами.

Python — проверьте, является ли число квадратом

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

Я уверен, что этот код работает. Но когда я выполнил тестовые примеры, например: test.expect( is_square( 4)) , он говорит, что значение не то, что ожидалось.

7 ответов

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

Так что он возвращает false только после проверки всех возможных квадратных корней. Вы также можете изучить math.sqrt() и float.is_integer() . Используя эти методы, ваша функция станет такой:

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

Python: проверьте, является ли число идеальным квадратом

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

скорость не вызывает беспокойства, на данный момент, просто работает.

19 ответов

проблема с опорой на любое вычисление с плавающей запятой ( math.sqrt(x) или x**0.5 ) заключается в том, что вы не можете быть уверены, что это точное (для достаточно больших целых чисел x , это не будет, и может даже переполнение). К счастью (если вы не торопитесь;-) есть много чистых целочисленных подходов, таких как следующие.

подсказка: он основан на «вавилонском алгоритме» для квадратного корня, см. Википедия. Это тут работа для любого положительного номер, для которого у вас достаточно памяти для завершения вычисления;-).

редактировать: давайте посмотрим пример.

это печатает, как пожелано (и в разумном количестве времени, тоже; -):

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

а затем попробуйте с x**7 и найти умный способ обойти проблему, которую вы получите,

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

Если Я был в спешке, конечно, я бы использовал gmpy — но тогда, я явно предвзят;-).

Да, я знаю, это так просто, это похоже на обман (a немного то, что я чувствую к Python в целом; -)-никакой умности вообще, просто совершенная прямота и простота (и, в случае gmpy, чистая скорость; -).

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

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

представьте себе, integer is 9 . math.sqrt(9) может быть 3.0 , но это также может быть что-то вроде 2.99999 или 3.00001 , поэтому возведение в квадрат результата сразу не является надежным. Зная это int принимает значение пола, увеличивая значение поплавка на 0.5 первое означает, что мы будем получите значение, которое мы ищем, если мы находимся в диапазоне, где float все еще имеет достаточно тонкое разрешение, чтобы представлять числа рядом с тем, который мы ищем.

идеальный квадрат-это число, которое можно представить как произведение двух одинаковых чисел. math.sqrt(number) возвратить float . int(math.sqrt(number)) приводит результат к int .

если квадратный корень является целым числом, например 3, то math.sqrt(number) — int(math.sqrt(number)) будет 0, а if заявление False . Если квадратный корень был вещественным числом, как 3.2, то это будет True и печать «это не идеальный квадрат».

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

моя собственная реализация isSquare (n) может быть не самой лучшей, но мне это нравится. У меня ушло несколько месяцев на изучение математической теории, цифровых вычислений и программирования на python, сравнение себя с другими участниками и т. д., чтобы действительно щелкнуть этим методом. Мне нравится его простота и эффективность. Я не видел ничего лучше. Скажи мне, что ты думаешь.

довольно прямо вперед. Сначала он проверяет, что у нас есть целое число, причем положительное. Иначе нет смысла. Он позволяет 0 проскальзывать как True (необходимый или следующий блок-бесконечный цикл).

следующий блок кода систематически удаляет полномочия 4 в очень быстром суб-алгоритме, используя операции битового сдвига и битовой логики. В конечном счете мы не находим isSquare нашего исходного n, но k

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

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

как и третий блок, четвертый проверяет значение ones-place в decimal с помощью простого оператора модуля и имеет тенденцию ловить значения, которые проскальзывают через предыдущий тест. Также мод 7 мод 8, 9 мод, а мод 13 тестов.

пятый блок проверки кода для некоторых хорошо известные идеальные квадратные узоры. Числа, заканчивающиеся на 1 или 9, предшествуют кратным четырем. А числа, заканчивающиеся на 5, должны заканчиваться на 5625, 0625, 225 или 025. Я включил другие, но понял, что они были избыточны или никогда не использовались.

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

кстати, я проверил рекомендуемый номер теста Алекса Мартелли, а также несколько чисел на много порядков больше, таких как:

напечатаны следующие результаты:

и он сделал это в 0,33 секунды.

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

примерно 99% всех целых чисел отклоняются как Неквадратичный до извлечения корня Вавилона даже реализуется, и в 2/3 времени потребуется вавилонянин, чтобы отклонить целое число. И хотя эти тесты не ускоряют процесс, который значительно, сокращение всех номеров тестов до нечетного путем деления всех степеней 4 действительно ускоряет вавилонский тест.

Я сделал тест сравнения времени. Я проверил все целые числа от 1 до 10 миллионов подряд. Используя только Вавилонский метод сам по себе (с мое специально разработанное первоначальное предположение) потребовалось моей поверхности 3 в среднем 165 секунд (со 100% точностью). Используя только логические тесты в моем алгоритме (исключая Вавилонский), потребовалось 127 секунд, он отклонил 99% всех целых чисел как неквадратные, не ошибочно отвергая любые совершенные квадраты. Из тех целых чисел, которые прошли, только 3% были идеальными квадратами (гораздо более высокая плотность). Используя полный алгоритм выше, который использует как логические тесты, так и извлечение вавилонского корня, у нас есть 100% точность, и завершение теста в только 14 секундах. Первые 100 миллионов целых чисел тестируются примерно за 2 минуты 45 секунд.

EDIT: я смог сбить время дальше. Теперь я могу проверить целые числа от 0 до 100 миллионов за 1 минуту 40 секунд. Много времени тратится на проверку типа данных и позитивности. Устранить первые две проверки и эксперимента на минуту. Следует предположить, что пользователь достаточно умен, чтобы знать, что негативы и поплавки не являются полный квадрат.

Это можно решить с помощью на decimal модуль получить произвольные квадратные корни точности и легкие проверки для «точности»:

для демонстрации с поистине огромного значения:

если вы увеличиваете размер тестируемого значения, это в конечном итоге становится довольно медленным (занимает около секунды для квадрата 200,000 бит), но для более умеренных чисел (скажем, 20,000 бит), это все еще быстрее, чем человек заметил бы для отдельных значений (

33 МС на моей машине). Но поскольку скорость не была вашей главной заботой, это хороший способ сделать это со стандартными библиотеками Python.

конечно, было бы гораздо быстрее использовать gmpy2 и просто тест gmpy2.mpz(x).is_square() , но если сторонние пакеты не ваша вещь, выше работает довольно хорошо.

это в основном квадратный корень, а затем по модулю 1, чтобы очистить целочисленную часть, и если результат равен 0 return True в противном случае return False . В этом случае x может быть любым большим числом, просто не таким большим, как максимальное число float, которое может обрабатывать python: 1.7976931348623157 e+308

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

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

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

1. решите, как долго будет число.
2. возьмите Дельта 0.000000000000. 000001
3. посмотрите, если(sqrt (x))^2 — x больше / равно /меньше, чем Дельта, и решите на основе Дельта-ошибки.

этот ответ не относится к вашему заявленному вопросу, но к неявному вопросу, который я вижу в коде, который вы опубликовали, т. е. «Как проверить, является ли что-то целым числом?»

первый ответ, который вы обычно получите на этот вопрос: «не надо!»И это правда, что в Python проверка типов обычно не является правильной вещью.

для этих редких исключений, однако, вместо того, чтобы искать десятичную точку в строковом представлении числа, нужно использовать isinstance:

конечно, это относится к переменной, а не значение. Если бы я хотел определить, является ли стоимостью была числом, я бы сделал так:

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

Если вы хотите сделать цикл над диапазоном и сделать что-то для каждого числа, которое не является идеальным квадратом, вы можете сделать что-то вроде этого:

Если вы хотите сделать что-то для каждого числа, которое является полным квадратом, то генератор еще проще:

Я не уверен в Python, но вы могли бы сделать что-то вроде:

то есть возьмите число, найдите квадратный корень, округлите его до ближайшего целого числа, возведите в квадрат и проверьте, совпадает ли оно с исходным числом. ( floor и добавить 0.5 делается для предотвращения таких случаев, как sqrt(4) возвращение 1.9999999. из-за математики с плавающей запятой, как отметил Майк Грэм.)

редактировать для разъяснения.

Я думаю, что это работает и очень просто:

это численно примерно такое же наивное решение, как вы можете иметь. Это работает для небольших чисел.

очевидно, он терпит неудачу для большого числа, такого как 152415789666209426002111556165263283035677490.

У меня есть небольшое улучшение исходного решения с использованием Вавилонского подхода. Вместо того, чтобы использовать набор для хранения каждого ранее сгенерированного приближения, только самые последние два приближения сохраняются и проверяются против текущего приближения. Это экономит огромное количество времени, потраченного на проверку всего набора предыдущих приближений. Я использую java вместо python и класс BigInteger вместо обычного примитивного целого числа.

есть очень простой способ сделать это. Найдите, сколько факторов имеет число (включая один и себя). Если он имеет нечетное количество факторов, это квадрат.

если результат функции нечетный, это квадрат.

это может быть не лучший метод для компьютерной программы, но это хороший метод для людей.

Python — проверьте, является ли число квадратом

Я уверен, что этот код работает. Но когда я делал тестовые примеры, например: test.expect( is_square( 4)) , он говорит, что это не то, что ожидалось.

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

так что он возвращает false только после проверки всех возможных квадратных корней. Вы также можете посмотреть в math.sqrt() и float.is_integer() . Используя эти методы, ваша функция станет такой:

Имейте в виду, что этот метод не будет работать с очень большими числами, но ваш метод будет очень медленным с ними, поэтому вам придется выбирать, что использовать. Надеюсь, я помог!

Похожие публикации:

1. Как строку чисел перевести в массив python
2. Как убрать из строки пробелы python
3. Как удалить python mac os
4. Как удалить переменную в python

Как проверить является ли число полным квадратом python

Я уверен, что этот код работает. Но когда я делал тестовые примеры, например: test.expect( is_square( 4)) , он говорит, что это не то, что ожидалось.

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

так что он возвращает false только после проверки всех возможных квадратных корней. Вы также можете посмотреть в math.sqrt() и float.is_integer() . Используя эти методы, ваша функция станет такой:

Имейте в виду, что этот метод не будет работать с очень большими числами, но ваш метод будет очень медленным с ними, поэтому вам придется выбирать, что использовать. Надеюсь, я помог!

Проверьте, является ли число полным квадратом

Как я мог проверить, является ли число полным квадратом?

Скорость не вызывает беспокойства, на данный момент, просто работая.

7 ответов

Проблема с тем, чтобы полагаться на любые вычисления с плавающей запятой ( math.sqrt(x) , или x**0.5 ) в том, что вы не можете быть уверены в их точности (для достаточно больших целых чисел x они не будут точными, и даже могут переполниться). К счастью (если не торопиться;-) существует множество чисто целочисленных подходов, таких как следующий.

Подсказка: он основан на «вавилонском алгоритме» для квадратного корня, смотрите википедию. Он работает для любого положительного числа, для которого у вас достаточно памяти для завершения вычислений;-).

Edit: давайте посмотрим пример.

это печатает, как надо (и за разумное время тоже;-):

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

А затем попробуйте с x**7 и найдите умный способ обойти проблему, которую вы получите,

вам придется становиться все умнее и умнее по мере роста чисел, конечно.

Если бы я спешил, конечно, я бы использовал gmpy — но тогда, я явно предвзят;-).

Да, я знаю, это настолько просто, что кажется жульничеством (немного похоже на то, как я отношусь к Python в целом;-) — никакой заумности, только идеальная прямота и простота (и, в случае с gmpy, чистая скорость;-)).

Проверить, является ли заданное число N квадратом целого числа

Проверить, является ли заданное натуральное число степенью двойки
Здравствуйте, форумчане. Есть следующее задание: Дано натуральное число N. Выведите слово.

Определить, является ли заданное число квадратом простого числа
Задание: Дано натуральное число N. Определить, является ли оно квадратом простого числа. Формат.

Цикл проверить, является ли число степенью числа 3
Дано целое число N>0, если оно является степенью числа 3 то вывести TRUE, если нет — FALSE

Как проверить является данное число квадратом целого числа?
Как проверить является данное число квадратом целого числа? подскажите какое необходимо написать.

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

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

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

В этом уроке вы:

• повторить основы простых чисел,
• написать код Python, чтобы проверить, является ли число простым, и
• оптимизируйте его дальше, чтобы получить алгоритм времени выполнения O (√ n).

Для всего этого и многого другого, давайте начнем.

Что такое простое число?

Начнем с рассмотрения основ простых чисел.

В теории чисел натуральное число n называется основной если у него ровно два делителя: 1 и само число (n). Вспомните из школьной математики: говорят, что число i является делителем числа n, если i делит n без остатка. ✅

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

nFactorsIs Prime?11Нет21, 2Да31, 3Да41, 2, 4Нет71, 7Да151, 3, 5, 15Нет

Из приведенной выше таблицы мы можем записать следующее:

• 2 — наименьшее простое число.
• 1 является множителем каждого числа.
• Каждое число n само по себе является множителем.

Итак, 1 и n — тривиальные множители для любого числа n. И у простого числа не должно быть других делителей, кроме этих двух.

Это означает, что при переходе от 2 к n – 1 вы не сможете найти нетривиальный множитель, который делит n без остатка.

Алгоритм O (n) для проверки того, является ли число простым в Python

В этом разделе давайте формализуем описанный выше подход в виде функции Python.

Вы можете перебрать все числа от 2 до n – 1, используя объект range() в Python.

В Python range(start, stop, step) возвращает объект диапазона. Затем вы можете выполнить итерацию по объекту диапазона, чтобы получить последовательность от начала до конца -1 с шагом шага.

Поскольку нам нужен набор целых чисел от 2 до n-1, мы можем указать диапазон (2, n) и использовать его вместе с циклом for.

Вот что мы хотели бы сделать:

• Если вы найдете число, которое делит n нацело без остатка, вы можете сразу сделать вывод, что это число не простое.

• Если вы перебрали весь диапазон чисел от 2 до n – 1 и не нашли числа, которое делит n без остатка, то это число простое.

Функция Python для проверки простого числа

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

Давайте теперь разберем приведенное выше определение функции.

• Приведенная выше функция is_prime() принимает в качестве аргумента положительное целое число n.
• Если вы найдете множитель в указанном диапазоне (2, n-1), функция вернет False, так как число не является простым.
• И он возвращает True, если вы проходите весь цикл, не найдя множителя.

Далее давайте вызовем функцию с аргументами и проверим правильность вывода.

В приведенном выше выводе вы видите, что 2 и 11 — простые числа (функция возвращает True). И 8, и 9 не простые (функция возвращает False).

Как оптимизировать функцию Python is_prime()

Мы можем сделать небольшую оптимизацию здесь. Обратите внимание на список факторов в таблице ниже.

NumberFactors61, 2, 3, 6101, 2, 5, 10181, 2, 3, 6, 9, 18

Итак, мы видим, что единственный множитель n, который больше n/2, — это сам n.

Таким образом, это означает, что вам не нужно зацикливаться до n – 1. Вместо этого вы можете запускать цикл только до n/2.

Если вы не найдете нетривиальный множитель до n/2, вы не сможете найти и множитель выше n/2.

Теперь давайте изменим функцию is_prime() для проверки факторов в диапазоне (2, n/2)

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

Хотя может показаться, что мы оптимизировали, этот алгоритм не эффективнее предыдущего с точки зрения сложности выполнения. На самом деле, они оба имеют сложность выполнения O(n): пропорциональную значению n или линейную по n.

Можем ли мы сделать лучше? Да мы можем!

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

Алгоритм O(√n) для проверки простого числа в Python

Бывает, что множители числа встречаются парами.

Если a — фактор числа n, то также существует фактор b такой, что axb = n, или просто ab = n.

Давайте проверим это на примере.

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

Также обратите внимание, что √18 примерно равно 4,24.

А среди множителей, встречающихся парами (а, b), видно, что если а меньше 4,24, то b больше 4,24 — в этом примере (2, 18) и (3, 6).

Факторы 18 в парах

На рисунке ниже показаны множители 18, нанесенные на числовую прямую.

Если число n является полным квадратом, вы будете иметь a = b = √n в качестве одного из множителей.

▶️ Посмотрите на множители 36 в таблице ниже. Поскольку 36 — полный квадрат, a = b = 6 — один из множителей. Для всех остальных пар факторов (a, b) выполняется a 6.

Факторы 36 в парах

Подводя итог, имеем следующее:

• Каждое число n можно записать как n = axb
• Если n — полный квадрат, то a = b = √n.
• А если a √n.
• В противном случае, если a > b, то a > √n и b Как изменить алгоритм is_prime() на O(√n)

• Чтобы вычислить квадратный корень числа, давайте импортируем встроенный математический модуль Python и используем функцию math.sqrt().
• Поскольку n не может быть идеальным квадратом, нам придется привести его к целому числу. Используйте int(var) для преобразования var в int.
• Чтобы убедиться, что мы действительно проверяем до √n, мы добавляем плюс один, поскольку функция range() по умолчанию исключает конечную точку диапазона.

Ячейка кода ниже подтверждает, что наша функция is_prime() работает правильно.

В следующем разделе давайте создадим несколько простых графиков, чтобы визуально понять O (n) и O (√ n).

Визуальное сравнение O(n) и O(√n)

▶️ Запустите следующий фрагмент кода в выбранной вами среде ноутбука Jupyter.

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

• Мы используем функцию NumPy arange() для создания массива чисел.
• Затем мы собираем значения n и √n до 20, но не включая их, в Панды DataFrame .
• Далее мы строим с помощью линейный график моряка() функция.

Из графика ниже видно, что √n значительно меньше n.

Давайте теперь увеличим диапазон до 2000 и повторим те же шаги, что и выше.

Из приведенного выше графика можно сделать вывод, что алгоритм O(√n) работает значительно быстрее, когда вы проверяете, является ли большое число простым.

Вот быстрый пример: 2377 — простое число — проверьте это!��

В то время как подход O(n) требует порядка 2000 шагов, алгоритм O(√n) может помочь получить ответ всего за 49 шагов.✅

Вывод

⏳ И настало время подвести итоги.

• Чтобы проверить, является ли число простым, наивный подход состоит в том, чтобы перебрать все числа в диапазоне (2, n-1). Если вы не найдете множитель, который делит n, то n — простое число.
• Поскольку единственный множитель n, превышающий n/2, — это само n, вы можете работать только до n/2.
• Оба вышеупомянутых подхода имеют временную сложность O (n).
• Поскольку множители числа встречаются парами, вы можете работать только до √n. Этот алгоритм намного быстрее, чем O (n). И выигрыш заметен при проверке, является ли большое число простым или нет.

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

Похожие публикации:

1. Как перенаправить dns запросы на другой сервер
2. Как вывести сообщение на экран
3. Npm run watch что это
4. Как вызвать функцию из статической библиотеки с