金字塔有世界七大奇迹之一的美称，我们在埃及和美洲等地方发现大部分都有金字塔建筑的分布，我们在尼罗河流域而的下游也发现了80座金字塔，其中胡夫金字塔是最高的金字塔。金字塔里的更加有奇妙之处的东西，就是埃及金字塔里留下的142857这一串数字的秘密，这究竟有何奥妙之处呢？142857这一串神奇的数字也被称为走马灯数，这一串数字非常的奇妙，它可以帮我们证明一个星期有7天，因为它的自我累加一次，就会由它的6个数字依照顺序轮值一次，等到了第7天，这一串数字就会消失不见了，取而代之的是由999999去替代142857，然后随着数字的逐渐加大，每超过一个星期的轮回，每个数字都需要分身一次，然而我们并不需要用到计算机，也可以轻松地知道继续累加的答案，我们只需要清楚地了解它的分身方法规律，给大家举个科学的列子：。由素数定理我们知道小于n的素数大约有n/ln个，所以ln是小于n的素数之间的平均间隔。再次，素数定理证明g/ln p的均值是1，但我们怎么认识g/ln p这个数列呢？ricci证明这个集合的极限点集具有正的勒贝格测度，但迄今为止被证明的极限点只有无穷。

#头条青云“叫好又叫座”作品征集#

〈一〉。

金字塔有世界七大奇迹之一的美称，我们在埃及和美洲等地方发现大部分都有金字塔建筑的分布，我们在尼罗河流域而的下游也发现了80座金字塔，其中胡夫金字塔是最高的金字塔。

我们也许会被金字塔的外形所吸引，它的形状很像我们汉字的“金”字，会惊叹它的建筑之美；我们也许对于金字塔是如何建造的会感到好奇，想要知道建造金字塔的秘密，会有很多的科学家去探寻它的建筑之奇特；我们也许还会对金字塔的塔底，它的正方形的周长约等于圆的周长感到好奇，也就是说金字塔塔底的正方形周长除以2倍的高度会约等于π。

金字塔里的更加有奇妙之处的东西，就是埃及金字塔里留下的142857这一串数字的秘密，这究竟有何奥妙之处呢？

142857这一串神奇的数字也被称为走马灯数，这一串数字非常的奇妙，它可以帮我们证明一个星期有7天，因为它的自我累加一次，就会由它的6个数字依照顺序轮值一次，等到了第7天，这一串数字就会消失不见了，取而代之的是由999999去替代142857，然后随着数字的逐渐加大，每超过一个星期的轮回，每个数字都需要分身一次，然而我们并不需要用到计算机，也可以轻松地知道继续累加的答案，我们只需要清楚地了解它的分身方法规律，给大家举个科学的列子：

我们先来看一下这一串数字乘1到14的结果，分别是：

142857 x 1 = 142857；

142857 x 2 = 285714；

142857 x 3 = 428571；

142857 x 4 = 571428，

142857 x 5 = 714285；

142857 x 6 = 857142；

142857×7＝999999；

142857×8＝1142856；

142857×9＝1285713；

142857×10＝1428570

142857×11＝1571427

142857×12＝1714284；

142857×13＝1857141；

142857×14＝1999998。

由以上结论可以推断出，从1至6的这种乘法的运算结果还是同样的6个数字反复出现，只是它们的位置顺序发生了变化，而后乘以7的时候，就变成了由999999替代这一串数字，往后乘以8的时候，我们会发现多了一个1和6，缺少了7，也许我们会纳闷这还有规律可循吗？其实是有的，这里面多出来的1和6，他们相加起来便是缺少的7了，由此推下去，乘以9的时候，多出来的1和3相加起来就是4了。

而且142857这一串数字也有这种奇妙之处，它分为两部分相加时等于999，如142+857=999，它拆成三部分的时候等于99，如14+28+57=99，它们都与9相关，真是神奇呀，还有就是用142857乘以142857会等于20408122449，而把它分成两部分相加又会变为原来的142857，如20408+122449=142857。

〈二〉。

一个很常见的问题：连续素数的间隔可以有多大？在我们回答这个问题之前，让我们先来谨慎地明确间隔的定义（有两个不同的常见定义）。对于每一个素数p，使g(p)等于p和大于p第一个素数之间的合数数量。因此，设第n个素数为p_{n} (p_{n}表示字母p的下标是n)，我们有：

p_{n+1} = p_{n} + g(p_{n}) + 1

即,g(p_{n})是p_{n}和p_{n+1}之间的间隔的大小。

由素数定理我们知道小于n的素数大约有n/ln(n)个，所以ln(n)是小于n的素数之间的平均间隔。然而，这些间隔会有怎样的宽度范围呢？下面我们将会讨论这个问题的几个方面。

首先要注意的是孪生素数就是使得g(p) = 1的p, p+2，所以从孪生素数猜想我们就有这个猜想：有无穷多个p，使得g(p) = 1（或者等价于lim inf g(n) = 1）。

第二个需要注意的是g(p)可以任意大。不妨令n为大于1的任意整数，考虑下面这个连续的整数列：

n!+2, n!+3, n!+4, n!+5, ..., n!+n

注意到2可以整除第一个数，3可以整除第二个数，以此类推，n可以整除第n-1个数，证明了这个数列的所有数都是合数。所以如果p是小于n!+2的最大素数，那我们就得到g(p) > n-1。显然，应该还有产生相同间隔的更小的数。例如，素数42842283925351与它后一个素数之间有777个合数。——这是间隔为777的最小的素数，并且它远小于778！+2（一个有1914位数的数）。（也可以使用更小的数，不大于n的连续素数乘积：n#，而不是使用n!）.

最后一段，我们已经证明 lim sup g(n) = ∞，然而因为平均间隔是关于ln(n)，所以我们期望得更多。westzynthius在1931年证明了：lim sup g(n)/ln(p_{n}) = ∞ 。

意味着对于每一个b>0，都有无穷多个素数p满足g(p) > b log p。在我们讲述更多之前，我们应该来看看数据上的证据

对每一个非负整数g，令p(g)是最小的由至少g个合数跟着的素数。这个告诉我们p(148) = p(149) = ... = p(153) = 4652353。

给定p，可能g(p)就会有一个上限。通过素数定理我们就能证明，对于任意实数e>0，存在某个整数n，使得总存在一个素数p满足：m p (1+e)m(对任意m > n)

这证明了，对于所有的p > max( n,1+1/e )，有g(p) ep。或者更简洁地说，对于n > k，有g(p_{n}) ep_{n}。)这里有几个关于e,k的具体数对：

对于n > 9, 有 g(p_{n}) (1/5) p_{n} (nagura 1952)

对于n >118, 有 g(p_{n}) (1/13) p_{n} (rohrbach & weis 1964 )

对于n >2010760, 有 g(p_{n}) (1/16597) p_{n} (schoenfeld 1976 )

1937年，ingham在hoheisel的开创性工作的基础上加工，从而证明了：p^(5/8 + eps)的某个常数倍是g(p)的上界（对于任意eps > 0）。许多人已经对5/8进行改进，我所知道的最新的记录是0.535，由r. baker 和 g. harman完成（但肯定的是，在现在这已经被改进了）。

再次，素数定理证明g(p)/ln p的均值是1，但我们怎么认识g(p)/ln p这个数列呢？ricci证明这个集合的极限点集具有正的勒贝格测度，但迄今为止被证明的极限点只有无穷（上述提到的点）。

对于lim inf g(p)/ln(p)的各种上界已经被发现，包括0.248（当然，孪生素数猜想和素数k元组猜想都要求下限为0）。在一个相关的猜想，cramer猜想：

lim sup g(p)/(ln p)² = 1

granbille修改了cramer猜想，揭示了它低估了间间隔的大小，granbille猜测，对于任意一个小于欧拉常数的常数c：有无穷多个p，使得g(p) ≥ 2e^{-c}ln²p。这里的常数c类似于merten定理的常数m。

这个猜想可以被证明吗？还不行，但是cramer表示，如果黎曼猜想被证实了，那么我们就可以得到一个比较弱的结果：

g(p)k ln p sqrt(p)。

〈三〉。

时至今日，素数定理已被证明，小于n的素数个数的上限和下限都已经给出，但π(n)的确切值是多少，依然是一个悬而未决的问题，一批又一批的数学家们前赴后继想登上最高峰，但都以失败告终，但这并不妨碍后面还有一批又一批的攀登者。所以千年的质数公式的探索不会简单，如果非常简单，会引起所有数学家反思的。

已知素数的相关成果还是当今密码学的基础。先行互联网的所有密码都和素数的规律有关系。素数公式的发现，将使这些密码变得毫无作用，可以预见不久的将来和密码账号有关的所有系统——比如银行账户、邮箱账号、游戏账号等——都将陷于极大的风险之中。

看一看下面一个有关素数在自然整数数轴上，1，2，3。。。。。。n。的一个排列现象，即：

2， 3， 4， 5， 6， 7。

8， 9， 10，1 1 12， 13 。

14 15，16，17，18， 19。

。。。。。。

就象这样子一直写下去，你就会发现这样一个规律：所有素数都排列在6的倍数的两边。这样就可以得出一个所谓求取素数的公式。即：6n士6。这个所谓的求取素数的公式，我曾在上世纪八九十年代的《我们爱科学》杂志上看到过。被称为求取素数的公式。

由此素数6n士1公式，联想到胡夫金字塔里的神秘数字:142857。及其对于星期天的算法惊人的一致性，而其中又与两素数之间的间隔随着自然整数n的增大而增大。而其中的规律有很大的间连和相当的关系呢。

原创首发。

本篇文章是上一篇同名文章的续篇，有兴趣的可以先看第一篇。

换元和替换法求极限方法非常好，也很锻炼思维，本篇文章不用洛必达法则，主要目的是深入领会换元和替换法思想，并达到切实掌握的目的。

一、换元法。

看例1，令x＝1/α，通过这一道题目可以看出，有时候，换元法比洛必达法则还好用。

二、替换法。

先来看例2，它主要为下面的例题提供替换依据。

看会了吗，非常简单，这一道例题最好能多看几遍，保证熟练掌握。由这一道题目可以得出lnx～x（x→0），熟练掌握它，它有非常好的妙用。

下面来看例3，体会一下怎样用替换法。

提示一下，替换依据是ln（x^m－1+1)～x^m－1和lnx＝ln（x－1+1)～x－1。

再来看例4，

思考一下，替换依据是什么。

最后看例5，

仔细想一想，它的替换依据是什么。

通过这三题，可以看出替换法非常优秀，可以达到秒杀的效果，是一种非常强大的极限计算方法。

思考最后一题，如果不用洛必达法则，还有更好的解法吗？

拍了一张漂亮的花，送给所有阅读我的文章的朋友。

switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。例如，在程序中使用数字1~7来表示星期一到星期天，如果想根据某个输入的数字来输出对应中文格式的星期值，可以通过下面的一段伪代码来描述：

用于表示星期的数字

如果等于1，则输出星期一

如果等于2，则输出星期二

如果等于3，则输出星期三

如果等于4，则输出星期四

如果等于5，则输出星期五

如果等于6，则输出星期六

如果等于7，则输出星期天

对于上面一段伪代码的描述，大家可能会立刻想到用刚学过的if…else if…else语句来实现，但是由于判断条件比较多，实现起来代码过长，不便于阅读。java中提供了一种switch语句来实现这种需求，在switch语句中使用switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句。具体实现代码如下：

switch(用于表示星期的数字) {

case 1 :

输出星期一;

break;

case 2 :

输出星期二;

break;

case 3 :

输出星期三

break;

case 4 :

输出星期四;

break;

case 5 :

输出星期五;

break;

case 6:

输出星期六;

break;

case 7:

输出星期天;

break;

}

上面改写后的伪代码便描述了switch语句的基本语法格式，具体如下：

在上面的格式中，switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没找到任何匹配的值，就会执行default后的语句。switch语句中的break关键字将在后面的做具体介绍，此外，我们只需要知道break的作用是跳出switch语句即可。

需要注意的是，在switch语句中的表达式只能是 类型的值，如果传入其它类型的值，程序会报错。但上述说法并不严谨，实际上在jdk5.0中引入的新特性 也可以作为switch语句表达式的值，在jdk7.0中也引入了新特性，switch语句可以接收一个 类型的值。

接下来通过一个案例演示根据数字来输出中文格式的星期，如下所示。

运行结果如图所示。

图1-1 运行结果

上述代码中，由于变量week的值为5，整个switch语句判断的结果满足第17行的条件，因此打印“星期五”，例程中的default语句用于处理和前面的case都不匹配的值，将第3行代码替换为int week = 8，再次运行程序，输出结果如下图所示。

图1-2 运行结果

在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。接下来通过一个案例来实现上面描述的情况，如下所示。

运行结果如下图所示。

图1-3 运行结果

上述代码中，当变量week值为1、2、3、4、5中任意一个值时，处理方式相同，都会打印“今天是工作日”。同理，当变量week值为6、7中任意一个值时，打印“今天是休息日”。

在生活中，我们可能会碰到如下的场景。

现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司有50名员工，用前面所学的知识完成，那么程序首先需要声明50个变量来分别记住每位员工的工资，这样做会显得很麻烦。

其实在java中，我们可以使用一个数组来记住这50名员工的工资。数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

在java中，可以使用以下格式来定义一个数组。如下

int[] x = new int[100];

上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。为了更好地理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：

int[] x; // 声明一个int[]类型的变量

x = new int[100]; // 创建一个长度为100的数组

接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。

第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示。

图1-4 内存状态图

第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示。

图1-5 内存状态图

在上图中描述了变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”。在java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“”的方式来获得数组的长度，即元素的个数。

接下来，通过一个案例来演示如何定义数组以及访问数组中的元素，如下所示。

运行结果如下图所示。

图1-6 运行结果

在上述代码中声明了一个int[]类型变量arr，并将数组在内存中的地址赋值给它。在5~7行代码中通过角标来访问数组中的元素，在第8行代码中通过length属性访问数组中元素的个数。从打印结果可以看出，数组中的三个元素初始值都为0，这是因为当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。具体如下表所示。

如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。接下来通过一个程序来学习如何为数组的元素赋值，如下所示。

运行结果如下图所示。

图1-7 运行结果

在上述代码中，第3行代码定义了一个数组，此时数组中每个元素都为默认初始值0。第2、3行代码通过赋值语句将数组中的元素arr[0]和arr[1]分别赋值为1和2，而元素arr[2]和arr[3]没有赋值，其值仍为0，因此打印结果中四个元素的值依次为1、2、0、0。

在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。

在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，具体格式如下：

上面的两种方式都可以实现数组的静态初始化，但是为了简便，建议采用第二种方式。接下来通过一段代码来演示数组静态初始化的效果，如下所示。

运行结果如下图所示。

图1-8 运行结果

上述代码中采用静态初始化的方式为数组每个元素赋予初值，分别是1、2、3、4。需要注意的是，第3行代码千万不可写成int[] arr = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。

在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。接下来通过一个案例来学习如何使用for循环来遍历数组，如下所示。

运行结果如下图所示。

图1-9 运行结果

上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。

数组在编写程序时应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作进行详细地讲解，如数组的遍历、最值的获取、数组的排序等。

在操作数组时，经常需要获取数组中元素的最值。接下来通过一个案例来演示如何获取数组中元素的最大值，如下所示。

运行结果如下图所示。

图1-10 运行结果

上述代码中，定义了一个临时变量max，用于记住数组的最大值。通过for 循环获取数组中的最大值，赋值给max变量。

首先假设数组中第一个元素arr[0]为最大值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比max值还大的元素，就将该元素赋值给max。这样一来，变量max就能够在循环结束时记住数组中的最大值。需要注意的是，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。

每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错，如下所示。

运行结果如下图所示。

上图运行结果中所提示的错误信息是数组越界异常arrayindexoutofboundsexception，出现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。

所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因，关于异常在后面的章节会有详细的讲解。

在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，接下来通过一个案例来演示这种异常，如下所示。

运行结果如下图所示。

图1-11 运行结果

通过上图所示的运行结果可以看出，上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常nullpointerexception。

在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组，接下来针对二维数组进行详细地讲解。

二维数组的定义有很多方式，接下来针对几种常见的方式进行详细地讲解，具体如下：

上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组，接下来通过一个图来表示这种情况，如下图所示。

图1-12 二维数组

第二种方式和第一种类似，只是数组中每个元素的长度不确定，接下来通过一个图来表示这种情况，如下图所示。

图1-13 二维数组

上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，接下来通过一个图来表示这种情况，如图1-14所示。

图1-14 二维数组

对二维数组中元素的访问也是通过角标的方式，如需访问二维数组中第一个元素数组的第二个元素，具体代码如下：

arr[0][1];

操作二维数组时，经常需要获取数组中元素的值。接下来通过一个案例来演示如何获取数组中元素值，如下所示。

运行结果如下图所示：

图1-15 运行结果

二维数组元素遍历与数组元素累加和

学习完了数组元素的访问，我们来学习下数组的遍历及数组的元素累加和操作。

运行结果如下图所示：

图1-16 运行结果

接下来通过一个案例来熟悉二维数组的使用。

例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示

运行结果如下图所示。

图1-17 运行结果

在上述代码中，第3行代码定义了一个长度为3的二维数组，并在4~6行代码中为数组的每个元素赋值。例程中还定义了两个变量sum和groupsum，其中sum用来记录公司的总销售额，groupsum用来记录每个销售小组的销售额。当通过嵌套for循环统计销售额时，外层循环对三个销售小组进行遍历，内层循环对每个小组员工的销售额进行遍历，内层循环每循环一次就相当于将一个小组员工的销售总额统计完毕，赋值给groupsum，然后把groupsum的值与sum的值相加赋值给sum。当外层循环结束时，三个销售小组的销售总额groupsum都累加到sum中，即统计出了整个公司的销售总额。

随机点名器，即在全班同学中随机的打印出一名同学名字。

要做的随机点名器，它具备以下3个内容：

在编写案例前，我们先来学习下本案例中所涉及到的知识点：

数组

在全班同学中随机的打印出一名同学名字。

我们对本案例进行分析，得出如下分析结果：

1.存储全班同学名字

2.打印全班同学每一个人的名字

3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。

上述代码中，通过随机数类random产生一个从0到数组长度的随机索引。使用该索引获取students数组中对应的值，便得到了全班同学的随机姓名。

它是一个用来存储同一个数据类型多个元素的一个容器（数组长度是固定的，数组中存储的元素的数据类型要求一致）

格式：

格式1：

数据类型[] 数组名 = new 数据类型[数组长度];

格式2:

数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,..};

格式3：

数据类型[] 数组名 = {元素值1,元素值2,..};

nullpointerexception: 空指针异常

arrayindexoutofboundsexception: 数组越界异常

它是一个包含多个一维数组的数组

特点：二维数组中的每个元素都是一个一维数组

格式：

格式1：

数据类型[][] 数组名 = new 数据类型[m][n];

m: 代表二维数组中一维数组的个数

n: 代表每个一维数组中元素的个数

格式2：

数据类型[][] 数组名 = new 数据类型[m][];

m: 代表二维数组中一维数组的个数

每一个一维数组通过赋值来确定数组长度

格式3：

数据类型[][] 数组名 = {{元素值1，元素值2,..},{元素值1，元素值2,..},..};