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

Простое число

Простое число – это натуральное число, которое делиться без остатка на себя и на единицу.

Метод для проверки, является ли число простым

Исходя из определения простоты числа, напишем метод для проверки.

Простое число должно удовлетворять условиям:

• Быть больше единицы – условие проверим с помощью условного оператора if;
• Делиться нацело только на один и на себя – в цикле проверим делиться ли N нацело на числа из диапазона от 2 до N-1.

public static bool IsPrimeNumber(uint n) < var result = true; if (n > 1) < for (var i = 2u; i < n; i++) < if (n % i == 0) < result = false; break; > > > else < result = false; > return result; > 

Если число, которое передается в качестве аргумента метода, является простым, метод возвращает значение true и false в противном случае.

Использование метода для проверки числа N на простоту

Простые числа из диапазона от 0 до N

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

Программа позволяющая вывести простые числа из отрезка:

static void Main(string[] args) < Console.Write("N hljs-keyword">var n = Convert.ToUInt32(Console.ReadLine()); Console.WriteLine("Простые числа из диапазона (, )", 0, n); for (var i = 0u; i < n; i++) < if (IsPrimeNumber(i)) < Console.Write($" "); > > Console.ReadLine(); > 

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

N первых простых чисел

После небольшой модификации программы, можем вывести необходимое количество простых чисел.

Программа позволяющая вывести на экран N первых простых чисел:

static void Main(string[] args) < Console.Write("N hljs-keyword">var n = Convert.ToUInt32(Console.ReadLine()); Console.WriteLine(" первых простых чисел", n); var count = 0u; var i = 0u; while (count < n) < if (IsPrimeNumber(i)) < Console.Write(i); if (count < n - 1) < Console.Write(", "); > count++; > i++; > Console.ReadLine(); > 

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

Программирование на C, C# и Java

Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы

ОСТОРОЖНО МОШЕННИКИ! В последнее время в соиальных сетях учстились случаи педложения помощи в написании прогамм от лиц, прикрвающихся сайтом vscode.ru. Мы никогда не пишем первыми и не размещаем никакие материалы в псторонних группах ВК. Для связи с нами используйте исключительно эти контакт: vscoderu@yandex.ru, https://vk.com/vscode

Является ли число простым — Проверяем на языке Си

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

Простое число — определение

Простое число — это натуральное число (то есть целое и положительное), большее, чем единица, которое делится без остатка только на единицу и само на себя.

Список простых чисел (приведем до ста) начинается так: 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…

Функция на Си, проверяющая — является ли число простым

Напишем на языке Си функцию, которая будет проверять — простое ли число. И возвращать результат проверки в виде логической величины bool: true (да) или false (нет).

// функция проверяет — простое ли число n
bool isPrime ( int n )
// в цикле перебираем числа от 2 до n — 1
for ( int i = 2 ; i < n ; i ++ ) if ( n % i == 0 ) // если n делится без остатка на i - возвращаем false (число не простое) return false ; // если программа дошла до данного оператора, то возвращаем true (число простое) - проверка пройдена return true ; else // иначе возвращаем false (число не простое) return false ;

Алгоритм проверки числа n на простоту строится на определении термина простого числа.

Во-первых число n должно быть больше 1 (проверяем это в строке 5 с помощью условного оператора if), а во-вторых проверяемое число должно иметь только два делителя: 1 и n (проверяем это в строках 8-10 с помощью цикла for и оператора if).

Для работы данного метода требуется подключить заголовочный файл stdbool.h в начале файла с исходным кодом. В stdbool.h содержится определение логических констант true и false, поскольку в чистой версии языка Си они отсутствуют.

Для подключения используем директиву include:

Как определить простое число

Задача 2.30
Дан одномерный массив А, состоящий из натуральных чисел. Вывести на экран количество простых чисел в массиве.

Для начала напомню, что такое простые числа.

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

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

Например, простыми числами являются 2, 3, 5 и т.п.

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

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

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

Как определить простое число в Паскале

Алгоритм решения с подробным разбором приведу на Паскале. Решение на С++ можете посмотреть в примере программы на С++.

ВАЖНО!
На этом многие могут ошибиться. В определении сказано, что простое число имеет ровно два различных делителя. Следовательно, число 1 не является простым (также не является простым, так как ноль можно делить на любые числа).

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

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

А вот если число N будет больше трёх, то в этом случае в цикле будем перебирать все возможные делители, начиная от 2 до (N-1). Если на какой-то делитель число N делится без остатка, значит, это тоже не простое число. В этом случае мы прерываем цикл (потому что проверять дальше нет смысла), а функция возвращает FALSE.

Проверять, делится ли число на самоё себя нет смысла (поэтому цикл длится только до N-1).

Саму функцию здесь приводить не буду — посмотрите её в примерах программ.

Решение задачи 2.30 на Паскале

program mytask; //**************************************************************** // КОНСТАНТЫ //**************************************************************** const COUNT = 100; //Количество элементов в массиве //**************************************************************** // ФУНКЦИИ И ПРОЦЕДУРЫ //**************************************************************** //**************************************************************** // Проверяет, является ли число простым // ВХОД : N - число // ВЫХОД : TRUE - число N простое, FALSE - не простое //**************************************************************** function IsPrimeNumber(N : WORD) : boolean; var i : WORD; begin Result := TRUE; case N of 0..3 : begin if N < 2 then Result := FALSE; //Не простое число Exit; end; end; for i := 2 to (N-1) do if (N mod i) = 0 then //Не простое число begin Result := FALSE; Break; end; end; var i : WORD; X : WORD = 0; A : array[1..COUNT] of WORD; //**************************************************************** // ОСНОВНАЯ ПРОГРАММА //**************************************************************** begin //Заполнить массив числами for i := 1 to COUNT do A[i] := i; //Подсчитать и выбрать простые числа из массива for i := 1 to COUNT do if IsPrimeNumber(A[i]) then begin Inc(X); Write(A[i], ' '); end; WriteLn(#10#13'Number of Prime numbers = ', X); WriteLn('The end. Press ENTER. '); ReadLn; end.

Решение задачи 2.30 на С++
#include #include using namespace std; //**************************************************************** // КОНСТАНТЫ //**************************************************************** const int COUNT = 100; //Количество элементов в массиве //**************************************************************** // ФУНКЦИИ И ПРОЦЕДУРЫ //**************************************************************** //**************************************************************** // Проверяет, является ли число простым // ВХОД : N - число // ВЫХОД : TRUE - число N простое, FALSE - не простое //**************************************************************** bool IsPrimeNumber(int N) < bool Res = true; switch (N) < case 0 : Res = false; break; case 1 : Res = false; break; case 2 : Res = true; break; case 3 : Res = true; break; default : for (int i = 2; i < N; i++) if (0 == (N % i)) //Не простое число < Res = false; break; >> return(Res); > //**************************************************************** // ОСНОВНАЯ ПРОГРАММА //**************************************************************** int main(int argc, char *argv[]) < int A[COUNT]; int X = 0; //Заполнить массив числами for (int i = 0; i < COUNT; i++) A[i] = i; //Подсчитать и выбрать простые числа из массива for (int i = 0; i < COUNT; i++) if (IsPrimeNumber(A[i])) < X++; cout ; cout

Алгоритмы поиска простых чисел

«Самое большое простое число 2 32582657 -1. И я с гордостью утверждаю, что запомнил все его цифры… в двоичной форме».
Карл Померанс

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

Решето Эратосфена

Решето Эратосфена — алгоритм, предложенный древнегреческим математиком Эратосфеном. Этот метод позволяет найти все простые числа меньше заданного числа n. Суть метода заключается в следующем. Возьмем набор чисел от 2 до n. Вычеркнем из набора (отсеим) все числа делящиеся на 2, кроме 2. Перейдем к следующему «не отсеянному» числу — 3, снова вычеркиваем все что делится на 3. Переходим к следующему оставшемуся числу — 5 и так далее до тех пор пока мы не дойдем до n. После выполнения вышеописанных действий, в изначальном списке останутся только простые числа.

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

Иллюстрация работы алгоритма из Википедии:

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

Существует ряд оптимизаций, позволяющих снизить эти показатели. Прием под названием wheel factorization состоит в том, чтобы включать в изначальный список только числа взаимно простые с несколькими первыми простыми числами (например меньше 30). В теории предлагается брать первые простые примерно до . Это позволяет снизить сложность алгоритма в раз. Помимо этого для уменьшения потребляемой памяти используется так называемое сегментирование. Изначальный набор чисел делится на сегменты размером и для каждого сегмента решето Эратосфена применяется по отдельности. Потребление памяти снижается до .

Решето Аткина

Более совершенный алгоритм отсеивания составных чисел был предложен Аткином и Берштайном и получил название Решето Аткина. Этот способ основан на следующих трех свойствах простых чисел.

Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.

Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.

Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.

Доказательства этих свойств приводятся в этой статье.

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

Из описания алгоритма следует, что вычислительная сложность решета Аткина и потребление памяти составляют . При использовании wheel factorization и сегментирования оценка сложности алгоритма снижается до , а потребление памяти до .

Числа Мерсенна и тест Люка-Лемера

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

Один из таких методов проверки — тест Люка-Лемера. Это детерминированный и безусловный тест простоты. Это означает, что прохождение теста гарантирует простоту числа. К сожалению, тест предназначен только для чисел особого вида , где p — натуральное число. Такие числа называются числами Мерсенна.

Тест Люка-Лемера утверждает, что число Мерсенна простое тогда и только тогда, когда p — простое и делит нацело -й член последовательности задаваемой рекуррентно: для .

Для числа длиной p бит вычислительная сложность алгоритма составляет .

Благодаря простоте и детерминированности теста, самые большие известные простые числа — числа Мерсенна. Самое большое известное простое число на сегодня — , его десятичная запись состоит из 24,862,048 цифр. Полюбоваться на эту красоту можно здесь.

Теорема Ферма и тест Миллера-Рабина

Простых чисел Мерсенна известно не очень много, поэтому для криптографии с открытым ключом необходим другой способ поиска простых чисел. Одним из таким способов является тест простоты Ферма. Он основан на малой теореме Ферма, которая гласит, что если n — простое число, то для любого a, которое не делится на n, выполняется равенство . Доказательство теоремы можно найти на Википедии.

Тест простоты Ферма — вероятностный тест, который заключается в переборе нескольких значений a, если хотя бы для одного из них выполняется неравенство , то число n — составное. В противном случае, n — вероятно простое. Чем больше значений a использовано в тесте, тем выше вероятность того, что n — простое.

К сожалению, существуют такие составные числа n, для которых сравнение выполняется для всех a взаимно простых с n. Такие числа называются числам Кармайкла. Составные числа, которые успешно проходят тест Ферма, называются псевдопростыми Ферма. Количество псевдопростых Ферма бесконечно, поэтому тест Ферма — не самый надежный способ определения простых чисел.

Тест Миллера-Рабина

Более надежных результатов можно добиться комбинируя малую теорему Ферма и тот факт, что для простого числа p не существует других корней уравнения , кроме 1 и -1. Тест Миллера-Рабина перебирает несколько значений a и проверяет выполнение следующих условий.

Пусть p — простое число и , тогда для любого a справедливо хотя бы одно из условий:

1. Существует целое число r < sтакое, что

Чем больше свидетелей простоты найдено, тем выше вероятность того, что n — простое. Согласно теореме Рабина вероятность того, что случайно выбранное число a окажется свидетелем простоты составного числа составляет приблизительно .

Следовательно, если проверить k случайных чисел a, то вероятность принять составное число за простое .

Сложность работы алгоритма , где k — количество проверок.

Благодаря быстроте и высокой точности тест Миллера-Рабина широко используется при поиске простых чисел. Многие современные криптографические библиотеки при проверке больших чисел на простоту используют только этот тест и, как показал Мартин Альбрехт в своей работе , этого не всегда оказывается достаточно.

Он смог сгенерировать такие составные числа, которые успершно прошли тест на простоту в библиотеках OpenSSL, CryptLib, JavaScript Big Number и многих других.

Тест Люка и Тест Baillie–PSW

Чтобы избежать уязвимости, связанные с ситуациями, когда сгенерированное злоумышленником составное число, выдается за простое, Мартин Альбрехт предлагает использовать тест Baillie–PSW. Несмотря на то, что тест Baillie–PSW является вероятностным, на сегодняшний день не найдено ни одно составное число, которое успешно проходит этот тест. За нахождение подобного числа в 1980 году авторы алгоритма пообещали вознаграждение в размере $30. Приз пока так и не был востребован.

Ряд исследователей проверили все числа до и не обнаружили ни одного составного числа, прошедшего тест Baillie–PSW. Поэтому, для чисел меньше тест считается детерминированным.

Суть теста сводится к последовательной проверке числа на простоу двумя различными методами. Один из этих методов уже описанный выше тест Миллера-Рабина. Второй — тест Люка на сильную псевдопростоту.

Тест Люка на сильную псевдопростоту

Последовательности Люка — пары рекуррентных последовательностей , описываемые выражениями:

Пусть и — последовательности Люка, где целые числа P и Q удовлетворяют условию

Найдем такие r, s для которых выполняется равенство

Для простого числа n выполняется одно из следующих условий:

1. n делит
2. n делит для некоторого j < r

Вероятность того, что составное число n успешно пройдет тест Люка для заданной пары параметров P, Q не превышает 4/15. Следовательно, после применения теста k раз, эта вероятность составляет .

Тесты Миллера-Рабина и Люка производят не пересекающиеся множества псевдопростых чисел, соответственно если число p прошло оба теста, оно простое. Именно на этом свойстве основывается тест Baillie–PSW.

Заключение

В зависимости от поставленной задачи, могут использоваться различные методы поиска простых чисел. К примеру, при поиске больших простых чисел Мерсенна, сперва, при помощи решета Эратосфена или Аткина определяется список простых чисел до некоторой границы, предположим, до . Затем для каждого числа p из списка, с помощью теста Люка-Лемера, на простоту проверяется .

Чтобы сгенерировать большое простое число в криптографических целях, выбирается случайное число a и проверяется тестом Миллера-Рабина или более надежным Baillie–PSW. Согласно теореме о распределении простых чисел, у случайно выбранного числа от 1 до n шанс оказаться простым примерно равен . Следовательно, чтобы найти простое число размером 1024 бита, достаточно перебрать около тысячи вариантов.

P.S. Исходники

Реализацию всех описанных алгоритмов на Go можно посмотреть на GitHub.

• Простые числа
• Тест Миллера-Рабина
• Тест Люка
• Числа Мерсенна
• Решето Эратосфена
• Решето Аткина
• Baillie–PSW