inline bool isPrime(int num)
{
   if(num==3 || num == 2)
       return true;
   else
       if(num%2==0)
           return false;
   int temp = num/2+1;
   int i=3;
   for(; i<temp; i+=2)
       if(num%i==0)
             break;
   return  i>=temp;
}

void fun( int i)
{
    for(int i=2; i<1001; i++)
      if(isPrime(i))
          cout<<i<<":prime"<<endl;
}

int main() 
{ 
     fun(1000);
}
行不？

好像你的面试题并没要求可读性

int main()
{
    for(int num=2; num<1001; num++)
    {
       if(num==3 || num == 2)
       {
           cout<<num<<":Prime"<<endl;
           continue;
       }    
       else
           if(num%2==0)
               continue;
       int temp = num/2+1;
       int i=3;
       for(; i<temp; i+=2)
           if(num%i==0)
                break;
       if(i>=temp)
          cout<<num<<":Prime"<<endl;
    }    
}

你这个结果达不到要求啊
题要求是求1000个质数,并且是前1000个质数
难道就每人来解答吗

inline bool isPrime(int num)
{
   int temp = (int)sqrt(num);
   int i=3;

   if (num==1)
       return false;

   for(int i=2; i<temp; i++)
   {
       if(num%i==0)
           return false;
   }
   return  true;
}

int main() 
{ 
   int nCount = 0;
   int nNum = 1;

   while (nCount < 1000)
   {
        if (isPrime(nNum))
        {
          printf("第%d素数: %d\n", nCount, nNUm);
          nCount++;
        }
        nNum++;  
   }
}

回复人： fmonkey() ( ) 信誉：96  2004-08-07 14:27:00  得分: 0  
 
 
   你这个结果达不到要求啊
题要求是求1000个质数,并且是前1000个质数
难道就每人来解答吗
------------------------------------

faint, 自己动脑筋想啊，这么简单个问题难道还要请教别人？

效率不是太高,看看这个:

#include <stdio.h>
#include <math.h>

bool isPrimeEx(int num, int prime[])
{
int limit = sqrt(num) + 1 ;

for(int i = 0 ; prime[i] < limit ; i++)
{
if(num % prime[i] == 0)
return false ;
}

return true ;
}

void main()
{
int prime[1000] ;

prime[0] = 2 ;
prime[1] = 3 ;

for(int i = 4, j = 2 ; i < 1000 ; i++)
{
if(isPrimeEx(i, prime))
{
prime[j] = i ;
j++ ;
}
}

for(i = 0 ; i < j ; i++)
{
printf("%d\t", prime[i]) ;
}
}

该算法利用先前已知的质数来判断当前的数是否为质数,所以isPrimeEx需要传入一个质数数组.例如判断997是否为质数,只需要依次判断997能否被2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37中任何一个整除.这是用空间复杂度的提升换取时间复杂度的降低.

该算法仍然可以改进,由于sqrt函数求出的是精确的浮点开方值,而我们并不需要如此高的精度,在vc6.0中,我跟踪了这个函数,发现一共执行了30-50行左右的汇编代码,不知道有没有更好的方法获得某个整数平方根的近似值.

不过如果要求的数字更大一些,比如100K以下,那么sqrt占用的时间就可以忽略了.
如果数字再大些....比如100M以下,恐怕就需要把质数表保存在文件中了

刚才的程序求的是1000以下的质数,这个是求前1000个:

#include <stdio.h>
#include <math.h>

bool isPrimeEx(int num, int prime[])
{
int limit = sqrt(num) + 1 ;

for(int i = 0 ; prime[i] < limit ; i++)
{
if(num % prime[i] == 0)
return false ;
}

return true ;
}

void main()
{
int prime[1000] ;

prime[0] = 2 ;
prime[1] = 3 ;

for(int i = 4, j = 2 ; j < 1000 ; i++) // 这里和刚才的程序有一点点区别
{
if(isPrimeEx(i, prime))
{
prime[j] = i ;
j++ ;
}
}

for(i = 0 ; i < j ; i++)
{
printf("%d\t", prime[i]) ;
}
}

楼上的你要是觉的简单
你可以不用来参与啊
你知道微软的那到strcpy函数题吗?
不要认为 什么都是那么简单

#include <iostream.h>
#include <math.h>
void main ()
{
int h, k, counter = 0;
cout << "2\t";
for (h = 3; counter < 999; h +=2)
{
for (k = 3; k <= sqrt (h + 1); k += 2)
if (h % k == 0)
break;
if (k > sqrt (h + 1))
{
cout << h << "\t";
counter++;
}
}
}

你知道微软的那到strcpy函数题吗？
----------------------------------
不知道

char* strcpy(char* a, const char* b)
{
   char *ret=a;
   while((*a++ = *b++)!=0);
   return ret; 
}
我只能写成这样
MS那个是怎么样的？

去看看 林锐的 <<高质量C/C++程序设计>>

喂,就题论题,别说远了嘛

是啊
FlyindanceDDr(我为君狂) 的
算法确实不错
但是主程序还是可以改进啊
还有更好的吗
 

#include <iostream.h>
#include <iomanip.h>
#include <math.h>

#define NUM_PRIMER_SEARCH 1000

bool IsPrimer(int num)
{
register int root, divisor = 3;

if((0x1 & num) || num == 2)
{
root = sqrt(num);

for(; divisor <= root; divisor += 2)
{
if(num % divisor == 0)
return false;
}

return true;
}

return false;
}


void main()
{
register nCount = 0, i = 1;
for(; nCount < NUM_PRIMER_SEARCH; )
{
for(; nCount < NUM_PRIMER_SEARCH; i ++)
{
if(IsPrimer(i))
{
++ nCount;
cout << setw(8) << i;
}
}

if(!(nCount % 8))
cout << endl;
}
}

主程序还需要哪些方面的优化?
只判断奇数吗?

#include <stdio.h>
#include <math.h>

bool isPrimeEx(int num, int prime[])
{
int limit = sqrt(num) + 1 ;

for(int i = 0 ; prime[i] < limit ; i++)
{
if(num % prime[i] == 0)
return false ;
}

return true ;
}

void main()
{
int prime[1000] ;

prime[0] = 2 ;
prime[1] = 3 ;

for(int i = 5, j = 2 ; j < 1000 ; i += 2) // 只判断奇数
{
if(isPrimeEx(i, prime))
{
prime[j] = i ;
j++ ;
}
}

for(i = 0 ; i < j ; i++)
{
printf("%d\t", prime[i]) ;
}
}

根本编译不通

#include <iostream>
#include <math.h>
using namespace std;

bool Isprime(int num)
{
if(num<2)
return false;
if(num==2)
return true;
if(num%2==0)
return false;
for(int i=3;i<sqrt(num);i+=2)
{
if(num%i==0)
return false;
}
return true;
}

int FindNext(int cur)
{
int i=cur+1;
while(!Isprime(i))
{
i++;
}
return i;
}

void main()
{
int count=0;
int cur=1;
while(count<1000)
{
cur=FindNext(cur);
cout<<cur<<ends;
count++;
}
}

#include<iostream>
using namespace std;


void main()
{
 int i,n,co=0,flag=1;
 for(n=2;n<10000&&co<1000;n++)
  {
   for(i=2;i<=n/2;i++)
    if(n%i==0)
      {flag=0;
       break ;}    //判断是不是素数,不是的话就将标志flag设为0; 
      
    if(flag==0)     //标志为0就跳到下一个数去 
    { 
      flag=1;
      continue;
      }
      
    cout<<n<<"  ";
     co++;
     
    }
 
 
 cin.get();
 }
//这是我写的一个小程序，可以实现1000个素数的求解，因为对效率有要求，所以建议不要写成函数调用，因为每次的调用和返回值都有较多的开销。当然，我用的是一种很笨的算法，楼主可以采用筛选法，那么在循环的次数上要少很多的，不过这又有另一个问题，就是要将以前的素数全部有备份，那就要使用数组，最有效的当然是动态的数组。很明显，这要加大空间的开销，而且写起来要麻烦一点
如果楼主特别的强调效率的话，可以将n和i设为register变量，这也有一点效
这个程序可以运行，最后一个数为7917
楼主也可以将其中的一些值改一下，比方说求前十个，前五个，

楼主面试过了不妨告诉一下我们楼主的经验啊。^_^

到底是要时间还是要空间啊？两个都要显然是不切实际的

有更好的筛子。
一个足够大的素数的个位只能是：1、3、7、9，这样可以用累加法来过滤奇数里可能的合数。速度比上述的任何一种方法都要快几个数量级。通常1,000,000个也就分吧分钟的事

只在奇数中判断

上次去华为面试就有这个题

mark

mark

给出一个精简的算法，看看哪位有更好的。本方法内存占用也不是很高，对1,000,000而言运行开销也就9M多点
/----------------------------------
//   素数序列快速生成算法 作者：FreeFice / Ziyun
//   适用于32位/64位系统。 本代码释放到公用域，任何人均可复制传播与引用，但
//   必须保证算法的完整性，不得全部或部分的声明为私有，否则即构成侵权行为。
//---------------------------------

#define MaxNum 1000 //1000000生成时间约1分钟

//-------公开的素数序列算法部分-------------
//  原理：依据足够大的素数其个位数是 1 3 7 9 的原则，构筑奇数筛子
//  运用累加步进的方法，避免使用大量的除法及开方操作，通过检测自身
//  已生成序列的界值，达到推定当前奇数运算范围。生成序列最少四个，
//  最多2147483647个
void InitPrime(int Max,__int64 *Prime)
{
   Prime[0] = 2; Prime[1]=3; Prime[2]=5;
   int m = 3,t=1;
   for (__int64 n=7; m<Max;n+=2){
      if (n%5==0)continue;
      __int64 s = Prime[t]*Prime[t];
      if (n>=s)t++;
      if (n==s)continue;
      for (int i=1;i<t;i++)
         if(n % Prime[i]==0)goto NEXT;
      Prime[m++]=n;
NEXT:
      }
}
//--------------------------------------

int main()
{
   __int64 *Primes = new __int64[MaxNum];
   InitPrime(MaxNum,Primes);
   //----------省略输出语句
   delete[]Primes;
   return 0;
}

楼上的算法好，可是这需要对质数有研究吧
楼上说的规律偶就不知道

这个问题讨论过N百次了，很早以前有较好的算法，求 10G 类的素数只要 50秒( C2 450上 ),求10G内素数个数只要10秒以下，咔咔，你在CSDN上搜以下就可以了

求一个范围内的素数用筛法还是比较好的，像这样的筛法效率还是比较高的，咔咔
取 N  = 前几个素数的乘积 如 2 * 3 * 5 * 7 * 11 * 13 , 对于大于 3 * N 的数可以写成 X = a * N + b 的形式, 显然的要 g c d( b , N ) = 1 才是素数，这样可以预先过滤掉大部分的非素数。
   然后就可以像常规的筛法筛选素数啦，段的大小要选择适当，不要超过高速缓存的大小

至于求素数个数的程序我就看不懂了郁闷啊

郁闷，我怎么写g c d( b , N ) 也不行啊

搜了一下还搜到啦，咔咔

http://search.csdn.net/search.asp?key=10G+%CB%D8%CA%FD&class=&size=10&option=advance&x=31&y=8

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

int isPrime(int n, int *p);

main()
{
  int m, y;
  printf("Please input a number:");
  scanf("%d", &m);
  int p[m];
  //*p = (int*)malloc(sizeof(int)*m);
  int count = isPrime(m, p);
  for(y = 0; y < count; y++)
  {
    printf("%d\n", p[y]);
  }
  getch();
}

int isPrime(int n, int *p)
{
  int x, j, con;
  int *tmp;
  tmp = p;
  con = 0;
  for(j = 3; j < n; j++)
  {
    for (x = 2; x < j; x++)
    {
      if ((j % x) != 0)
      {
        p[con] = j;
        continue;
      }
      else 
      {
        con--;
        break;
      
    }
    con++;
  }
  return con;
}

哪个弱智,
这一程序能编译得过吗?
有点怪了,
哪有这种定义数组的,
不出错真的就怪了.
C有这种定义数组的语法吗?
int m, y;
  printf("Please input a number:");
  scanf("%d", &m);
  int p[m];

楼上,

说一下,

你用哪个编译器编译过了,

我也试一下.

应该是一个不错的编译器

楼上的有病啊,别人用伪码写程序不行啊,知道意思就行了.

求前1000个素数(甚至前1M个)用的时间应该是以毫秒计

贴个运行很慢的来,求3-1M的素数,咔咔

const size_t MaxPrePrime = 0X100000;

unsigned* preprimetab = NULL;
size_t szpreprimetablen = 0; 

struct __genpreprimetab {
enum { sztmpbuf = MaxPrePrime / 2 };
__genpreprimetab() 
{
assert( !preprimetab && !szpreprimetablen );
int i , cur = 0;
unsigned* tmp = new unsigned[ sztmpbuf ];
for( i = 3; i < MaxPrePrime; i += 2 ) tmp[ ( i - 3 ) / 2 ] = i;
for( i = 0; i < sztmpbuf; ++i )
if( tmp[i] ) filteronce( tmp , tmp[i] );
for( i = 0; i < sztmpbuf; ++i )
if( tmp[i] ) ++szpreprimetablen;
preprimetab = new unsigned[szpreprimetablen];
for( i = 0; i < sztmpbuf; ++i )
if( tmp[i] ) preprimetab[cur++] = tmp[i];
delete[]tmp;

}
~__genpreprimetab()
{
delete[]preprimetab;
szpreprimetablen = 0;
}
private:
void filteronce( unsigned* ptr , unsigned prime )
{
assert( ptr && ( prime & 1 ) );
unsigned ntime = MaxPrePrime / prime;
for( unsigned n = 3; n <= ntime; n += 2 )
ptr[ ( n * prime - 3 ) >> 1 ] = 0;
}
} __preinit;

不做成函数，如下：效率还可以
#include <iostream.h>
main()
{
cout<<"1:\t2"<<endl;
cout<<"2:\t5"<<endl;
int num = 2;
int j;
for(int i = 7; num < 1000; i += 2)
{
for (j = 3; j <= i / 2; j += 2)
{ if( i % j == 0 ) 
break;
}
if( j >= i / 2 ) 
{ num += 1;
cout<<num<<":\t"<<i<<endl;
}

}
}

既然大家如此的热情那我不如把我这次面试的另外两道题写出来
重开一贴，欢迎各位参与 

紧急补充：

   1、强烈建议用筛法，这样对效率有很大的提高。
   2、请不要用函数调用，这不利于效率
   3、在循环中有判断时，请把判断写在外面（程序要做少量的改动），因为每一次判断都可能打断cpu的流水线作业，这在很大程度上违背了局部性原则，（计算机基础中有讲过的，不知道的应该补补了），对于这种大量循环应该写在外面，程序虽然不简捷，但是对效率有很大的提升。
   4、书写程序的时候最好用规范点的方法，你是去求职的，写得规范一定有好处的。