一道google面试题--自然数e中出现的连续的第一个10个数字组成的质数

最新推荐文章于 2024-10-05 11:36:49 发布
最新推荐文章于 2024-10-05 11:36:49 发布
阅读量1.3w 收藏 28
点赞数 8
分类专栏： C++ Primer 5 C 笔试/面试 科研 Linux 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huaxi1902/article/details/39155515
版权
Linux 同时被 3 个专栏收录
31 篇文章 0 订阅
订阅专栏
C
4 篇文章 0 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏


博客内容移到 http://www.linuxyu.com/

此CSDN博客将不再更新，欢迎大家访问新的网站~~


Google早几年在美国很多地铁的出站口都有大幅招聘广告，它的第一题如下了：{first 10-digit prime found in consecutive digits e}.com，也就是自然数e中出现的连续的第一个10个数字组成的质数。据说当时只要正确解答了这道题，在浏览器的地址栏中输入这个答案，就可以进入下一轮的测试，整个测试过程如同一个数学迷宫，直到你成为google的一员。

对这题比较感兴趣，就暂时开题，这两天动笔完成这篇博客。

难点分析

初步分析，主要两个难点：

（1）e的小数点后n位有效数字，提供素数判断的数据源；

（2）素数的高效判断，尤其时针对10位数的指数判断。

自然数e计算

计算e可使用泰勒公式推出来的

e^x≈1 + x + x^2/2! + x^3/3! +……+ x^n/n!  （1）

当x=1时，

e≈1 + 1 + 1/2! + 1/3! +……+ 1/n!   （2）

取n=10,即可算出近似值e≈2.7182818。 当n取较大值时，可获得高精度的e。

版本1

最初步的想法，直接利用泰勒公式计算，printf出来。

//compute e 
//program 1

#include <stdio.h>
#define N 20

int main()
{
    double e = 1.0, t = 1.0;
    int i = 0;

    for(i = 1; i <= N; i++){
        t = t / i;
        e = e + t;
    }

    printf ("e=%.20lf\n",e );
    return 0;
}

版本2

对（2）进行叠乘合并起来，改写成如下（3）：

e=2+1/2(1+1/3(1+1/4(1+…1/(n-1)(1+1/n)…)))   （3）

从最里面的括号往外算，共做n次除法和加法得一段结果，运算效率也是O(N*M)，但是由于收敛速度快些。

//compute e 
//program 2

#include <stdio.h>
#define N 20

int main()
{
    double e = 0.0;
    int i = 0;

    for(i = N; i > 0; i--){
        e = (e + 1.0) / i;
    }

    printf ("e=%.20lf\n",e );
    return 0;
}

版本3

版本1和2只能达到小数点后15位精度，假设我们需要的数据源是e达到e后面1000位数，那么就必须要考虑到高精度的问题。自定义数据结构时必须的，但（3）中主要计算加法、减法和乘法不会丢失精度，而除法会丢失精度，因为它始终存在余数，余数是丢失精度的原因，所以要保存精度就是保存余数，在这里的除法将产生两个整数，一个是商，一个是余数，形如：

a / b = (d,r)

如果以10为基，那高精度就是对这样的除法继续做下去，将r*10恢复精度，再除，直到满足精度为止。

//compute e 
//program 3

#include <stdio.h>

//umber of significant digit=(DN-1)*4
#define DN 2504

int euler[DN], data[DN];
int step,n;

void precise_division()
{
    int i=0;
    long y=0,r=0;

    for(i=step;i<DN;i++)
    {
        y = 10000*r + data[i];
        data[i] = y/n;
        euler[i] += data[i];
        r = y%n;
    }
}

void revise()
{
    int c=0,i=0;

    for(i=DN-1;i>=0;i--)
    {
        euler[i] += c;
        if(euler[i]>9999)
        {
            c = euler[i]/10000;
            euler[i] = euler[i]%10000;
        }
        else
            c = 0;
    }
}

void euler_print()
{
    int i=0;

    printf("\n\nE=%d.\n",euler[0]);
    for(i=1;i<DN;i++)
    {
        printf("%.4d ",euler[i]);
        if((i%250)==0)
            printf("\n\tnow it has %d bit\n",i*4);
    }
    printf("\n\neulur number is ok\n");
}

void main()
{
    int i=0;
    step=0;
    n=1;

    for(i=0;i<DN;i++)
    {
        euler[i]=0;
        data[i]=0;
    }
    euler[0]=1;
    data[0]=1;

    while(1)
    {
        i=step;
        while(data[i]==0)
        {
            i++;
            if(i>=DN)
            goto _EXT;
        }

        step=i;
        precise_division();
        revise();
        n++;
    }

_EXT:
    euler_print();
}

版本4

参考文献2，实现本版本，唯一没有想通的部分在于GetLength函数实现的数学原理，这个后续再补充。

//compute e 
//program 4

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//umber of significant digit
#define N 10000

typedef unsigned int UINT;

int GetLength(int m)
{
    int n=1;
    double x=2.0/2.72;
    while(m)
    {
        while(x<1.0)
        {
            n++;
            x*=(double)(n+1);
        }
        while(x>=1.0 && m)
        {
            x/=10.0;
            --m;
        }
    }
    while(x<1.0)
    {
        n++;
        x*=(double)(n+1);
    }
    return n;
}

void main()
{
    const UINT base=1000000;
    int i,j,k,m;
    UINT *r=NULL;
    UINT *euler=NULL;
    UINT y=0;

    m=GetLength(N);

    r=(UINT *)calloc(m+1,sizeof(UINT));
    euler=(UINT *)calloc(N,sizeof(UINT));

    assert(r!=NULL);
    assert(euler!=NULL);

    for(i=0;i<=m;++i)
    {
        r[i]=1;
        euler[i]=0;
    }

    j=1;
    euler[0] = 2;

    for(k=N;k>0;k-=6)
    {
        y=0;
        for(i=m;i>=2;--i)
        {
            y = y + r[i]*base;
            r[i] = y%i;
            y /= i;
        }

        if(k<6)
        {
            euler[j++] = y%base;
        }
        else
        {
            if(y<base)
                euler[j++] = y;
            else
            {
                if(r)
                    free(r);
                return;
            }
        }
    }
    if(r)
        free(r);

    printf("\n\nE=%d.\n",euler[0]);
    for(i=1;i<j;i++)
    {
        printf("%.6d ",euler[i]);
        if((i%100)==0)
            printf("\n\tnow it has %d bit\n",i*6);
    }
    printf("\n\neulur number is ok\n");

    if(euler)
        free(euler);

    return;
}

素数判断

版本1

素数，即除1以外，只能被1和其本身整除的数。因此根据定义，最初的判断素数的方法为版本1。

//judge prime 
//program 1
bool prime_1(int n)
{
    int i;
    for(i=2;i<n;i++)
    {
        if(n%i==0)
        {
            return false;
        }
    }
    return true;
}

版本2

由于一个数的因式分解可表示为x = a * b, a<=b，因此在判断整数n是不是素数时并不需要整数从2 ～ n，只需要整除2 ～ sqrt(n) 即可。

//judge prime 
//program 2
bool prime_2(int n)
{
    int i,n2;

    n2=sqrt(n);
    for(i=2;i<=n2;i++)
    {
        if(n%i==0)
        {
            return false;
        }
    }
    return true;
}

但是需要注意的是，int类型只能表示2^-31 ~ 2^31 范围，并不能完整表示10位大小的整数n，因此需要使用能够long long int类型。其次，求平方根的函数原型为double sqrt(double)，进行sqrt(n)计算时并不确定能保证其精度。最后，对e小数点后，每个10位数字大小的整数n进行判断，需要对每个2 ～ sqrt(n)的整数进行判断，单个判断耗时间太久，所有判断重复运算太多。因此次方法必然不行。

版本3

任何一个合数都可以表现为适当个素数的乘积的形式，所以我们只用素数去除要判断的数即可，比如要判断100以内的素数，只用10以内的2，3，5，7就够了。那么首先就要构建一个素数表，以空间换时间。

可以使用一种被称为“埃拉托色尼筛”的算法。该算法一开始初始化一个2～n的连续整数序列。从2开始，2的倍数肯定不是素数，去除，剩下的数中下一个是3。再把3的倍数去除，再下一个是5（4已经去除了），以此类推，最后剩下的数必然是素数，因为它没有被筛，不是任何一个数的倍数（除了1和自己）。这样只需要很多次加法就可以了。

//create prime less then n 
//program 3

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  //Linux, gcc -lm
#include <stdbool.h>


#define Long64 long long
#define MAX_N 8000000

Long64 prime_table[MAX_N/2]={0};

void create_prime_table(Long64 n)
{
    Long64 i,j,n2;
    bool prime[MAX_N+1]={0};

    n2=sqrt(n);

    i=2;
    for(i=2;i<=n2;i++)
    {
        if(prime[i]==0)
        {
            for(j=i+i;j<=n;j+=i)
            {
                prime[j]=1;
            }
        }
    }

    j=0;
    for(i=2;i<=n;i++)
    {
        if(prime[i]==0)
        {
            prime_table[j]=i;
            j++;
            printf("%lld : %lld \n",j,i);
        }
    }
}

void main()
{
    create_prime_table(MAX_N);
}

这算是基本的筛法了，但它还有很多优化的空间。首先内存中存的表不只是素数，还有合数的空间，合数比素数多得多。 其次对于合数可能会被筛选多次，比如6，在2的时候筛掉一次。在3的时候又筛掉一次。

版本4

采用线性筛选方式，即对一个合数，只进行一次筛选，极大程度的减少重复计算。 同时，采用堆结构存放素数表。

//create prime less then n
//program 4

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  //Linux, gcc -lm
#include <stdbool.h>


#define Long64 long long
#define MAX_N 1000000000

void create_prime_table2(Long64 n)
{
    Long64 i,j,k;
    bool *prime;
    Long64 *prime_table;

    prime=(bool *)calloc(MAX_N+1,sizeof(bool));
    prime_table=(Long64 *)calloc(MAX_N/100,sizeof(Long64));

    i=2;
    k=0;
    for(i=2;i<=n;i++)
    {
        if(prime[i]==0)
        {
            prime_table[k++]=i;
            //printf("%lld : %lld \n",k,i);
        }
        for(j=0;j<k && prime_table[j]*i <= n;j++)
        {
            prime[prime_table[j]*i]=1;
            if(i%prime_table[j]==0)
                break;
        }
    }
    printf("k = %lld\n",k);

    if(prime_table)
        free(prime_table);
    if(prime)
        free(prime);
}

void main()
{
    create_prime_table2(MAX_N);
}

这样做之后，程序运行速度快多了，但是只能计算到1x10^9....再大时，运行就提示段错误了。还要再在其他地方想办法。。。 暂时先记录到这里。

自然数e

在上上一篇博客中，虽然实现了计算n为自然数e的程序，但是GetLength 函数实现的数学原理一直没有想清楚。其实是这样的。 计算自然数e时，我们使用的时泰勒公式

e^x = 1 + x + x^2/2! +... + x^n/n!...

当考虑到泰勒公式的余项时，余项可以表示为

R(x) = (e^esp * x^(n+1))/(n+1)!

其中esp在0～x之间。再取x=1,得到

R(1) = e^esp/(n+1)! <= e/(n+1)! < 10^(-M)

10^(-M)就是我们要达到的误差限，也就是小数点后的后M位。 因此，若要计算到10000位的精度，只需计算(n+1)!/e > 10^10000即可。 程序中GetLength的实现原理就是这样。

素数判断

在上一篇博客中，只计算到1x10^9内的素数，并没有达到要求，主要时卡在了数据结构上，再大的话在我2G内存32位系统上就已经提示段错误了。现在回过头了想想，其实还可以在算法上再改进。 我们知道a*b = c，一个M位的数乘上另外一个M位的数，得到结果位数范围在M+1~2M的范围内。我们只要求出5位数以内的素数，就可以用来判断10位数的整数是否为素数了。 那么素数判断的程序就可以修改成这样，也就是版本2和版本4的结合。

版本5

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  //Linux, gcc -lm
#include <stdbool.h>

#define Long64 long long
#define MAX_N 100000

//create prime less then n 
//program 5

Long64 create_prime_table3(bool *prime, Long64 *prime_table, Long64 n)
{
    Long64 i,j,k;

    i=2;
    k=0;
    for(i=2;i<=n;i++)
    {
        if(prime[i]==0)
        {
            prime_table[k++]=i;
            //printf("%lld : %lld \n",k,i);
        }
        for(j=0;j<k && prime_table[j]*i <= n;j++)
        {
            prime[prime_table[j]*i]=1;
            if(i%prime_table[j]==0)
                break;
        }
    }

    return k;
}

bool prime3(Long64 prime_table[], Long64 length, Long64 n)
{
    Long64 i;

    for(i=0;i<length;i++)
    {
        if(n%(prime_table[i])==0)
        {
            return false;
        }
    }
    return true;
}

void main()
{   
    bool *prime;
    Long64 *prime_table,i=0,j=0,length=0;

    prime=(bool *)calloc(MAX_N+1,sizeof(bool));
    prime_table=(Long64 *)calloc(MAX_N,sizeof(Long64));

    length = create_prime_table3(prime,prime_table,MAX_N);

    for(i=1000000000; i<10000000000; i++)
        if(prime3(prime_table,length,i)!=false)
            printf("%lld : %lld\n",j++,i);
}

收尾：判断e中首个连续10位素数

有了以上问题解决后，这道题终于可以解决了。不仅可以找到第一个10位长度的素数，还可以找到前10个！前10个结果如下，格式为“第几个：在e中的起始位置：要找的素数”

1:99:7427466391 
2:123:7413596629 
3:149:6059563073 
4:171:3490763233 
5:182:2988075319 
6:201:1573834187 
7:214:7021540891 
8:218:5408914993 
9:254:6480016847 
10:295:9920695517

完整实现代码如下

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  //Linux, gcc -lm
#include <stdbool.h>
#include <assert.h>

#define MAX_E_BITE_N 1000
#define PRIME_N 1000000

#define Long64 long long

typedef unsigned int UINT;


int get_length(int nbite)
{
    int m = 1;
    double x = 2.0/2.72;
    while(nbite)
    {
        while(x<1.0)
        {
            m++;
            x *= (double)(m+1);
        }
        while(x >= 1.0 && nbite)
        {
            x /= 10.0;
            --nbite;
        }
    }
    while(x < 1.0)
    {
        m++;
        x *= (double)(m+1);
    }
    return m;
}


int create_e(Long64 *euler, const UINT base, int m)
{
    UINT *r = NULL;
    UINT y = 0;
    int i = 0,j = 0,k = 0;

    r=(UINT *)calloc(m+1,sizeof(UINT));

    assert(r != NULL);
    assert(euler != NULL);

    for(i = 0;i <= m; ++i)
    {
        r[i] = 1;
        euler[i] = 0;
    }

    j = 1;
    euler[0] = 2;

    for(k = MAX_E_BITE_N; k > 0; k -= 5)
    {
        y = 0;
        for(i = m; i >= 2; --i)
        {
            y = y + r[i]*base;
            r[i] = y%i;
            y /= i;
        }

        if(k < 5)
        {
            euler[j++] = y%base;
        }
        else
        {
            if(y < base)
                euler[j++] = y;
            else
            {
                if(r)
                    free(r);
                return 0;
            }
        }
    }
    if(r)
        free(r);

    printf("\n\nE=%lld.\n",euler[0]);
    for(i = 1; i < j; i++)
    {
        printf("%.5lld ",euler[i]);
    }
    printf("\n\neulur number is ok j=%d\n",j);

    return j;
}

Long64 create_prime_table(bool *prime, Long64 *prime_table, Long64 n)
{
    Long64 i,j,k;

    i = 2;
    k = 0;
    for(i = 2;i <= n;i++)
    {
        if(prime[i] == 0)
        {
            prime_table[k++] = i;
//            printf("%lld : %lld \n",k,i);
        }
        for(j = 0; j < k && (prime_table[j]*i) <= n; j++)
        {
            prime[prime_table[j] * i] = 1;
            if(i%prime_table[j] == 0)
                break;
        }
    }

    return k;
}

bool is_prime(Long64 prime_table[], Long64 length, Long64 n)
{
    Long64 i;

    for(i = 0; i < length; i++)
    {
        if(n%(prime_table[i]) == 0)
        {
            return false;
        }
    }
    return true;
}


void main()
{
    const UINT base = 100000;
    int m = 0,elength = 0,j = 0,find_number = 10;

    Long64 *euler = NULL;
    bool *prime = NULL;
    Long64 *prime_table = NULL;

    Long64 i = 0,length = 0,data = 0;

    Long64 ten[10] = {1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};

    m = get_length(MAX_E_BITE_N);

    euler = (Long64 *)calloc(MAX_E_BITE_N,sizeof(Long64));

    elength = create_e(euler,base,m);


    prime = (bool *)calloc(PRIME_N+1,sizeof(bool));
    prime_table = (Long64 *)calloc(PRIME_N,sizeof(Long64));

    length = create_prime_table(prime,prime_table,PRIME_N);

    if(prime)
        free(prime);

    m = 0;
    for(i = 1; (i+2) < elength; i++)
    {
        for(j = 0; j < 5; j++)
        {
            data = euler[i]%ten[5-j]*ten[5+j] + euler[i+1] * ten[j] + euler[i+2]/ten[5-j];

//          printf("data : %lld \n",data);

            if(is_prime(prime_table,length,data) == true)
            {
                printf("find it! %d:%lld:%lld\n",++m,5*(i-1)+j+1,data);

                if(m == find_number)
                    break;    
            }               
        }

        if(m == find_number)
            break;    
    }


    if(euler)
        free(euler);
    if(prime_table)
        free(prime_table);

    return;
}

习惯2021
关注
专栏目录
2020 android面试题答案
疾风剑豪
05-04 5021
（1）java面试题（基础+进阶）（必须） java中==和equals和hashCode的区别 ==是运算符，用来比较两个值、两个对象的内存地址是否相等； equals是Object类的方法，默认情况下比较两个对象是否是同一个对象，内部实现是通过“==”来实现的。 如果想比较两个对象的其他内容，则可以通过重写equals方法， hashCoed也是Object类里面的方法，返回值是一个对象的哈希...
106@365大型互联网企业面试题整理&…
IT小生
05-12 1910
全新整理：微软、谷歌、百度等公司经典面试 100 题[第 101-170 题] 整理:July、二零一一年三月九日。 应网友承诺与要求，全新整理。转载，请注明出处。 博主说明： 此 100 题 V0.2 版，本人不再保证，还会提供答案。 因为之前整理的微软 100 题，已经基本上，把题目都出尽了。见谅。 --------------------------------------------微软十
EPRIMES:找出 e 的连续数字中的前 n 位素数。-matlab开发
06-01
最近，谷歌公司创建了一些高速公路广告牌，要求路人在 e 的连续数字中找到第一个十位数的素数。 当然，Mathworks 文件交换必须解决这样的挑战！ 不幸的是，谷歌广告牌问题的答案很快在媒体上公布，所以答案很容易找到。 不过，如果您想自己解决问题，请随时忽略这些出版物和本程序。 该程序从第一个一位数素数开始，并继续定位越来越大的素数。 程序在 500 位有一个任意的停止点。 此外，为了节省空间，e 只存储了 10,000 个数字，因此使用此代码可以限制（远大于 500）您想要的素数有多大。 使用 Java 进行可能的素数计算。 （请参阅之前提交的 ISPR.M 函数下的注释。） 明显说明：Google 是 Google, Inc. 的商标。
java 自然常数e中出现的连续的第一个10个数字组成的质数_冷知识：数学常数“e”的传奇故事...
weixin_34483980的博客
03-07 573
原标题：冷知识：数学常数“e”的传奇故事自然对数的底e是一个令人不可思议的常数，一个由 lim (1+1/n)^n 定义出的常数，居然在数学和物理中频频出现，简直可以说是无处不在。这实在是让我们不得不敬畏这神奇的数学世界。 欧拉恒等式但凡说起e，一个必定要提到的公式就是欧拉恒等式——被誉为世界上最美丽的公式。数学中最基本的5个常数——0、1、圆周率π、自然对数的底e和虚数单位i，以及数学中最基本的...
自然常数e的定义
最新发布
duoyasong5907的博客
10-05 883
你会发现，每当缩小领利息的周期，复利后的收益会变多。那假如利息周期无限小，以此类推，一年后的复利会如何呢？实际上，这个数字不会超过e。可以用银行利息的复利来理解这个公式。某银行每年的利息年化是100%，你在里面存了1块钱，且每次领到利息时都会再存回去。
java 自然常数e中出现的连续的第一个10个数字组成的质数,一道google面试题--自然数e中出现的连续的第一个10个数字组成的质数...
weixin_39874795的博客
03-20 429
素数判断版本1素数，即除1以外，只能被1和其本身整除的数。因此根据定义，最初的判断素数的方法为版本1。//judge prime//program 1bool prime_1(int n){int i;for(i=2;i{if(n%i==0){return false;}}return true;}版本2由于一个数的因式分解可表示为x = a * b, a<=b，因此在判断整数n是不是素数时...
java 自然常数e中出现的连续的第一个10个数字组成的质数_（e.com中第一个10位数的质数）.com python google challenge 2004...
weixin_39890332的博客
03-01 414
以下是一种方法：def z(contfrac, a=1, b=0, c=0, d=1):for x in contfrac:while a > 0 and b > 0 and c > 0 and d > 0:t = a // ct2 = b // dif not t == t2:breakyield ta = (10 * (a - c*t))b = (10 * (b - d...
Google面试题 | 数字计数
Epsilon
09-30 721
DescriptionGiven a non-negative integer n, count all numbers with unique digits, x, where 0 ≤ x < 10n.Example: Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 1
全新整理 微软 谷歌 百度等公司经典面试100题 第101 160题
gdfyug的博客
11-08 860
全新整理 微软 谷歌 百度等公司经典面试100题 第101 160题
链表&amp；双指针-以快慢指针查找环形链表中链表环的第一个结点为例
2301_79125431的博客
10-13 118
题解 | #判断质数# Number.prototype._isPrime = function (){ if (this == 2) { return true } if信也科技一面 前端 秋招 面经 基本信息时间：2023.10.13时长：42 minbase：魔都面试岗位：前端 秋招 问题自我介绍为啥要做这个课程第一次听说候选人录了视频，很有意思，我简单沟题解 | #矩阵乘法计算量估算# num = int(in
java 自然常数e中出现的连续的第一个10个数字组成的质数_自然常数-常数e的来历e在很多数学公式中出现的频率比较高今天做导数题时看到 爱问知识人...
weixin_39899244的博客
03-07 535
自然常数简介自然常数e就是lim(1+1/x)^x,x->+∞或lim(1+z)^(1/z),z->0,其值约为2。71828,，是一个无限不循环数。[编辑本段]自然常数来源旋涡形或螺线型是自然事物极为普遍的存在形式，比如：一缕袅袅升上蓝天的炊烟，一朵碧湖中轻轻荡开的涟漪，数只缓缓攀援在篱笆上的蜗牛和无数在恬静的夜空携拥着旋舞的繁星……螺线特别是对数螺线的美学意义可以用指数的形式来表达...
e小数点后一百万位.txt
03-24
自然常数e小数点后一百万位
Google的面试题目（数学部分）
关门大吉！谢谢大家支持！^_^
11-13 1683
- 在‘e’的数列中所能找到的第一个十位数质数-用3种颜色为20面体上色，每个面一种颜色，有多少种组合？你会选择哪3种颜色-什么是世上最美的数学方程式？-试着证明 WWWDOT - GOOGLE = DOTCOM-三角形ABC，用圆规和尺，找出点P，保证三角形ABP、ACP和BCP周长相等。-找出此数列的下一个:10,9,60,90,70,66？A) 96B) 10的100次方C) A
谷歌的招聘题
python之程的博客
08-19 1400
谷歌的招聘题 旧金山湾地区的101号公路是一条繁忙的通勤公路，来往的是Adobe、苹果、应用材料、思科、易趣网、GeNeNeTeaTM、谷歌、休利特、帕卡德、信息技术、直觉、甲骨文、硅图形、太阳微系统、雅虎、A等公司的总部的员工。这些通勤者记得那张谷歌支付的大海报，上面是一道数学题，答出者可以获得谷歌面试的资格。 为此题吸引并向往谷歌者，认真答题，进而进了谷歌，彼此心照不宣，可以称为自然对数届...
e的前2000位
m0_37101905的博客
05-01 1512
e=2. 71828 18284 59045 23536 02874 71352 66249 77572 47093 69995 95749 66967 62772 40766 30353 54759 45713 82178 52516 64274 27466 39193 20030 59921 81741 35966 29043 57290 03342 95260 59563 0738
常数e的后10000位小数
aaapengbo的博客
04-11 2765
2.718281828459045235360287471352662497757247093699959574966967627724076630353 547594571382178525166427427466391932003059921817413596629043572900334295260 595630738132328627943490763233829880753195251019011573834187930702154089149 9348841675092447.
e值的计算
say_book的博客
02-20 4077
e值该如何计算呢？ 若关于ex幂级数展开 ex=1+x+x2/2!+x3/3!+•••+xn/n! 取x=1，有e=1+1/2+1/6+••• 接下来就是十分简单的编程 这里选用了python语言（当然也可以选用其他编程语言）进行计算 import time e=1 #e bn=1 since = time.time() for i in range(100000): bn=bn*(i+1) #n! e=e+1/bn spend = time.time()-since print(e) p
阿尔卡特笔试题目之三
我的仓库 My Storehouse
05-22 1281
　　1．自己定义数据结构，写出程序：在一个单向链表中，往I位置插入一个节点。 Typedef  struct  node...{        datatype  data;        struct   node  *next;}listnode;typedef struct slist ...{        int count;        listnode* m_pNodeHe
【PAT甲级】Google Recruitment
麦芽雪冷萃
04-22 305
Problem Description： In July 2004, Google posted on a giant billboard along Highway 101 in Silicon Valley (shown in the picture below) for recruitment. The content is super-simple, a URL consisting o...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值