Программа для поиска простых чисел

Ответ 1

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

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; 
    }
);

Формула приближения для числа простых чисел, используемых здесь, π(x) < 1.26 x / ln(x). Нам нужно только проверять простые числа, не превышающие x = sqrt(num).

Обратите внимание, что сито

Ответ 2

Попробуйте следующее:

void prime_num(long num)
{

    // bool isPrime = true;
    for (long i = 0; i <= num; i++)
    {
        bool isPrime = true; // Move initialization to here
        for (long j = 2; j < i; j++) // you actually only need to check up to sqrt(i)
        {
            if (i % j == 0) // you don't need the first condition
            {
                isPrime = false;
                break;
            }
        }
        if (isPrime)
        {
            Console.WriteLine ( "Prime:" + i );
        }
        // isPrime = true;
    }
}

Ответ 3

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

Однако, когда вы пишете цикл, вы на самом деле НЕ хотите, чтобы мы использовали sqrt (i) в условии цикла, как предложили несколько ответов. Мы с вами знаем, что sqrt - это "чистая" функция, которая всегда дает один и тот же ответ, если дан один и тот же входной параметр. К сожалению, компилятор НЕ знает этого, поэтому, если использовать что-то вроде '<= Math.sqrt(x)' в условии цикла, он будет пересчитывать sqrt числа на каждой итерации цикла.

Вы можете избежать этого несколькими разными способами. Вы можете либо предварительно вычислить sqrt перед циклом, и использовать предварительно вычисленное значение в условии цикла, либо вы можете работать в другом направлении и изменить i<Math.sqrt(x) на i*i<x. Лично я бы предварительно вычислил квадратный корень - хотя я думаю, что он более понятен и, возможно, немного быстрее - но это зависит от количества итераций цикла (i*i означает, что он все еще выполняет умножение в цикле). С помощью всего лишь нескольких итераций, i*i, как правило, будет быстрее. При достаточном количестве итераций потери от i*i каждую итерацию перевешивают время выполнения sqrt за пределами цикла.

Вероятно, этого достаточно для размера чисел, с которыми вы имеете дело - ограничение в 15 цифр означает, что квадратный корень составляет 7 или 8 цифр, что вписывается в довольно разумный объем памяти. С другой стороны, если вы хотите много работать с числами в этом диапазоне, возможно, вы захотите взглянуть на некоторые из более сложных алгоритмов первичной проверки, таких как алгоритмы Полларда или Брента. Они более сложны (мягко говоря), но намного быстрее для больших чисел.

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

Ответ 4

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

for (int j = 3; j <= Math.Sqrt(i); j+=2) { ... }

Вы также можете выйти из функции, как только увидите, что число не является простым, вам не нужно проверять больше делителей (я вижу, вы уже это делаете!).

Это будет работать, только если число больше двух.

Нет Sqrt

Вы можете полностью избежать Sqrt, сохранив текущую сумму. Например:

int square_sum=1;
for (int j=3; square_sum<i; square_sum+=4*(j++-1)) {...}

Это потому, что сумма чисел 1+ (3 + 5) + (7 + 9) даст вам последовательность нечетных квадратов (1,9,25 и т.д.). И, следовательно, j представляет собой квадратный корень из square_sum. Пока square_sum меньше i, тогда j меньше квадратного корня.

Ответ 5

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

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);
    }
}

Ответ 6

Это может быть только мое мнение, но есть еще одна серьезная ошибка в вашей программе (отмена заданного "простого номера" вопроса, на который был дан ответ).

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

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

Ваш метод 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

    IList<long> primes = FindSmallerPrimes(number);

    DisplayPrimes(primes);
}

public IList<long> FindSmallerPrimes(long largestNumber)
{
    List<long> returnList = new List<long>();
    //Find the primes, using a method as described by another answer, add them to returnList
    return returnList;
}

public void DisplayPrimes(IList<long> primes)
{
    foreach(long l in primes)
    {
        Console.WriteLine ( "Prime:" + l.ToString() );
    }
}

Даже если вы в конечном итоге работаете где-то там, где такая сфера не нужна, хорошо знать, как это сделать.

Ответ 7

EDIT_ADD: Если Will Ness прав, что цель вопроса состоит в том, чтобы вывести непрерывный поток простых чисел до тех пор, пока программа запускается (нажатие Pause/Break для паузы и любая клавиша для запуска снова), не испытывая серьезной надежды на то, что каждый из них достигнет этого верхнего предела, тогда код должен быть написан без аргумента верхнего предела и проверки диапазона "истина" для первого цикла "i". С другой стороны, если бы вопрос хотел на самом деле напечатать простые числа до предела, то следующий код будет выполнять работу гораздо эффективнее, используя Trial Division только для нечетных чисел, с тем преимуществом, что он вообще не использует память (он также может быть преобразован в непрерывный цикл в соответствии с приведенным выше):

static void primesttt(ulong top_number) {
  Console.WriteLine("Prime:  2");
  for (var i = 3UL; i <= top_number; i += 2) {
    var isPrime = true;
    for (uint j = 3u, lim = (uint)Math.Sqrt((double)i); j <= lim; j += 2) {
      if (i % j == 0)  {
        isPrime = false;
        break;
      }
    }
    if (isPrime) Console.WriteLine("Prime:  {0} ", i);
  }
}

Во-первых, код вопроса не выводит из-за того, что его переменные цикла являются целыми числами, а проверенный лимит является огромным длинным целым числом, что означает, что цикл не достигнет предела, создавая внутренний цикл EDITED:, в результате чего переменная 'j' возвращается назад к отрицательным числам; когда переменная 'j' возвращается к -1, тестируемое число терпит неудачу в первом тесте, потому что все числа равномерно делятся на -1 END_EDIT. Даже если бы это было исправлено, код вопроса производит очень медленный вывод, потому что он связан с 64-разрядными делениями очень больших количеств составных чисел (все четные числа плюс нечетные композиты) на весь диапазон чисел до этой вершины число десяти увеличилось до шестнадцатой власти за каждое премьер, которое оно может произвести. Вышеприведенный код работает, потому что он ограничивает вычисление только нечетными числами и только делает модульные деления до квадратного корня текущего тестируемого числа.

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

Хотя один liner (вид) отвечает на @SLaks, используя Linq работает, это не действительно сито Eratosthenes, поскольку это просто неоптимизированная версия Пробный отдел, неоптимизированный тем, что он не устраняет нечетные простые числа, не начинается с квадрата найденного базового штриха и не прекращает отбраковывать базовые простые числа, превышающие квадратный корень верхнего номера, до сито. Это также довольно медленно из-за множества вложенных операций перечисления.

На самом деле это злоупотребление методом Linq Aggregate и эффективно не использует первый из двух генерируемых диапазонов Linq. Он может стать оптимизированным пробным подразделением с меньшими издержками перечисления следующим образом:

static IEnumerable<int> 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. Тем не менее, он по-прежнему медленный и интенсивный в памяти из-за генерации List и множественных перечислений, а также множественного деления (подразумеваемого по модулю).

Следующая реалистичная реализация Sieve of Eratosthenes выполняется примерно в 30 раз быстрее и занимает гораздо меньше памяти, так как она использует только однобитовое представление на пронумерованное количество и ограничивает его перечисление конечным выходом последовательности итератора, а также оптимизирует только обработку нечетные композиты и только отбраковывают из квадратов базовых простых чисел для базовых простых чисел до квадратного корня из максимального числа следующим образом:

static IEnumerable<uint> 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 <= BFLMT; ++i) if (buf[(int)i]) {
      var p = 3u + i + i; if (i <= SQRTLMT) {
        for (var j = (p * p - 3u) / 2u; j <= BFLMT; j += p)
          buf[(int)j] = false; } 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.\r\n");

  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(
    "{0} primes found <= {1}; the last one is {2} in {3} milliseconds.",
    count, n, lastp,elpsd / 10000);

  Console.Write("\r\nPress any key to exit:");
  Console.ReadKey(true);
  Console.WriteLine();
}

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

EDIT_ADD: Однако для получения перечисления количества простых чисел менее десяти тысяч триллионов (от десяти до шестнадцатой), как задается вопросом, сегментированный подкапотный подход с использованием многоядерных требуется обработка, но даже с С++ и очень оптимизированным PrimeSieve, это потребовало бы чего-то более 400 часов, чтобы просто получить количество найденных простых чисел, и десятки раз, чтобы их перечислить, поэтому в течение года, чтобы сделать то, что задает вопрос. Чтобы сделать это с использованием не оптимизированного алгоритма пробной деления, попытка потребовала суперэнов и очень долгое время даже с использованием оптимизированного алгоритма Trial Division, как в чем-то вроде десяти-двухмиллионных лет (это два миллиона нулей лет!!).

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

Решения, которые я размещаю здесь, не сократят его, так как даже последнее сито из Eratosthenes потребует около 640 терабайт памяти для этого диапазона.

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

Ответ 8

Пахнет больше домашней работой. У моего очень старого графического калькулятора была такая простая программа. Технически цикл проверки внутреннего отклонения должен выполняться только до я ^ (1/2). Вам нужно найти "все" простые числа между 0 и L? Другая серьезная проблема заключается в том, что ваши переменные цикла являются "int", в то время как ваши входные данные "длинны", это вызовет переполнение, из-за чего ваши циклы не выполняются даже один раз. Зафиксируйте переменные цикла.

Ответ 9

Один код строки в С#: -

Console.WriteLine(String.Join(Environment.NewLine, 
    Enumerable.Range(2, 300)
        .Where(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1)
        .All(nn => n % nn != 0)).ToArray()));                                    

Ответ 10

Сито Эратосфена, приведенное выше, не совсем корректно. Как написано, он найдет все простые числа от 1 до 1000000. Чтобы найти все простые числа от 1 до num, используйте:

private static IEnumerable Primes01(int num)
{
    return Enumerable.Range(1, Convert.ToInt32(Math.Floor(Math.Sqrt(num))))
        .Aggregate(Enumerable.Range(1, num).ToList(),
        (result, index) =>
            {
                result.RemoveAll(i => i > result[index] && i%result[index] == 0);
                return result;
            }
        );
}

Семя Агрегата должно быть от 1 до num, так как этот список будет содержать окончательный список простых чисел. Enumerable.Range(1, Convert.ToInt32(Math.Floor(Math.Sqrt(num)))) - количество раз, когда семя очищается.

Ответ 11

так что это в основном только два опечатки, один, самый неудачный, for (int j = 2; j <= num; j++), который является причиной непроизводительного тестирования 1%2,1%3 ... 1%(10^15-1), который продолжается очень долго, поэтому OP didn "получить" любой результат ". Вместо этого он должен был j < i;. Другим, второстепенным в сравнении, является то, что i должен начинаться с 2, а не с 0:

for( i=2; i <= num; i++ )
{
    for( j=2; j < i; j++ ) // j <= sqrt(i) is really enough
....

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

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

Вторая альтернатива, с гораздо большей сложностью (т.е. намного быстрее) заключается в использовании сегментированного сита Eratosthenes. Что является инкрементным и неограниченным.

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

Ответ 12

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

Алгоритм на странице также принимает несколько ярлыков (нечетные числа и проверяет только до квадратного корня), что делает его чрезвычайно эффективным, и это позволит вам вычислять длинные числа.

Ответ 13

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

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

Я не буду давать полной реализации, так как это было бы легко, это подход в псевдокоде. (На моей машине фактическая реализация вычисляет все простые числа в Sytem.Int32 (2 биллиона) в течение 8 секунд.

public IEnumerable<long> GetPrimes(long max)
{
    // we safe the result set in an array of bytes.
    var buffer = new byte[long >> 4];
    // 1 is not a prime.
    buffer[0] = 1;

    var iMax = (long)Math.Sqrt(max);

    for(long i = 3; i <= iMax; i +=2 )
    {
        // find the index in the buffer
        var index = i >> 4;
        // find the bit of the buffer.
        var bit = (i >> 1) & 7;

        // A not set bit means: prime
        if((buffer[index] & (1 << bit)) == 0)
        {
            var step = i << 2;
            while(step < max)
            {
                // find position in the buffer to write bits that represent number that are not prime.
            }
        }
        // 2 is not in the buffer.
        yield return 2;

        // loop through buffer and yield return odd primes too.
    }
}

Решение требует хорошего понимания побитовых операций. Но это пути, и пути быстрее. Вы также можете защитить результат результата на диске, если вам это нужно для последующего использования. Результат 17 * 10 ^ 9 номеров может быть защищен с 1 ГБ, а расчет этого набора результатов занимает максимум 2 минуты.

Ответ 14

Я знаю, что это тихий старый вопрос, но после прочтения здесь: Сито Эратосфена Wiki

Так я написал это из понимания алгоритма:

void SieveOfEratosthenes(int n)
{
    bool[] primes = new bool[n + 1];

    for (int i = 0; i < n; i++)
        primes[i] = true;

    for (int i = 2; i * i <= n; i++)
        if (primes[i])
            for (int j = i * 2; j <= n; j += i)
                primes[j] = false;

    for (int i = 2; i <= n; i++)
        if (primes[i]) Console.Write(i + " ");
}

В первом цикле мы заполняем массив логических значений с помощью true.

Второй цикл цикла начинается с 2, поскольку 1 не является простым числом и проверяет, не поменяется ли простое число, а затем присваивает false индексу j.

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

Ответ 15

Очень похоже - из упражнения для реализации Сито Эратосфена в С#:

public class PrimeFinder
{
    readonly List<long> _primes = new List<long>();

    public PrimeFinder(long seed)
    {
        CalcPrimes(seed);
    }

    public List<long> Primes { get { return _primes; } }

    private void CalcPrimes(long maxValue)
    {
        for (int checkValue = 3; checkValue <= maxValue; checkValue += 2)
        {
            if (IsPrime(checkValue))
            {
                _primes.Add(checkValue);
            }
        }
    }

    private bool IsPrime(long checkValue)
    {
        bool isPrime = true;

        foreach (long prime in _primes)
        {
            if ((checkValue % prime) == 0 && prime <= Math.Sqrt(checkValue))
            {
                isPrime = false;
                break;
            }
        }
        return isPrime;
    }
}

Ответ 16

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

public static class PrimeHelper
{

    public static IEnumerable<Int32> FindPrimes(Int32 maxNumber)
    {
        return (new PrimesInt32(maxNumber));
    }

    public static IEnumerable<Int32> FindPrimes(Int32 minNumber, Int32 maxNumber)
    {
        return FindPrimes(maxNumber).Where(pn => pn >= minNumber);
    }

    public static bool IsPrime(this Int64 number)
    {
        if (number < 2)
            return false;
        else if (number < 4 )
            return true;

        var limit = (Int32)System.Math.Sqrt(number) + 1;
        var foundPrimes = new PrimesInt32(limit);

        return !foundPrimes.IsDivisible(number);
    }

    public static bool IsPrime(this Int32 number)
    {
        return IsPrime(Convert.ToInt64(number));
    }

    public static bool IsPrime(this Int16 number)
    {
        return IsPrime(Convert.ToInt64(number));
    }

    public static bool IsPrime(this byte number)
    {
        return IsPrime(Convert.ToInt64(number));
    }
}

public class PrimesInt32 : IEnumerable<Int32>
{
    private Int32 limit;
    private BitArray numbers;

    public PrimesInt32(Int32 limit)
    {
        if (limit < 2)
            throw new Exception("Prime numbers not found.");

        startTime = DateTime.Now;
        calculateTime = startTime - startTime;
        this.limit = limit;
        try { findPrimes(); } catch{/*Overflows or Out of Memory*/}

        calculateTime = DateTime.Now - startTime;
    }

    private void findPrimes()
    {
        /*
        The Sieve Algorithm
        http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
        */
        numbers = new BitArray(limit, true);
        for (Int32 i = 2; i < limit; i++)
            if (numbers[i])
                for (Int32 j = i * 2; j < limit; j += i)
                     numbers[j] = false;
    }

    public IEnumerator<Int32> GetEnumerator()
    {
        for (Int32 i = 2; i < 3; i++)
            if (numbers[i])
                yield return i;
        if (limit > 2)
            for (Int32 i = 3; i < limit; i += 2)
                if (numbers[i])
                    yield return i;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    // Extended for Int64
    public bool IsDivisible(Int64 number)
    {
        var sqrt = System.Math.Sqrt(number);
        foreach (var prime in this)
        {
            if (prime > sqrt)
                break;
            if (number % prime == 0)
            {
                DivisibleBy = prime;
                return true;
            }
        }
        return false;
    }

    private static DateTime startTime;
    private static TimeSpan calculateTime;
    public static TimeSpan CalculateTime { get { return calculateTime; } }
    public Int32 DivisibleBy { get; set; }
}

Ответ 17

    public static void Main()
    {  
        Console.WriteLine("enter the number");
        int i = int.Parse(Console.ReadLine());

        for (int j = 2; j <= i; j++)
        {
            for (int k = 2; k <= i; k++)
            {
                if (j == k)
                {
                    Console.WriteLine("{0}is prime", j);

                    break;
                }
                else if (j % k == 0)
                {
                    break;
                }
            }
        }
        Console.ReadLine();          
    }

Ответ 18

static void Main(string[] args)
    {  int i,j;
        Console.WriteLine("prime no between 1 to 100");
    for (i = 2; i <= 100; i++)
    {
        int count = 0;
        for (j = 1; j <= i; j++)
        {

            if (i % j == 0)
            { count=count+1; }
        }

        if ( count <= 2)
        { Console.WriteLine(i); }


    }
    Console.ReadKey();

    }

Ответ 19

U может использовать понятие нормального простого числа, должно быть только два фактора (один и сам). Так что сделайте так, просто:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PrimeNUmber
{
    class Program
    {
        static void FindPrimeNumber(long num)
        {
            for (long i = 1; i <= num; i++)
            {
                int totalFactors = 0;
                for (int j = 1; j <= i; j++)
                {
                    if (i % j == 0)
                    {
                        totalFactors = totalFactors + 1;
                    }
                }
                if (totalFactors == 2)
                {
                    Console.WriteLine(i);
                }
            }
        }

        static void Main(string[] args)
        {
            long num;
            Console.WriteLine("Enter any value");
            num = Convert.ToInt64(Console.ReadLine());
            FindPrimeNumber(num);
            Console.ReadLine();
        }
    }
}

Ответ 20

Это самый быстрый способ вычисления простых чисел в С#.

   void PrimeNumber(long number)
    {
        bool IsprimeNumber = true;
        long  value = Convert.ToInt32(Math.Sqrt(number));
        if (number % 2 == 0)
        {
            IsprimeNumber = false;
        }
        for (long i = 3; i <= value; i=i+2)
        {             
           if (number % i == 0)
            {

               // MessageBox.Show("It is divisible by" + i);
                IsprimeNumber = false;
                break;
            }

        }
        if (IsprimeNumber)
        {
            MessageBox.Show("Yes Prime Number");
        }
        else
        {
            MessageBox.Show("No It is not a Prime NUmber");
        }
    }

Ответ 21

Это решение отображает все простые числа от 0 до 100.

        int counter = 0;
        for (int c = 0; c <= 100; c++)
        {
            counter = 0;
            for (int i = 1; i <= c; i++)
            {
                if (c % i == 0)
                { counter++; }
            }
            if (counter == 2)
            { Console.Write(c + " "); }
        }

Ответ 22

class CheckIfPrime
   {
    static void Main()
      {
          while (true)
        {
            Console.Write("Enter a number: ");
            decimal a = decimal.Parse(Console.ReadLine());
            decimal[] k = new decimal[int.Parse(a.ToString())];
            decimal p = 0;
            for (int i = 2; i < a; i++)
            {
                if (a % i != 0)
                {
                    p += i;
                    k[i] = i;
                }
                else
                    p += i;
            }
            if (p == k.Sum())
               { Console.WriteLine ("{0} is prime!", a);}
            else
               {Console.WriteLine("{0} is NOT prime", a);}

        }
    }

}