Данная работа рассматривает новый алгоритм поиска простых чисел методом исключений. Показывает закономерность расположения простых чисел в числовом ряду.
This article considers a new algorithm of searching of prime numbers by method of exceptions. Shows regularity of an arrangement of prime numbers in a numerical row.
Ключевые слова:
простые числа; ряд простых чисел; исключения
prime numbers; the number of Prime numbers; exceptions
УДК 511
Простое число- это такое число, которое делится на единицу и само себя.
Введение. Впервые свойства простых чисел начали изучать математики Древней Греции. В частности Эвклид В книге «Начал» доказал, что простых чисел бесконечное множество, далее, что каждое целое число можно представить единственным способом в виде произведения простых чисел и т.д.
В 200 году до н.э. грек Эратосфен придумал алгоритм для поиска простых чисел под названием «Решето Эратосфена».
Следующие открытия в этой области были сделаны уже в 17 веке математиком Ферма. Он доказал гипотезу Альбера Жирара, что любое простое число вида 4n+1 можно записать в виде суммы двух квадратов, сформулировал теорему, что любое число можно представить в виде суммы четырех квадратов. Доказал малую теорему Ферма и т.д.
Простые числа (Python)
Актуальность. В этой области математики работали такие ученые, как Эйлер, Люкас, Чебышев, Риман.
Однако в теории простых чисел имеется еще множество нерешенных вопросов, некоторым из которых сотни лет.[1]
По мере развития технического прогресса потребность в понимании таких вопросов, как:
- существует ли арифметическая прогрессия из последовательных простых чисел для любой заданной длины?
- бесконечно ли число наборов из трех последовательных простых чисел в арифметической прогрессии?
- содержит ли последовательность Фибоначчи бесконечное количество простых чисел? и т.д.
не уменьшается, а требует их решения.
Цели и задачи: при разработке алгоритма поиска простых чисел, мы исходили из необходимости определения закономерности расположения простых чисел в ряду натуральных чисел. Учитывая, специфику и сложность задачи, целью было также определение натуральных чисел(исключений), влияющих на математическую закономерность расположения простых чисел.
При определении алгоритма поиска простых чисел, мы использовали следующий метод.
Видеоуикенд #127. Пишем на Java алгоритм поиска простых чисел, знакомимся с программами автодополнения кода, узнаем о ниспадающем программировании в ООП и учимся бороться с техническим долгом
Вопросы, связанные с алгоритмами, встречаются на технических собеседованиях достаточно часто. Поэтому каждый потенциальный джуниор должен учесть это при подготовке к интервью. В этом видео показано, как написать алгоритм поиска простых чисел с примером на Java. Помимо решения задачи автор оценивает быстродействие своего алгоритма при поиске первого миллиона простых чисел.
Самопишущийся код
Как работают программы, которые самостоятельно пишут код? Могут ли они конкурировать с программистами и способны ли они изменить индустрию разработки программного обеспечения? На эти и многие другие вопросы ответят Никита Поваров и Роман Поборчий — представители компании JetBrains. Просмотрев это видео, вы узнаете, как автогенерация кода помогает ускорить работу программиста, и увидите работу таких программ на конкретных примерах из практики разработчиков JetBrains.
Ниспадающее программирование и его преимущества
Вячеслав Пыжьянов уже больше 10 лет программирует на Java. За это время он успел стать тимлидом группы разработки в компании Naumen. Недавно Вячеслав выступил с докладом, тема которого посвящена ниспадающему программированию. Просмотрев это выступление, вы узнаете об алгоритме действий для более эффективной разработки простого и понятного кода.
Еще одной темой доклада стал вопрос об ускорении процесса разработки. Доклад актуален для разработчиков любого уровня.
Как работать с техдолгом и техническими задачами в продуктовой команде
Командная разработка мобильных приложений требует соблюдения не только дедлайнов, но и целого ряда других факторов. Среди них не последнюю роль играют такие понятия, как технический долг и технозадачи. Илья Царев из команды Яндекс Go решил подробно рассказать, как подсчитать количество техдолга и как его оценивать. Кроме того докладчик объяснил, что нужно делать, чтобы технический долг не возникал, и как лучше решать эту проблему, если она все же появилась.
Источник: javarush.com
Программа для поиска простых чисел
Я хочу найти простое число между 0 и длинной переменной, но я не могу получить никакого вывода.
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication16 < class Program < void prime_num(long num) < bool isPrime = true; for (int i = 0; i > if (isPrime) < Console.WriteLine ( «Prime:» + i ); >isPrime = true; > > static void Main(string[] args) < Program p = new Program(); p.prime_num (999999999999999L); Console.ReadLine(); >> >
Кто-нибудь может мне помочь и найти, что является возможной ошибкой в программе?
user89147 02 окт ’09 в 15:07 2009-10-02 15:07
2009-10-02 15:07
28 ответов
Вы можете сделать это быстрее, используя почти оптимальное сито для пробного деления в одну (длинную) строку, например:
Enumerable.Range(0, Math.Floor(2.52*Math.Sqrt(num)/Math.Log(num))).Aggregate( Enumerable.Range(2, num-1).ToList(), (result, index) => < var bp = result[index]; var sqr = bp * bp; result.RemoveAll(i =>i >= sqr i % bp == 0); return result; > );
Обратите внимание, что сито Eratosthenes имеет гораздо лучшую сложность во время выполнения, чем пробное деление (должно работать намного быстрее для большего num значения, когда правильно реализовано).
user34397 02 окт ’09 в 15:17 2009-10-02 15:17
2009-10-02 15:17
void prime_num(long num) < // bool isPrime = true; for (long i = 0; i > if (isPrime) < Console.WriteLine ( «Prime:» + i ); >// isPrime = true; > >
user18255 02 окт ’09 в 15:18 2009-10-02 15:18
2009-10-02 15:18
Люди упомянули пару строительных блоков для того, чтобы сделать это эффективно, но на самом деле никто не сложил все вместе. Сито Эратосфена — хорошее начало, но с ним у вас не хватит памяти задолго до того, как вы достигнете установленного предела.
Это не значит, что это бесполезно — когда вы делаете свой цикл, вы действительно заботитесь о главных делителях. Таким образом, вы можете начать с использования сита для создания базы простых делителей, а затем использовать их в цикле для проверки чисел на первичность.
Однако, когда вы пишете цикл, вы на самом деле НЕ хотите, чтобы мы использовали sqrt (i) в условии цикла, как предложили несколько ответов. Мы с вами знаем, что sqrt — это «чистая» функция, которая всегда дает один и тот же ответ, если дан один и тот же входной параметр. К сожалению, компилятор НЕ знает этого, поэтому, если использовать что-то вроде ‘ i
Вероятно, этого достаточно для размера чисел, с которыми вы имеете дело — ограничение в 15 цифр означает, что квадратный корень составляет 7 или 8 цифр, что вписывается в довольно разумный объем памяти. С другой стороны, если вы хотите много работать с числами в этом диапазоне, вы можете рассмотреть некоторые из более сложных алгоритмов простой проверки, такие как алгоритмы Полларда или Брента. Они более сложны (мягко говоря), но намного быстрее для больших чисел.
Существуют и другие алгоритмы для еще больших чисел ( квадратичное сито, общее сито поля чисел), но мы пока не будем в них разбираться — они намного сложнее и действительно полезны только для работы с действительно большими числами (GNFS начинает быть полезной в диапазоне от 100 цифр).
user179910 02 окт ’09 в 16:55 2009-10-02 16:55
2009-10-02 16:55
Вам нужно только проверить нечетные делители до квадратного корня из числа. Другими словами, ваш внутренний цикл должен запуститься:
for (int j = 3; j
Вы также можете выйти из функции, как только вы обнаружите, что число не простое, вам больше не нужно проверять делители (я вижу, вы уже это делаете!).
Это будет работать, только если num больше двух.
Нет Sqrt
Вы можете избежать Sqrt в целом, сохраняя текущую сумму. Например:
int square_sum=1; for (int j=3; square_sum
Это потому, что сумма чисел 1+(3+5)+(7+9) даст вам последовательность нечетных квадратов (1,9,25 и т. Д.). И поэтому j представляет квадратный корень из square_sum , Пока square_sum меньше чем i затем j меньше квадратного корня.
user441661 02 окт ’09 в 15:18 2009-10-02 15:18
2009-10-02 15:18
Первый шаг: напишите метод расширения, чтобы узнать, является ли вход простым
public static bool isPrime(this int number ) < for (int i = 2; i < number; i++) < if (number % i == 0) < return false; >> return true; >
2 шаг: напишите метод, который будет печатать все простые числа от 0 до числа, введенного
public static void getAllPrimes(int number) < for (int i = 0; i < number; i++) < if (i.isPrime()) Console.WriteLine(i); >>
user1322557 17 апр ’12 в 15:50 2012-04-17 15:50
2012-04-17 15:50
Это может быть только мое мнение, но есть еще одна серьезная ошибка в вашей программе (за исключением заданного вопроса «простого числа», на который был дан исчерпывающий ответ).
Как и остальные респонденты, я предполагаю, что это домашняя работа, которая указывает на то, что вы хотите стать разработчиком (предположительно).
Вам нужно научиться разделять ваш код. Это не то, что вам всегда нужно делать в проекте, но полезно знать, как это сделать.
Ваш метод prime_num (long num) может иметь лучшее, более понятное имя. И если предполагается найти все простые числа меньше заданного числа, он должен вернуть их в виде списка. Это облегчает разделение вашего дисплея и вашей функциональности.
Если бы он просто возвратил IList, содержащий простые числа, вы могли бы затем отобразить их в своей основной функции (возможно, вызвав другую внешнюю функцию, чтобы красиво их напечатать), или использовать их в дальнейших вычислениях.
Поэтому моя лучшая рекомендация для вас — сделать что-то вроде этого:
public void main(string args[]) < //Get the number you want to use as input long x = number;//’number’ can be hard coded or retrieved from ReadLine() or from the given arguments IListprimes = FindSmallerPrimes(number); DisplayPrimes(primes); > public IList FindSmallerPrimes(long largestNumber) < ListreturnList = new List(); //Find the primes, using a method as described by another answer, add them to returnList return returnList; > public void DisplayPrimes(IList primes) < foreach(long l in primes) < Console.WriteLine ( «Prime:» + l.ToString() ); >>
Даже если вы в конечном итоге работаете где-то, где такие слова не нужны, полезно знать, как это сделать.
user23902 02 окт ’09 в 16:32 2009-10-02 16:32
2009-10-02 16:32
EDIT_ADD: Если Уилл Несс прав, то цель вопроса состоит в том, чтобы просто вывести непрерывный поток простых чисел в течение всего времени работы программы (нажатие кнопки «Пауза / Разрыв» для паузы и любая клавиша для повторного запуска) без какой-либо серьезной надежды на то, что каждый получит этот верхний предел, тогда код должен быть написан без аргумента верхнего предела и проверки диапазона «true» для первого цикла «i» for. С другой стороны, если вопрос хотел на самом деле вывести простые числа до предела, то следующий код сделает работу намного эффективнее, используя пробное деление только для нечетных чисел, с тем преимуществом, что он вообще не использует память (это также может быть преобразовано в непрерывный цикл согласно приведенному выше):
static void primesttt(ulong top_number) < Console.WriteLine(«Prime: 2»); for (var i = 3UL; i > if (isPrime) Console.WriteLine(«Prime: «, i); > >
Во-первых, код вопроса не производит вывод, потому что его переменные цикла являются целыми числами, а проверяемый предел является огромным длинным целым числом, что означает, что цикл не может достичь предела, создавая внутренний цикл. EDITED: при этом переменная ‘j’ возвращается к отрицательным числам; когда переменная ‘j’ возвращается к -1, проверенное число не проходит простое тестирование, поскольку все числа делятся на -1 END_EDIT. Даже если это было исправлено, код вопроса производит очень медленный вывод, потому что он связан с выполнением 64-битного деления очень большого количества составных чисел (все четные числа плюс нечетные составные) на весь диапазон чисел до этой вершины. число десять возведено в шестнадцатую степень для каждого простого числа, которое оно может произвести. Вышеприведенный код работает, потому что он ограничивает вычисление только нечетными числами и делает только деление по модулю до квадратного корня текущего проверяемого числа.
Чтобы отобразить простые числа до миллиарда, требуется час или около того, поэтому можно представить, сколько времени потребуется, чтобы показать все простые числа до десяти тысяч триллионов (от 10 до шестнадцатой степени), особенно когда вычисления становятся медленнее с увеличением дальности. END_EDIT_ADD
На самом деле это злоупотребление методом Linq Aggregate, и он не использует эффективно первый из двух сгенерированных диапазонов Linq. Он может стать оптимизированным пробным отделом с меньшими накладными расходами перечисления следующим образом:
static IEnumerable primes(uint top_number) < var cullbf = Enumerable.Range(2, (int)top_number).ToList(); for (int i = 0; i < cullbf.Count; i++) < var bp = cullbf[i]; var sqr = bp * bp; if (sqr >top_number) break; cullbf.RemoveAll(c => c >= sqr c % bp == 0); > return cullbf; >
который работает во много раз быстрее, чем ответ SLaks. Тем не менее, он все еще медленный и занимает много памяти из-за генерации списка и нескольких перечислений, а также операций множественного деления (подразумеваемых по модулю).
Следующая истинная реализация Sieve of Eratosthenes работает примерно в 30 раз быстрее и занимает гораздо меньше памяти, поскольку использует только одноразрядное представление для каждого просеянного числа и ограничивает его перечисление до конечной выходной последовательности итератора, а также оптимизирует обработку только нечетных композиций, и отбраковывают только квадраты базовых простых чисел для базовых простых чисел до квадратного корня из максимального числа, как указано ниже:
static IEnumerable primes(uint top_number) < if (top_number < 2u) yield break; yield return 2u; if (top_number < 3u) yield break; var BFLMT = (top_number — 3u) / 2u; var SQRTLMT = ((uint)(Math.Sqrt((double)top_number)) — 3u) / 2u; var buf = new BitArray((int)BFLMT + 1,true); for (var i = 0u; i yield return p; > >
Приведенный выше код вычисляет все простые числа до десяти миллионов в диапазоне около 77 миллисекунд на Intel i7-2700K (3,5 ГГц).
Любой из двух статических методов может быть вызван и протестирован с помощью операторов using и статического метода Main следующим образом:
using System; using System.Collections; using System.Collections.Generic; using System.Linq; static void Main(string[] args) < Console.WriteLine(«This program generates prime sequences.rn»); var n = 10000000u; var elpsd = -DateTime.Now.Ticks; var count = 0; var lastp = 0u; foreach (var p in primes(n)) < if (p >n) break; ++count; lastp = (uint)p; > elpsd += DateTime.Now.Ticks; Console.WriteLine( » primes found ; the last one is in milliseconds.», count, n, lastp,elpsd / 10000); Console.Write(«rnPress any key to exit:»); Console.ReadKey(true); Console.WriteLine(); >
который покажет число простых чисел в последовательности до предела, последнее найденное простое число и время, затраченное на перечисление этого расстояния.
EDIT_ADD: Однако, чтобы произвести перечисление числа простых чисел менее десяти тысяч триллионов (от десяти до шестнадцатой степени), как задается вопрос, требуется сегментированный постраничный подход с использованием многоядерной обработки, но даже с C++ и очень Оптимизированная PrimeSieve, для создания числа найденных простых чисел потребуется более 400 часов, а для перечисления всех их в десятки раз больше времени, чтобы выполнить заданный вопрос. Чтобы сделать это с использованием неоптимизированного алгоритма Trial Division, понадобятся супер-эоны и очень-очень долгое время даже при использовании оптимизированного алгоритма Trial Division, как, например, от десяти до двух миллионов энергетических лет (это два миллиона нулей!!).
Неудивительно, что его настольный компьютер просто сидел и зависал, когда пытался это сделать. Если бы он попробовал меньший диапазон, такой как миллион, он все равно обнаружил бы, что он реализуется в диапазоне секунд.
Решения, которые я выкладываю здесь, тоже не сработают, поскольку даже последнему сите Эратосфена потребуется около 640 терабайт памяти для этого диапазона.
Вот почему только сегментированный на странице подход, такой как PrimeSieve, может решить такую проблему для заданного диапазона, и даже это требует очень длительного времени, например, от нескольких недель до нескольких лет, если только у вас нет доступа к суперкомпьютеру с сотни тысяч ядер. END_EDIT_ADD
Источник: stackru.com