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

попробуйте это:

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

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

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

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

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

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

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

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

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

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

Нет 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 меньше квадратного корня.

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

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

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

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

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

ваш метод 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() );
    }
}

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

EDIT_ADD: если Уилл Несс прав, что цель вопроса - просто вывести непрерывный поток простых чисел до тех пор, пока программа запускается (нажатие паузы/перерыва для паузы и любой клавиши для запуска снова) без серьезной надежды на то, что каждый доберется до этого верхнего предела, тогда код должен быть написан без аргумента верхнего предела и проверки диапазона "true" для первого цикла "i". С другой стороны, если вопрос хотел фактически напечатать простые числа до предела, то следующий код будет выполнять эту работу намного эффективнее, используя пробное разделение только для нечетных чисел, с тем преимуществом, что он вообще не использует память (он также может быть преобразован в непрерывный цикл, как указано выше):

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

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

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

на самом деле это злоупотребление агрегатным методом Linq и эффективно не использует первый из двух генерируемых диапазонов 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. Однако он по-прежнему медленный и интенсивный из-за генерации списка и нескольких перечислений, а также нескольких разделить (подразумевается по модулю) операции.

следующее истинное сито реализации Эратосфена работает примерно в 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 GHz).

любой из двух статических методов может быть вызван и протестирован с помощью операторов using и со статическим основным методом следующим образом:

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: однако, чтобы произвести перечисление числа простых чисел менее десяти тысяч триллионов (от десяти до шестнадцатой степени), как задается вопрос, требуется сегментированный подкачанный подход с использованием многоядерной обработки, но даже с C++ и очень высоко оптимизированный PrimeSieve, это потребует чего-то более 400 часов, чтобы просто произвести количество найденных простых чисел, и в десятки раз больше, чтобы перечислить их все год, чтобы сделать то, что спрашивает вопрос. Чтобы сделать это с помощью неоптимизированного алгоритма пробного деления, это займет супер эоны и очень долгое время даже с использованием оптимизированного алгоритма пробного деления, как в чем-то от десяти до двух миллионных лет мощности (это два миллиона нулей лет!!!).

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

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

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

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

на решето Эратосфена ответ выше не совсем правильный. Как написано, он найдет все простые числа между 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, так как этот список будет содержать окончательный список простых чисел. The Enumerable.Range(1, Convert.ToInt32(Math.Floor(Math.Sqrt(num)))) - это количество раз, когда семя очищается.

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

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

код одной строки в C# : -

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

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

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

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

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

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

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

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

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

Я не буду давать полную реализацию, так как это было бы легко, это подход в псевдокод. (На моей машине фактическая реализация вычисляет все простые числа в системе.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 чисел можно safed с 1 ГБ, и вычисление этого набора результатов занимает около 2 минут максимум.

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

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

Prime Helper очень быстрый расчет

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

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

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

    }

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

это решение отображает все простые числа от 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 + " "); }
        }

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

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

Я знаю, что это тихий старый вопрос, но после прочтения здесь: сито Эратосфена 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.

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