Печать простых чисел от 1 до 100

Этот код С++ выводит следующие простые числа: 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97.

Но я не думаю, что моя книга хочет, чтобы она была написана. Он упоминает что-то о квадратном корне из числа. Поэтому я попытался изменить свой второй цикл на for (int j=2; j<sqrt(i); j++), но он не дал мне результат, который мне нужен.

Как мне изменить этот код так, как хочет моя книга?

int main () 
{
    for (int i=2; i<100; i++) 
        for (int j=2; j<i; j++)
        {
            if (i % j == 0) 
                break;
            else if (i == j+1)
                cout << i << " ";

        }   
    return 0;
}

Первичным целым числом является число, которое имеет ровно два разных делителя, а именно 1 и самого числа. Написать, запустить и протестировать программу на С++, которая находит и печатает все простые числа менее 100. (Подсказка: 1 является простым номер. Для каждого номера от 2 до 100, find Remainder = Number% n, где n от 2 до sqrt (число).\If n больше, чем sqrt (число), число не равно делится на n. Зачем? Если какой-либо Остаток равен 0, число не является простым числом.)

ОТВЕТЫ

Ответ 1

Три способа:

1.

int main () 
{
    for (int i=2; i<100; i++) 
        for (int j=2; j*j<=i; j++)
        {
            if (i % j == 0) 
                break;
            else if (j+1 > sqrt(i)) {
                cout << i << " ";

            }

        }   

    return 0;
}

2.

int main () 
{
    for (int i=2; i<100; i++) 
    {
        bool prime=true;
        for (int j=2; j*j<=i; j++)
        {
            if (i % j == 0) 
            {
                prime=false;
                break;    
            }
        }   
        if(prime) cout << i << " ";
    }
    return 0;
}

3.

#include <vector>
int main()
{
    std::vector<int> primes;
    primes.push_back(2);
    for(int i=3; i < 100; i++)
    {
        bool prime=true;
        for(int j=0;j<primes.size() && primes[j]*primes[j] <= i;j++)
        {
            if(i % primes[j] == 0)
            {
                prime=false;
                break;
            }
        }
        if(prime) 
        {
            primes.push_back(i);
            cout << i << " ";
        }
    }

    return 0;
}

Изменить: В третьем примере мы отслеживаем все наши ранее рассчитанные простые числа. Если число делится на непустое число, существует также некоторое простое число < =, которое делитель также делится на. Это уменьшает вычисление на коэффициент primes_in_range/total_range.

Ответ 2

Если j равно sqrt(i), он также может быть действительным фактором, а не только меньше.

Чтобы продолжить и включить sqrt(i) в ваш внутренний цикл, вы можете написать:

for (int j=2; j*j<=i; j++)

(По сравнению с использованием sqrt(j) это имеет то преимущество, что не требуется преобразование в числа с плавающей запятой.)

Ответ 3

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

Ответ 4

Это моя очень простая программа на С++, которая перечисляет простые числа между 2 и 100.

for(int j=2;j<=100;++j)
{
    int i=2;
    for(;i<=j-1;i++)
    {
        if(j%i == 0)
            break;
    }

    if(i==j && i != 2)
        cout<<j<<endl;
}

Ответ 5

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

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

  • Создайте список последовательных целых чисел от 2 до n: (2, 3, 4,..., n).
  • Сначала пусть p равно 2, первое простое число.
  • Начиная с p, подсчитывайте с шагом p и отметьте каждое из этих чисел больше, чем p в списке. Эти цифры будут 2p, 3p, 4p и т.д.; обратите внимание, что некоторые из них, возможно, уже отмечены.
  • Найдите первое число, большее, чем p в списке, который не отмечен. Если такого номера не было, остановитесь. В противном случае пусть p теперь равно это число (которое является следующим простым) и повторить с шага 3.

Ответ 6

Поиск простых чисел до 100 особенно приятен и приятен:

    printf("2 3 ");                        // first two primes are 2 and 3
    int m5 = 25, m7 = 49, i = 5, d = 4;
    for( ; i < 25; i += (d=6-d) )
    {
        printf("%d ", i);                  // all 6-coprimes below 5*5 are prime
    }
    for( ; i < 49; i += (d=6-d) )
    {
        if( i != m5) printf("%d ", i);
        if( m5 <= i ) m5 += 10;            // no multiples of 5 below 7*7 allowed!
    }
    for( ; i < 100; i += (d=6-d) )         // from 49 to 100,
    {
        if( i != m5 && i != m7) printf("%d ", i);
        if( m5 <= i ) m5 += 10;            //   sieve by multiples of 5,
        if( m7 <= i ) m7 += 14;            //                       and 7, too
    }

Квадратный корень из 100 равен 10, и поэтому это преобразование сита Eratoshenes с 2-3 wheel использует кратные числа простых чисел выше 3, которые не превышают 10 - а именно. 5 и 7! - чтобы просеять 6-coprimes ниже 100 инкрементным образом.

Ответ 7

Используя логическое решение Fieve of Eratosthenes, я могу добиться тех же результатов при скорости намного быстрее.

My code demo VS принятый ответ.

Сравнивая count, мой код занимает значительно меньшую итерацию, чтобы закончить работу. Оформить результаты для разных значений N в конце.

Почему этот код работает лучше, чем уже принятые:

- четные числа не проверяются даже один раз на протяжении всего процесса.

- как внутренние, так и внешние петли проверяются только в пределах возможных пределов. Нет посторонних проверок.

код:

int N = 1000; //Print primes number from 1 to N
vector<bool> primes(N, true);
for(int i = 3; i*i < N; i += 2){    //Jump of 2
    for(int j = 3; j*i < N; j+=2){  //Again, jump of 2
        primes[j*i] = false;
    }
}
if(N >= 2) cout << "2 ";
for(int i = 3; i < N; i+=2){        //Again, jump of 2
    if(primes[i] == true) cout << i << " "; 
}

Для N = 1000 мой код принимает 1166 итераций, принятый ответ занимает 5287 (в 4,5 раза медленнее)

Для N = 10000 мой код принимает 14637 итераций, принятый ответ занимает 117526 (в 8 раз медленнее)

Для N = 100000 мой код принимает итерации 175491, принятый ответ занимает 2745693 (в 15,6 раза медленнее)

Ответ 8

Прекрасно менять цикл for на for (int j=2; j<=sqrt(i); j++), но вам также нужно изменить что-то еще. Глядя конкретно на ваше состояние печати,

else if (i == j+1) {
      cout << i << " ";
}

почему это никогда не будет запущено, если вы только переходите к sqrt(i)? Где вы можете переместить cout, чтобы изменить это? (Подсказка: вы можете перенести распечатку из цикла, а затем использовать переменную типа определенного типа)

Ответ 9

Я проверяю, является ли число простым или нет со следующим кодом (конечно, используя sqrt):

bool IsPrime(const unsigned int x)
{
  const unsigned int TOP
  = static_cast<int>(
      std::sqrt( static_cast<double>( x ) )
    ) + 1;

  for ( int i=2; i != TOP; ++i )
  {
    if (x % i == 0) return false;
  }
  return true;
}

Я использую этот метод для определения простых чисел:

#include <iostream>

using std::cout;
using std::cin;
using std::endl;

#include <cmath>

void initialize( unsigned int *, const unsigned int );
void show_list( const unsigned int *, const unsigned int );
void criba( unsigned int *, const unsigned int );
void setItem ( unsigned int *, const unsigned int, const unsigned int );

bool IsPrime(const unsigned int x)
{
  const unsigned int TOP
  = static_cast<int>(
      std::sqrt( static_cast<double>( x ) )
    ) + 1;

  for ( int i=2; i != TOP; ++i )
  {
    if (x % i == 0) return false;
  }
  return true;
}

int main()
{

    unsigned int *l;
    unsigned int n;

    cout << "Ingrese tope de criba" << endl;
    cin >> n;

    l = new unsigned int[n];

    initialize( l, n );

    cout << "Esta es la lista" << endl;
    show_list( l, n );

    criba( l, n );  

    cout << "Estos son los primos" << endl;
    show_list( l, n );
}

void initialize( unsigned int *l, const unsigned int n)
{
    for( int i = 0; i < n - 1; i++ )
        *( l + i ) = i + 2;
}

void show_list( const unsigned int *l, const unsigned int n)
{
    for( int i = 0; i < n - 1; i++ )
    {
        if( *( l + i ) != 0)
            cout << l[i] << " - ";
    }
    cout << endl;
}

void setItem( unsigned int *l, const unsigned int n, const unsigned int p)
{
    unsigned int i = 2;
    while( p * i <= n)
    {
        *( l + (i * p - 2) ) = 0;
        i++;
    }
}

void criba( unsigned int *l, const unsigned int n)
{
    for( int i = 0;  i * i <= n ; i++ )
     if( IsPrime ( *( l + i) ) )
        setItem( l, n, *(l + i) );      
}

Ответ 10

Использование правил делимости простых чисел можно найти в O (n), и это действительно эффективно Правила делимости

Решение будет основываться на отдельных цифрах числа...

Ответ 11

#include<iostream>
using namespace std;
void main()
{
        int num,i,j,prime;
    cout<<"Enter the upper limit :";
    cin>>num;
    cout<<"Prime numbers till "<<num<<" are :2, ";

    for(i=3;i<=num;i++)
    {
        prime=1;
        for(j=2;j<i;j++)
        {
            if(i%j==0)
            {
                prime=0;
                break;
            }
        }
        if(prime==1)
            cout<<i<<", ";
    }
}

Ответ 12

Вот моя реализация Сита Эратосфена (для простых чисел от 2 до n)

#include <iostream>

int main (){
int n=0;
std::cout << "n = ";
std::cin >> n;
std::cout << std::endl;

if (n==0 || n==1){
    std::cout << "No primes in this range" << std::endl;
    return 0;
}


const int array_len = n-2+1;

int the_int_array[array_len];
for (int counter=2; counter <=n; counter++)
    the_int_array[counter-2]=counter;


int runner = 0;
int new_runner = 0;

while (runner < array_len ){
    if (the_int_array[runner]!=0){
        new_runner = runner;
        new_runner = new_runner + the_int_array[runner];

        while (new_runner < array_len){
           the_int_array[new_runner] = 0;
           new_runner = (new_runner + the_int_array[runner]);
        }
    }
runner++;
}

runner = 0;

while (runner < array_len ){
    if (the_int_array[runner]!=0)
        std::cout << the_int_array[runner] << " ";
    runner++;
}

std::cout << std::endl;
return 0;

}

Ответ 13

#include "stdafx.h"
#include<iostream>
using namespace std;
void main()
{ int f =0;
 for(int i=2;i<=100;i++)
  {
   f=0;
   for(int j=2;j<=i/2;j++)
   { 
     if(i%j==0)
     { f=1;
       break;
     }
   }
 if (f==0)
  cout<<i<<" ";
}
 system("pause");
}

Ответ 14

это мой подход из простого блога:

//Prime Numbers generation in C++
//Using for loops and conditional structures
#include <iostream>
using namespace std;

int main()
{
int a = 2;       //start from 2
long long int b = 1000;     //ends at 1000

for (int i = a; i <= b; i++)
{

 for (int j = 2; j <= i; j++)
 {
    if (!(i%j)&&(i!=j))    //Condition for not prime
        {
            break;
        }

    if (j==i)             //condition for Prime Numbers
        {
              cout << i << endl;

        }
 }
}
}

- См. больше на: http://www.programmingtunes.com/generation-of-prime-numbers-c/#sthash.YoWHqYcm.dpuf

Ответ 15

Я всегда использую это (легко и быстро):

#include <iostream>
using namespace std;

int i,j;
bool b[101];

int main( )
{
    for(i=2;i<101;i++){
        b[i]=true;
    }
    for(i=1;i<101;i++){
        if(b[i]){
            cout<<i<<" ";
            for(j=i*2;j<101;j+=i) b[j]=false;
        }
    }
}

Вот вывод этого кода: 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

Ответ 16

Чтобы узнать, нет ли. является простым или не С++:

#include<iostream>
#include<cmath>

using namespace std;
int main(){

int n, counter=0;

cout <<"Enter a number to check whether it is prime or not \n";
cin>>n;

  for(int i=2; i<=n-1;i++) {
    if (n%i==0) {
      cout<<n<<" is NOT a prime number \n";
      break;
    }
    counter++;
                }
    //cout<<"Value n is "<<n<<endl;
    //cout << "number of times counter run is "<<counter << endl;
    if (counter == n-2)
      cout << n<< " is prime \n";
   return 0;
}

Ответ 17

Я сделал это в perl на основе самого популярного ответа по 2-му методу ProdigySim. Мне пришлось добавить эквивалент break в perl, last, сразу после print $i . " \n";, чтобы избежать двойных чисел дважды.

#!/bin/perl
use strict;

for(my $i=2; $i < 100; $i++){

    my $prime = 1;

    for (my $j=2; $j*$j<=$i; $j++){
        if ($i % $j == 0){
            $prime = 0;
            last;
        }
        if($prime) {
            print $i . " \n";
            last;
        }
    }

}

Ответ 18

Простая программа для печати "N" простых чисел. Вы можете использовать значение N как 100.

    #include  <iostream >
    using  namespace  std;

    int  main()
    {
        int  N;
        cin  >>  N;
        for (int  i =  2;  N > 0;  ++i)
        {
            bool  isPrime  =  true ;
            for (int  j =  2;  j < i;  ++j)
            {
                if (i  % j ==  0)
                {
                    isPrime  =  false ;
                    break ;
                }
            }
            if (isPrime)
            {
                --N;
                cout  <<  i  <<  "\n";
            }
        }
        return  0;
    }

Ответ 19

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

#include<iostream.h>
#include<conio.h>

void main()
{
clrscr();
int n,i,j,k;
cout<<"Enter n\n";
cin>>n;

for(i=1;i<=n;i++)
{   k=0;
  for(j=1;j<=i;j++)
  {
    if((i%j)==0)
    k++;
   }
  if(k==2)
  cout<<i<<endl;
}
getch();
}

Ответ 20

Обновление: это решение неверно, не следуйте ему

Просто попробуй Его месиво легко с любыми дополнительными встроенными функциями.

#include <iostream.h>
#include <conio.h>

int prime(int n,int r){

  for(int i=2;n<=r;i++){
    if(i==2 || i==3 || i==5 || i==7){
      cout<<i<<"\n";
      n++;
    } else if(i%2==0 || i%3==0 || i%5==0 || i%7==0)
      continue;
    else {
      cout<<i<<"\n";
      n++;
    }
  }

}

main(){
  int a=1,b;
  cout<<"Please Enter the number of prime number to display: "; 
  //Taking the range of no of prime number to be displayed 
  //in your condition u can give 100 as range on input

  cin>>b;

  prime(a,b);
  getch();
}

Ответ 21

Чтобы найти простые числа < 100, я думал, что будет быстро использовать простой код.
Но даже для небольших пределов это кажется недействительным (см. Правки).

Как это работает?

"buildX (uint m)" является ситом от Eratosthenes для нечетных чисел,
нечетные композиты отмечены в массиве uint, он начинается с 3,
который не отмечен (пока ничего). Нечетные кратные 3: 9,15,21...
Следующий не отмечен: 5. Начальная маркировка на 5 * 5, 3 * 5 была отмечена 3. 25,35,45...
Следующий: 7. 49,63,77... Далее: 9. он отмечен (на 3), пропустите его. 11:121,143,165...
Отмечаются только нечетные числа, сохраняются пробелы, делятся на 2.
Первое шестнадцатеричное число в массиве uint "x" равно 0x9B4B3490. Двоичный:.... 0100 1001 0000. Каждый бит представляет собой нечетное число, поэтому 1,3,5,7,11,13,17,19,23 не отмечены,
нечетные простые числа (кроме 1).

"countPrimes (uint [] x)" подсчитывает простые числа, нулевые биты в каждом номер массива uint "x", с небольшим перекручиванием, который подсчитывает установленные биты (единицы). Прочитайте число, инвертируйте его "xi = ~ x [i]", подсчет: 0x9B4B3490.... 0100 1001 0000
                0x64B4CB6F... 1011 0110 1111 9 единиц

Результаты. Primes < 100 0,12 мкс. < 200 0,23 мкс. < 400 0,47 мкс. < 800 1,03 мкс. Primes < 2 ^ 32 19 с.

Для больших лимитов (2 ^ 32) на моем ящике, используя (8 гиперпотоков) 4 ядра, это можно сделать примерно в 10 раз быстрее. Существует точка безубыточности, где однопоточный код быстрее, чем многопоточный код. Я думаю, что этот момент близок к пределу ~ 100.000.000 Но мне нужен какой-то код для небольших ограничений, поэтому я написал его.

Мой пост был заблокирован, возможно, потому, что он не C/С++. С другой стороны, это не должно быть слишком сложно перевести, есть превосходные программы (Ким Валиш примысе).

using System;
using sw = System.Diagnostics.Stopwatch;
class Program
{
    static void Main()
    {
        uint m = 100; uint[] p = primes(m);
        sw sw = sw.StartNew();
        for (int i = 1000000; i > 0; i--) p = primes(m);
        Console.Write(sw.Elapsed + " " + p.Length + " primes"); Console.Read();
    }


    static uint[] primes(uint m)  // primes <= m
    {
        if (m < 2) return new uint[0];
        uint[] x = buildX(m), p = new uint[countPrimes(x)]; p[0] = 2;
        int i = 1; m >>= 1;
        for (uint n = 1; n <= m; n++)
            if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        return p;
    }

    static uint[] buildX(uint m)  // Eratosthenes
    {
        m -= m / ~0u; m += m & 1; m >>= 1;
        var x = new uint[m / 32 + 1]; x[m >> 5] = ~0u << (int)m;
        for (uint a = 3, b = 4, c = 4, d; b < m; a += 2, b += c += 4)
            if ((x[a >> 6] & 1u << (int)(a >> 1)) == 0)
                for (d = b; d < m; d += a) x[d >> 5] |= 1u << (int)d;
        return x;
    }

    static uint countPrimes(uint[] x)  // Bit Twiddling Hacks
    {
        uint xi, c = 0;
        for (int i = x.Length - 1; i >= 0; i--)
        {
            xi = ~x[i]; xi -= (xi >> 1) & 0x55555555;
            xi = (xi & 0x33333333) + (xi >> 2 & 0x33333333);
            c += ((xi + (xi >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
        }
        return c;
    }
}

При колесе mod 6 n = 6k ± 1, k > 0
Primes < 100 0,10 мкс. < 200 0,19 мкс. < 400 0,39 мкс. < 800 0,79 мкс.

static uint[] primes(uint m)
{
    if (m < 2) return new uint[0];
    uint[] x = buildX(m), p = new uint[countPrimes(x)]; p[0] = 2;
    if (m > 2) p[1] = 3;
    int i = 2; m >>= 1; uint n = 2;
    for (; n < m; n += 2)
    {
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n++;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
    }
    if (n == m
         && (x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
    return p;
}

С колесом мод 30, n = 30k + {7,11,13,17,19,23,29,31}, k >= 0
Primes < 100 0,10 мкс. < 200 0,19 мкс. < 400 0,37 мкс. < 800 0,75 мкс.

static uint[] primes(uint m)
{
    if (m < 2) return new uint[0];
    uint[] x = buildX(m), p = new uint[countPrimes(x)]; p[0] = 2;
    if (m > 2) p[1] = 3; if (m > 4) p[2] = 5; int i = 3; m >>= 1;
    for (uint n = 0; ; )
    {
        n += 3; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 2; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 1; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 2; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 1; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 2; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 3; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
        n += 1; if (n > m) break;
        if ((x[n >> 5] & 1u << (int)n) == 0) p[i++] = n << 1 | 1;
    }
    return p;
}

Забыл распечатать их;)

    foreach (var v in p) Console.Write(v + " ");