预处理指令
    以一个井号开头的行都叫做预处理指令。除了#include指令外，我们还经常用到#define指令。#define指令可以告诉编译器，编译时把代码中出现的特定标识当作什么来处理。例如，我们可以这样写：
#define NAME_OF_MY_POTENTIAL_GF "ZPR"
    这样，编译器会在编译前把代码中出现NAME_OF_MY_POTENTIAL_GF的地方全部替换成"ZPR"。这种替换是无条件的，但是有一个例外：当指定的标识属于某个字符串（被引号引起来）时替换不会发生。例如，下面两行代码会输出NAME_OF_MY_POTENTIAL_GF defined as: ZPR
printf("NAME_OF_MY_POTENTIAL_GF defined as: ");
printf(NAME_OF_MY_POTENTIAL_GF);
    其中，后面那个NAME_OF_MY_POTENTIAL_GF被自动替换为"ZPR"。如果哪一天ZPR不要我了，我就可以非常方便地让整个程序适用于另一个MM。

    C语言中通常会用#define代替const。例如，下面的代码假设了输入数据n<=2000。
#include <stdio.h>
#define MAX 2000

int main()
{
   int f[MAX][MAX];
   int i,j,n;
   scanf("%d",&n);
   for ( i=0; i<n; i++ )
   {
      for ( j=0; j<=i; j++ )
      {
          f[i][j] = j ? (f[i-1][j] + f[i-1][j-1]) % 10000 : 1;
          printf( "%5d" , f[i][j] );
      }
      printf("\n");
   }

   return 0;
}

    下面的这些指令也是合法的：
#define begin {
#define end }
#define and &&
#define or ||
    #define定义的指令允许带参数。例如，下面的定义也是合法的：
#define sqr(x) x*x
    观察下面的这个程序：
#include <stdio.h>
#define begin {
#define end }
#define writeln(num) printf("%d\n",num)
#define sqr(x) x*x

int main()
begin
   writeln(sqr(100));
   writeln(sqr(10+2));
end
    程序输出：
10000
32
    为什么第二个输出的数是32不是144？不要忘了sqr中的x不是一个变量，编译器仅仅是把x替换为10+2，因此sqr(10+2)的结果是10+2*10+2，当然是32咯。为了避免这种情况，这样写就没问题了：
#define sqr(x) ( (x) * (x) )
    下面这个定义很常用：
#define MAX(a,b) ( ((a) > (b)) ? (a) : (b) )

    如果你想写出一个很有个性的C代码，反复使用#define是一个不错的选择。例如，这段代码就极具个性，一个光棍的形象跃然于屏幕上。然而，真正把#define发挥得淋漓尽致的，还是要数这段代码。

static声明
    在函数中的变量声明前加一个static可以使这个变量具有“记忆性”。观察下面的程序：
#include <stdio.h>
void printNum()
{
   int a=1;
   static int b=1;
   printf("%d %d\n", a++, b++);
}
int main()
{
   int i;
   for ( i=1; i<=5; i++ )
       printNum();
   return 0;
}
    程序输出：
1 1
1 2
1 3
1 4
1 5

short类型和int类型的范围
    最初我们列出的C语言类型和Pascal类型的对比只能提供一个参考。事实上不同的编译器中short和int的范围可能不同。你可以查一下前面说过的limits.h来确定这些类型的实际范围。通常short是16位整数，long是32位整数。在Windows下Dev-C++中int类型是32位。

对64位整型的处理
    和Free Pascal一样，对64位整数类型的处理总是比较麻烦。
    首先，对long long赋值很可能会发生错误，你可以在常数后添加一个LL表明这是long long类型。其次，C语言中有些函数是要区分数据类型的，你需要根据数据类型选用恰当的函数。最后，long long类型的输出很可能也有问题，此时你可以用"%lld"来替换"%d"，表明输出的是一个long long类型。在Windows下总要装点怪，我在Windows编译时非要用"%I64d"才行。
    下面的程序代码在Windows下Dev-C++中一切正常。
#include <stdio.h>
#include <stdlib.h>

int main()
{
    long long a;
    a = -5841314520LL;
    a = llabs(a);
    a = a + 1;
    printf("%I64d",a);
    return 0;
}

查漏补缺
    这个系列到这里就结束了。还有我没有说到的语法点吗？欢迎大家补充。

后记
    C语言速成手册到这里就结束了。这很可能是网上现有的原创C语言教材中讲解最快，篇幅最短的，因为它只适合已经学过其它语言，了解程序设计基础知识的人。这一系列的文章略过了大量的概念讲解、示例代码和习题，你可以自己在网上阅读一些C语言程序作为补充。以后我可能还会写一些类似的文章介绍其它语言。下一步我计划写C与C++的区别，对象和类的介绍以及C++的新特性。再以后我可能会向Java或者Ruby的方向发展。
    祝各位努力转C的OIer暑假愉快。

Matrix67原创
转贴请注明出处

    下个月打算换空间商，主要原因是目前所用的空间的控制面板功能不强。现在正在考虑选哪一家的asp虚拟主机，最好是asp+php的，年费300以下吧。昨天没事在网上搜了一下相关信息，没想到所有的服务商都惹来骂声一片。仔细想想这也正常，毕竟大家都是吃了苦头才会出来叫冤，空间用得上好的人没事不会平白无故地发帖表扬服务商。当然我最初也在想，能不能通过骂的人的数量来评价服务商。后来我发现这是不科学的：骂的人多了，可能服务质量确实差；骂的人少了，很可能是因为根本没有几个客户。因此最后还是想问各位网友，你们觉得哪些地方好的都请推荐一下。

火星文一则，若看过莫见怪，今天偶然看到后感觉真的很神奇。
播放时请务必戴上耳机，耳机音质越高越好。

虚拟理发店：超级真实的听觉体验。理发师会告诉你这背后的科学知识。
火柴盒：你会听到一个人在你周围各个地方摇动火柴盒，让你感到浑身不自在

Shepard悖论：你会感觉音调不断在上升，但事实上这段声音的开头和结尾音调是一样的。如果不断重复播放这段声音，音调似乎在永无止境地上升。非常神奇。
坠落的铃铛：你会感觉音调在不断下降，但事实上音调在不断上升（从开头重新播放来证实这一点）
加速击打：你会觉得打击声速度在加快，但事实上开头和结尾的速度是一样的（我咋没啥感觉呢）

后面三个声音错觉来自http://www.noah.org/science/audio_paradox，你也可以在那里找到下载的地方

http://dzh.mop.com/topic/readSub_7615180_0_0.html
这是我在猫扑读的最长的帖子，我全部看完了。非常牛的帖子，我在这里推荐一下。
我不觉得这是一个BT帖，相反这是一个相当有思想的帖子（即使里面有一些错误），能带给人很多思考。

    100除以7的余数是2，意思就是说把100个东西七个七个分成一组的话最后还剩2个。余数有一个严格的定义：假如被除数是a，除数是b（假设它们均为正整数），那么我们总能够找到一个小于b的自然数r和一个整数m，使得a=bm+r。这个r就是a除以b的余数，m被称作商。我们经常用mod来表示取余，a除以b余r就写成a mod b = r。
    如果两个数a和b之差能被m整除，那么我们就说a和b对模数m同余（关于m同余）。比如，100-60除以8正好除尽，我们就说100和60对于模数8同余。它的另一层含义就是说，100和60除以8的余数相同。a和b对m同余，我们记作a≡b(mod m)。比如，刚才的例子可以写成100≡60(mod 8)。你会发现这种记号到处都在用，比如和数论相关的书中就经常把a mod 3 = 1写作a≡1(mod 3)。
    之所以把同余当作一种运算，是因为同余满足运算的诸多性质。比如，同余满足等价关系。具体地说，它满足自反性（一个数永远和自己同余）、对称性（a和b同余，b和a也就同余）和传递性（a和b同余，b和c同余可以推出a和c同余）。这三个性质都是显然的。
    同余运算里还有稍微复杂一些的性质。比如，同余运算和整数加减法一样满足“等量加等量，其和不变”。小学我们就知道，等式两边可以同时加上一个相等的数。例如，a=b可以推出a+100=b+100。这样的性质在同余运算中也有：对于同一个模数m，如果a和b同余，x和y同余，那么a+x和b+y也同余。在我看来，这个结论几乎是显然的。当然，我们也可以严格证明这个定理。这个定理对减法同样有效。

    性质：如果a≡b(mod m)，x≡y(mod m)，则a+x≡b+y(mod m)。
    证明：条件告诉我们，可以找到p和q使得a-mp = b-mq，也存在r和s使得x-mr = y-ms。于是a-mp + x-mr = b-mq + y-ms，即a+x-m(p+r) = b+y-m(q+s)，这就告诉我们a+x和b+y除以m的余数相同。

    容易想到，两个同余式对应相乘，同余式两边仍然相等：
    如果a≡b(mod m)，x≡y(mod m)，则ax≡by(mod m)。
    证明：条件告诉我们，a-mp = b-mq，x-mr = y-ms。于是(a-mp)(x-mr) = (b-mq)(y-ms)，等式两边分别展开后必然是ax-m(...) = by-m(...)的形式，这就说明ax≡by(mod m)。

    现在你知道为什么有的题要叫你“输出答案mod xxxxx的结果”了吧，那是为了避免高精度运算，因为这里的结论告诉我们在运算过程中边算边mod和算完后再mod的结果一样。假如a是一个很大的数，令b=a mod m，那么(a * 100) mod m和(b * 100) mod m的结果是完全一样的，这相当于是在a≡b (mod m)的两边同时乘以100。这些结论其实都很显然，因为同余运算只关心余数（不关心“整的部分”），完全可以每一次运算后都只保留余数。因此，整个运算过程中参与运算的数都不超过m，避免了高精度的出现。

    在证明Fermat小定理时，我们用到了这样一个定理：
    如果ac≡bc(mod m)，且c和m互质，则a≡b(mod m) （就是说同余式两边可以同时除以一个和模数互质的数）。
    证明：条件告诉我们，ac-mp = bc-mq，移项可得ac-bc = mp-mq，也就是说(a-b)c = m(p-q)。这表明，(a-b)c里需要含有因子m，但c和m互质，因此只有可能是a-b被m整除，也即a≡b(mod m)。

    可能以后还要用到更多的定理，到时候在这里更新。

Matrix67原创
转贴请注明出处

    不知道大家的PJBlog是否有这个问题：如果某篇日志较短，日志预览内容没有被切割（和原日志相同）时，首页日志预览内容底下仍然要跟一个“查看更多”链接，而按道理说此时是不应该出现这个链接的。我一直以为PJBlog不能判断日志预览内容和全文内容是否一样，直到今天我突然发现首页上的最近几篇日志居然没有出现“查看更多”链接。经过实验，发现只要有空格、引号等特殊字符出现时，PJBlog总会认为日志预览和全文不相同。查看PJBlog的源代码，发现问题果然出现在CheckStr函数上。这不知是舜子的疏忽还是有什么其它的原因（耗资源？）。
    打开class目录下的cls_logAction.asp，查找下面这一行：
if log_View("log_Intro")<>HtmlEncode(log_View("log_Content")) then
    改成：
if UnCheckStr(log_View("log_Intro"))<>HtmlEncode(UnCheckStr(log_View("log_Content"))) then

    打开class目录下的cls_default.asp，查找下面这一行：
<%if webLogArr(10,PageCount)<>HtmlEncode(webLogArr(11,PageCount)) then%>
    改成：
<%if UnCheckStr(webLogArr(10,PageCount))<>HtmlEncode(UnCheckStr(webLogArr(11,PageCount))) then%>

    再次回到PJBlog首页，“查看更多”链接就正常了。当然，如果你的日志是静态的，别忘了到后台初始化一次。目前我是用的静态日志输出，UBB编辑器，按行自动分隔，修改之后一切正常。

Matrix67原创，转贴请注明出处

    一个数是素数（也叫质数），当且仅当它的约数只有两个——1和它本身。规定这两个约数不能相同，因此1不是素数。对素数的研究属于数论范畴，你可以看到许多数学家没事就想出一些符合某种性质的素数并称它为某某某素数。整个数论几乎就围绕着整除和素数之类的词转过去转过来。对于写代码的人来说，素数比想像中的更重要，Google一下BigPrime或者big_prime你总会发现大堆大堆用到了素数常量的程序代码。平时没事时可以记一些素数下来以备急用。我会选一些好记的素数，比如4567, 124567, 3214567, 23456789, 55566677, 1234567894987654321, 11111111111111111111111 (23个1)。我的手机号前10位是个素数。我的网站域名的ASCII码连起来(77 97 116 114 105 120 54 55 46 99 111 109)也是个素数。还有，我的某个MM的八位生日也是一个素数。每次写Hash函数之类的东西需要一个BigPrime常量时我就取她的生日，希望她能给我带来好运。偶尔我叫她素MM，没人知道是啥意思，她自己也不知道。
    素数有很多神奇的性质。我写5个在下面供大家欣赏。

1. 素数的个数无限多（不存在最大的素数）
  证明：反证法，假设存在最大的素数P，那么我们可以构造一个新的数2 * 3 * 5 * 7 * ... * P + 1（所有的素数乘起来加1）。显然这个数不能被任一素数整除（所有素数除它都余1），这说明我们找到了一个更大的素数。

2. 存在任意长的一段连续数，其中的所有数都是合数（相邻素数之间的间隔任意大）
  证明：当0<a<=n时，n!+a能被a整除。长度为n-1的数列n!+2, n!+3, n!+4, ..., n!+n中，所有的数都是合数。这个结论对所有大于1的整数n都成立，而n可以取到任意大。

3. 所有大于2的素数都可以唯一地表示成两个平方数之差。
  证明：大于2的素数都是奇数。假设这个数是2n+1。由于(n+1)^2=n^2+2n+1，(n+1)^2和n^2就是我们要找的两个平方数。下面证明这个方案是唯一的。如果素数p能表示成a^2-b^2，则p=a^2-b^2=(a+b)(a-b)。由于p是素数，那么只可能a+b=p且a-b=1，这给出了a和b的唯一解。

4. 当n为大于2的整数时，2^n+1和2^n-1两个数中，如果其中一个数是素数，那么另一个数一定是合数。
  证明：2^n不能被3整除。如果它被3除余1，那么2^n-1就能被3整除；如果被3除余2，那么2^n+1就能被3整除。总之，2^n+1和2^n-1中至少有一个是合数。

5. 如果p是素数，a是小于p的正整数，那么a^(p-1) mod p = 1。
  这个证明就有点麻烦了。
    首先我们证明这样一个结论：如果p是一个素数的话，那么对任意一个小于p的正整数a，a, 2a, 3a, ..., (p-1)a除以p的余数正好是一个1到p-1的排列。例如，5是素数，3, 6, 9, 12除以5的余数分别为3, 1, 4, 2，正好就是1到4这四个数。
    反证法，假如结论不成立的话，那么就是说有两个小于p的正整数m和n使得na和ma除以p的余数相同。不妨假设n>m，则p可以整除a(n-m)。但p是素数，那么a和n-m中至少有一个含有因子p。这显然是不可能的，因为a和n-m都比p小。
    用同余式表述，我们证明了：
(p-1)! ≡ a * 2a * 3a * ... * (p-1)a (mod p)
    也即：
(p-1)! ≡ (p-1)! * a^(p-1) (mod p)
    两边同时除以(p-1)!，就得到了我们的最终结论：
1 ≡ a^(p-1) (mod p)

    可惜最后这个定理最初不是我证明的。这是大数学家Fermat证明的，叫做Fermat小定理(Fermat's Little Theorem)。Euler对这个定理进行了推广，叫做Euler定理。Euler一生的定理太多了，为了和其它的“Euler定理”区别开来，有些地方叫做Fermat小定理的Euler推广。Euler定理中需要用一个函数f(m)，它表示小于m的正整数中有多少个数和m互素（两个数只有公约数1称为互素）。为了方便，我们通常用记号φ(m)来表示这个函数（称作Euler函数）。Euler指出，如果a和m互素，那么a^φ(m) ≡ 1 (mod m)。可以看到，当m为素数时，φ(m)就等于m-1（所有小于m的正整数都与m互素），因此它是Fermat小定理的推广。定理的证明和Fermat小定理几乎相同，只是要考虑的式子变成了所有与m互素的数的乘积：m_1 * m_2 ... m_φ(m) ≡ (a * m_1)(a * m_2) ... (a * m_φ(m)) (mod m)。我为什么要顺便说一下Euler定理呢？因为下面一句话可以增加我网站的PV：这个定理出现在了The Hundred Greatest Theorems里。

    谈到Fermat小定理，数学历史上有很多误解。很长一段时间里，人们都认为Fermat小定理的逆命题是正确的，并且有人亲自验证了a=2, p<300的所有情况。国外甚至流传着一种说法，认为中国在孔子时代就证明了这样的定理：如果n整除2^(n-1)-1，则n就是素数。后来某个英国学者进行考证后才发现那是因为他们翻译中国古文时出了错。1819年有人发现了Fermat小定理逆命题的第一个反例：虽然2的340次方除以341余1，但341=11*31。后来，人们又发现了561, 645, 1105等数都表明a=2时Fermat小定理的逆命题不成立。虽然这样的数不多，但不能忽视它们的存在。于是，人们把所有能整除2^(n-1)-1的合数n叫做伪素数(pseudoprime)，意思就是告诉人们这个素数是假的。
    不满足2^(n-1) mod n = 1的n一定不是素数；如果满足的话则多半是素数。这样，一个比试除法效率更高的素性判断方法出现了：制作一张伪素数表，记录某个范围内的所有伪素数，那么所有满足2^(n-1) mod n = 1且不在伪素数表中的n就是素数。之所以这种方法更快，是因为我们可以使用二分法快速计算2^(n-1) mod n 的值，这在计算机的帮助下变得非常容易；在计算机中也可以用二分查找有序数列、Hash表开散列、构建Trie树等方法使得查找伪素数表效率更高。
    有人自然会关心这样一个问题：伪素数的个数到底有多少？换句话说，如果我只计算2^(n-1) mod n的值，事先不准备伪素数表，那么素性判断出错的概率有多少？研究这个问题是很有价值的，毕竟我们是OIer，不可能背一个长度上千的常量数组带上考场。统计表明，在前10亿个自然数中共有50847534个素数，而满足2^(n-1) mod n = 1的合数n有5597个。这样算下来，算法出错的可能性约为0.00011。这个概率太高了，如果想免去建立伪素数表的工作，我们需要改进素性判断的算法。

    最简单的想法就是，我们刚才只考虑了a=2的情况。对于式子a^(n-1) mod n，取不同的a可能导致不同的结果。一个合数可能在a=2时通过了测试，但a=3时的计算结果却排除了素数的可能。于是，人们扩展了伪素数的定义，称满足a^(n-1) mod n = 1的合数n叫做以a为底的伪素数(pseudoprime to base a)。前10亿个自然数中同时以2和3为底的伪素数只有1272个，这个数目不到刚才的1/4。这告诉我们如果同时验证a=2和a=3两种情况，算法出错的概率降到了0.000025。容易想到，选择用来测试的a越多，算法越准确。通常我们的做法是，随机选择若干个小于待测数的正整数作为底数a进行若干次测试，只要有一次没有通过测试就立即把这个数扔回合数的世界。这就是Fermat素性测试。
    人们自然会想，如果考虑了所有小于n的底数a，出错的概率是否就可以降到0呢？没想到的是，居然就有这样的合数，它可以通过所有a的测试（这个说法不准确，详见我在地核楼层的回复）。Carmichael第一个发现这样极端的伪素数，他把它们称作Carmichael数。你一定会以为这样的数一定很大。错。第一个Carmichael数小得惊人，仅仅是一个三位数，561。前10亿个自然数中Carmichael数也有600个之多。Carmichael数的存在说明，我们还需要继续加强素性判断的算法。

    Miller和Rabin两个人的工作让Fermat素性测试迈出了革命性的一步，建立了传说中的Miller-Rabin素性测试算法。新的测试基于下面的定理：如果p是素数，x是小于p的正整数，且x^2 mod p = 1，那么要么x=1，要么x=p-1。这是显然的，因为x^2 mod p = 1相当于p能整除x^2-1，也即p能整除(x+1)(x-1)。由于p是素数，那么只可能是x-1能被p整除(此时x=1)或x+1能被p整除(此时x=p-1)。
    我们下面来演示一下上面的定理如何应用在Fermat素性测试上。前面说过341可以通过以2为底的Fermat测试，因为2^340 mod 341=1。如果341真是素数的话，那么2^170 mod 341只可能是1或340；当算得2^170 mod 341确实等于1时，我们可以继续查看2^85除以341的结果。我们发现，2^85 mod 341=32，这一结果摘掉了341头上的素数皇冠，面具后面真实的嘴脸显现了出来，想假扮素数和我的素MM交往的企图暴露了出来。
    这就是Miller-Rabin素性测试的方法。不断地提取指数n-1中的因子2，把n-1表示成d*2^r（其中d是一个奇数）。那么我们需要计算的东西就变成了a的d*2^r次方除以n的余数。于是，a^(d * 2^(r-1))要么等于1，要么等于n-1。如果a^(d * 2^(r-1))等于1，定理继续适用于a^(d * 2^(r-2))，这样不断开方开下去，直到对于某个i满足a^(d * 2^i) mod n = n-1或者最后指数中的2用完了得到的a^d mod n=1或n-1。这样，Fermat小定理加强为如下形式：
    尽可能提取因子2，把n-1表示成d*2^r，如果n是一个素数，那么或者a^d mod n=1，或者存在某个i使得a^(d*2^i) mod n=n-1 ( 0<=i<r ) （注意i可以等于0，这就把a^d mod n=n-1的情况统一到后面去了）
    Miller-Rabin素性测试同样是不确定算法，我们把可以通过以a为底的Miller-Rabin测试的合数称作以a为底的强伪素数(strong pseudoprime)。第一个以2为底的强伪素数为2047。第一个以2和3为底的强伪素数则大到1 373 653。
    Miller-Rabin算法的代码也非常简单：计算d和r的值（可以用位运算加速），然后二分计算a^d mod n的值，最后把它平方r次。程序的代码比想像中的更简单，我写一份放在下边。虽然我已经转C了，但我相信还有很多人看不懂C语言。我再写一次Pascal吧。函数IsPrime返回对于特定的底数a，n是否是能通过测试。如果函数返回False，那说明n不是素数；如果函数返回True，那么n极有可能是素数。注意这个代码的数据范围限制在longint，你很可能需要把它们改成int64或高精度计算。
function pow( a, d, n:longint ):longint;
begin
   if d=0 then exit(1)
   else if d=1 then exit(a)
   else if d and 1=0 then exit( pow( a*a mod n, d div 2, n) mod n)
   else exit( (pow( a*a mod n, d div 2, n) * a) mod n);
end;

function IsPrime( a,n:longint ):boolean;
var
   d,t:longint;
begin
   if n=2 then exit(true);
   if (n=1) or (n and 1=0) then exit(false);
   d:=n-1;
   while d and 1=0 do d:=d shr 1;
   t:=pow( a, d, n );
   while ( d<>n-1 ) and ( t<>1 ) and ( t<>n-1 ) do
   begin
      t:=(t * t)mod n;
      d:=d shl 1;
   end;
   exit( (t=n-1) or (d and 1=1) );
end;
    对于大数的素性判断，目前Miller-Rabin算法应用最广泛。一般底数仍然是随机选取，但当待测数不太大时，选择测试底数就有一些技巧了。比如，如果被测数小于4 759 123 141，那么只需要测试三个底数2, 7和61就足够了。当然，你测试的越多，正确的范围肯定也越大。如果你每次都用前7个素数(2, 3, 5, 7, 11, 13和17)进行测试，所有不超过341 550 071 728 320的数都是正确的。如果选用2, 3, 7, 61和24251作为底数，那么10^16内唯一的强伪素数为46 856 248 255 981。这样的一些结论使得Miller-Rabin算法在OI中非常实用。通常认为，Miller-Rabin素性测试的正确率可以令人接受，随机选取k个底数进行测试算法的失误率大概为4^(-k)。

    Miller-Rabin算法是一个RP算法。RP是时间复杂度的一种，主要针对判定性问题。一个算法是RP算法表明它可以在多项式的时间里完成，对于答案为否定的情形能够准确做出判断，但同时它也有可能把对的判成错的（错误概率不能超过1/2）。RP算法是基于随机化的，因此多次运行该算法可以降低错误率。还有其它的素性测试算法也是概率型的，比如Solovay-Strassen算法。另外一些素性测试算法则需要预先知道一些辅助信息（比如n-1的质因子），或者需要待测数满足一些条件（比如待测数必须是2^n-1的形式）。前几年AKS算法轰动世界，它是第一个多项式的、确定的、无需其它条件的素性判断算法。当时一篇论文发表出来，题目就叫PRIMES is in P，然后整个世界都疯了，我们班有几个MM那天还来了初潮。算法主要基于下面的事实：n是一个素数当且仅当(x-a)^n≡(x^n-a) (mod n)。注意这个x是多项式中的未知数，等式两边各是一个多项式。举个例子来说，当a=1时命题等价于如下结论：当n是素数时，杨辉三角的第n+1行除两头的1以外其它的数都能被n整除。

Matrix67原创
转贴请注明出处

今天早上登陆Google分析，发现昨天的网站点击来源里居然有这么一项……
有没有人能解释一下这是为什么？