篮球外围下注_篮球投注导航_[所有网址]

篮球外围下注_篮球投注导航_[所有网址]是该公司为打造信誉第一,2014最新体验金,篮球外围下注_篮球投注导航_[所有网址]这里的所有老虎机游戏及真人百家乐游戏都具有欧洲风格,致力成为最具传播力和互动性的娱乐城网站。

美洲杯竞猜网址从关于素数的算法题来学习如何

2019-07-31 19:49 来源:未知

问题:

  难题出处见 C语言初学者代码中的常见错误与弱点(5) 。

  在该文的最后,曾涉及完毕的代码还会有进一步改进的余地。本文完成了那一个革新。所以本文钻探的而不是初大家代码中的常见错误与劣点,而是对自家自个儿代码的改正和优化。标题只是为了保全种类的再而三性。

 

   

 相关博客:

  不常发掘Jingle Guo网上好朋友后来商讨同一难题的一篇博文,笔者以为到对阅读此文的网民恐怕有一定的参谋价值,故在此付出相关链接:从有关素数的算法题来学习怎么着巩固代码作用。


 

接下去有N行,每行有二个正整数X
输出:输出有N行,每行是对应X的最临近它的素数

进一步提升效用

  没什么更加好的艺术,只可以用点“赖皮”花招,即丰裕运用已有个别素数知识,帮Computer算出一部分素数。

void add_1_prime( Node * * pp )  {     if ( * pp == NULL )      {         add ( 2 , pp );                     //第一个素数          return ;          }       switch ( ( * pp ) -> prime )     {        case  2: add ( 3  , pp );                             return ;        case  3: add ( 5  , pp );                             return ;        /* 这里可以依样写多个case,只要是按照素数从小到大的次序*/            default:                  {                     int next_p = ( * pp )->prime   1 ;     //从最后一个素数之后开始找下一个素数                           while ( !be_prime( next_p , pp ) )                         next_p    ;                       add( next_p , pp );                    //将下一个素数加入素数表                      return ;                  }      }     }

   这里switch语句的构造万分有趣。

void test(){
    clock_t start = clock();
    for(int i=1; i <= 100000;   i){
        isPrime(1000000007);
    }
    clock_t end = clock();
    cout << endl << static_cast<double>(end - start)/CLOCKS_PER_SEC << endl;
}

4
22
5
18
8
输出
23
5
19
7

拉长可读性?

  即便把树立素数表的渴求写在get_nearest()函数中,只怕会使代码可读性别变化得更加好些。 

int get_nearest( int x )  {     int step = 0 ;         //步长增量     int sign = -1;         //符号     Node * head = NULL ;   //素数链表           while ( 建立最大素数平方不小于x的素数表() , ! be_prime( x , & head ) )        x  = ( sign = - sign ) *    step ;          my_free(head) ;     return x ;  }

   但这里的那么些那几个“,”是免不掉的,且圈复杂度不改变。

  至于这种写法是还是不是真正改进了可读性,恐怕是例外。

因为里面大家或然会进展重新的揣摸,对这几个难题笔者一开首想到的化解方式正是确立一个质数表,咱们能够直接通过搜索表来飞快的明确二个数是或不是是质数。当要推断的数极大时,需求占用非常大的空间来建表,为了节约空间,小编将每壹人都即使用上了。

 main(  , & ( n -- > , & , get_nearest( x ) ); 

重构

/*
问题:
素数
在世博园某音信通讯馆中,旅客可采纳手提式有线电话机等终端出席互动小游戏,与设想人物Kr. Kong 进行猜数比赛。
当荧屏出现二个整数X时,若您能比Kr. Kong越来越快的发生最相仿它的素数答案,你将会赢得贰个意外的赠礼。

举个例子:当荧屏出现22时,你的应对应是23;当显示屏出现8时,你的答问应是7;
若X本人是素数,则回复X;若最周边X的素数有八个时,则答应出乎它的素数。

输入:第一行:N 要竞技彩票的平头个数
接下去有N行,每行有一个正整数X
输出:输出有N行,每行是对应X的最周边它的素数

样例:输入
4
22
5
18
8
输出
23
5
19
7

作者:薛非
出处:   “C语言初学者代码中的常见错误与缺点”类别博文

版本:V 2.1
*/

#include <stdio.h>  #include <stdbool.h>    typedef  struct prime_list     {        unsigned prime;        struct prime_list * next;     }   Node;    int get_nearest( int );  bool be_prime( int , Node * * );  int get_remainder( int , Node * * ) ;  void add_1_prime( Node * * );  bool sqr_less ( int , int );  void add ( int , Node * * );  void my_malloc( Node * *  );  void my_free( Node * );    int main( void )  {     unsigned n ;          puts( "数据组数=?" );     scanf( "%u" , &n );           while ( n -- > 0 )     {        int x ;                 puts( "整数X=?" );        scanf( "%d", & x );                printf("%dn" , get_nearest( x ) ); //求最接近x的素数     }          return 0;  }    int get_nearest( int x )  {     int step = 0 ;         //步长增量     int sign = -1;         //符号     Node * head = NULL ;   //素数链表           while ( ! be_prime( x , & head ) )        x  = ( sign = - sign ) *    step ;          my_free(head) ;     return x ;  }    bool be_prime( int x , Node * * pp ) //根据素数表pp判断x是否为素数   {     if ( x <= 1 )        return false ;          if ( x == 2 )        return true ;             if ( get_remainder( x , pp ) == 0 ) // x对素数表pp中素数逐个求余有0值         return false ;          return true ;  }    int get_remainder( int x , Node * * pp )//x对素数表pp中素数逐个求余  {     while ( * pp == NULL || sqr_less( (*pp) -> prime , x ) )//表中素数个数不足         add_1_prime ( pp ) ;                                 //表中增加一个素数           Node * p = * pp ;          while ( p != NULL )     {        if ( x % p -> prime == 0 )           return 0;        p = p -> next ;     }          return !0 ;  }    bool sqr_less ( int n , int x )  {     return n * n < x ;  }    //“偷奸耍滑”的add_1_prime()  void add_1_prime( Node * * pp )  {     if ( * pp == NULL )      {         add ( 2 , pp );                     //第一个素数          return ;          }       switch ( ( * pp ) -> prime )     {        case  2: add ( 3  , pp );                             return ;        case  3: add ( 5  , pp );                             return ;        /* 这里可以依样写多个case,只要是按照素数从小到大的次序*/            default:                  {                     int next_p = ( * pp )->prime   1 ;     //从最后一个素数之后开始找下一个素数                           while ( !be_prime( next_p , pp ) )                            next_p    ;                       add( next_p , pp );                    //将下一个素数加入素数表                      return ;                  }      }     }    //老老实实的add_1_prime()  //void add_1_prime( Node * * pp )  //{  //   if ( * pp == NULL )   //   {  //       add ( 2 , pp );                     //第一个素数   //       return ;       //   }  //     //   int next_p = ( * pp )->prime   1 ;     //从最后一个素数之后开始找下一个素数   //     //   while ( !be_prime( next_p , pp ) )  //      next_p    ;  //  //   add( next_p , pp );                    //将下一个素数加入素数表   //}    void add ( int prime , Node * * pp )  {     Node * temp ;          my_malloc( & temp );     temp -> prime = prime ;     temp -> next = * pp ;       * pp = temp ;  }    void my_malloc( Node * * p_p )  {     if ( ( * p_p = malloc( sizeof (* * p_p) ) ) == NULL )        exit(1);  }    void my_free( Node * p )  {     Node * temp ;     while ( ( temp = p ) != NULL )     {        p = p->next;         free( temp );     }  }

 

 相关博客

  不时开掘Jingle Guo网民后来研商同一难题的一篇博文,小编备感对读书此文的网上朋友也可能有早晚的参照他事他说加以考察价值,故在此付出相关链接:。

main( , ( n -- , , get_nearest( x ) ); prime_list * get_nearest( step = ; sign = - ; Node * head = NULL ; ( ! be_prime( x , = ( sign = - sign ) * be_prime( x , Node * * pp...

改进

  程序的总体构思未有改变,所以main()函数无需别的改动。

int main( void )  {     unsigned n ;          puts( "数据组数=?" );     scanf( "%u" , &n );           while ( n -- > 0 )     {        int x ;                 puts( "整数X=?" );        scanf( "%d", & x );                printf("%dn" , get_nearest( x ) ); //求最接近x的素数     }          return 0;  }

   进一步的改善浮今后

typedef  struct prime_list     {        unsigned prime;        struct prime_list * next;     }   Node;    int get_nearest( int x )  {     int step = 0 ;         //步长增量     int sign = -1;         //符号     Node * head = NULL ;   //素数链表           while ( ! be_prime( x , & head ) )        x  = ( sign = - sign ) *    step ;          my_free(head) ;     return x ;  }

   这里扩张了一个链表head,用于存款和储蓄素数表。那样,在认清素数时只用不大的素数试除就可以了,那足以使计量数据极为减弱。因为与自然数相比,素数的数额比较少(≈ln n / n 个)。其它,在认清完x是或不是为素数之后,要是须求决断下二个数(x = ( sign = - sign ) * step ;)是不是为素数,那几个素数表还是能重复使用,最多再向个中增多贰个素数就足以了。(注意最初素数表是空的)

  推断素数的方法很轻便,小学生都懂。

bool be_prime( int x , Node * * pp ) //根据素数表pp判断x是否为素数   {     if ( x <= 1 )        return false ;          if ( x == 2 )        return true ;             if ( get_remainder( x , pp ) == 0 ) // x对素数表pp中素数逐个求余有0值         return false ;          return true ;  }

  可是出于素数表(*pp==NULL)或许是空的,由此

int get_remainder( int x , Node * * pp )//x对素数表pp中素数逐个求余  {     while ( * pp == NULL || sqr_less( (*pp) -> prime , x ) )//表中素数个数不足         add_1_prime ( pp ) ;                                 //表中增加一个素数           Node * p = * pp ;          while ( p != NULL )     {        if ( x % p -> prime == 0 )           return 0;        p = p -> next ;     }          return !0 ;  }    bool sqr_less ( int n , int x )  {     return n * n < x ;  }

  须求先向当中增添素数

  add_1_prime ( pp ) ;

  直到

  sqr_less( (*pp) -> prime , x )

  依从小到大次序最终参预的十二分素数的平方十分大于x截至。

  对于

void add_1_prime( Node * * pp )  {     if ( * pp == NULL )      {         add ( 2 , pp );                     //第一个素数          return ;          }          int next_p = ( * pp )->prime   1 ;     //从最后一个素数之后开始找下一个素数           while ( !be_prime( next_p , pp ) )        next_p    ;       add( next_p , pp );                    //将下一个素数加入素数表   }

来讲,参与第叁个素数——2很轻松,可是搜索素数表中最大素数后的下一个素数时,却须要剖断贰个整数是还是不是是素数

be_prime( next_p , pp )

  这样,就能够意识,那个历程最初是由推断有个别数x是或不是是素数初阶,

be_prime( x , & head )

  在认清进程中供给树立素数表,

add_1_prime ( pp ) ; 

  而建设构造素数表,又供给推断有些数是不是是素数

be_prime( next_p , pp )

  那样就产生了二个但是错综相连的直接递归调用。更为复杂的是,在调用的历程中,素数表本人即持续地被使用,而本人也处于不断的生成意况之中,即持续地被增加进新的素数,与复杂的直接递归一道,构成了比复杂更头眼昏花的千头万绪的代码结构与复杂的数据结构的头晕目眩的结合体。风乐趣的话能够团结账一下圈复杂度,如此繁复的情形熟视无睹并不易于遇到。

  这种范围完全都以由于总括造成的,由于对进度的锱铢必较,进而产生了一幅猫猫在拼命咬本身尾巴同时喵咪自身又在持续调换的千头万绪无比的动态画面。因此我们轻松明白,为什么有些人讲,“不成熟的优化是万恶之源”(Premature optimization is the root of all evil!- 唐NaderKnuth)。因为优化往往代表引人复杂。复杂也是一种资本,况且是一种极高昂的基金。

  就以此主题材料来讲这种资本应当算是值得,因为对于求八个非常的大的最临近的素数难题来说(比方对于109以此量级),两套代码的进程有大相径庭。

素数

style="font-size: 15px;">在世界艺术博览园某消息通信馆中,游客可应用手机等终端到场互动小游戏,与虚构人物Kr. Kong 进行猜数竞技。

当荧屏现身叁个整数X时,若你能比Kr. Kong更加快的产生最临近它的素数答案,你将会收获一个不敢相信 无法相信的赠品。

 

style="font-size: 15px;">比如:当显示屏现身22时,你的答应应是23;当荧屏出现8时,你的答复应是7;

style="font-size: 15px;">若X本人是素数,则回答X;若最临近X的素数有五个时,则回复出乎它的素数。

 

输入:第一行:N 要竞彩的大背头个数

接下去有N行,每行有三个正整数X

style="font-size: 15px;">输出:输出有N行,每行是对应X的最相仿它的素数

 

样例:输入

4

22

5

18

8

输出

23

5

19

7

 prime_list * get_nearest(  step =  ;         
    sign = -;         
   Node * head = NULL ;   

    ( ! be_prime( x , & = ( sign = - sign ) *   

 

若X自身是素数,则答应X;若最临近X的素数有多个时,则回应出乎它的素数。

bool isPrime(int num)
{
    if(num < 2) return false;
    for(int i=2; i*i<num;   i){
        if(num % i == 0) return false;
    }
    return true;
}

 

 

*/

TAG标签: 篮球外围下注
版权声明:本文由篮球外围下注发布于系统,转载请注明出处:美洲杯竞猜网址从关于素数的算法题来学习如何