c语言输入n求0,c语言n=0

本文目录一览：

• 1、用c语言任意输入n个数求出其中0的个数
• 2、C语言输入一个自然数n，求n！ ，同时统计结果中有多少个0？
• 3、用C语言输入一个自然数n,求n!,同时统计结果中有多少个0
• 4、用c语言设计程序:输入一个自然数n，求n！同时统计计算结果有多少个0

用c语言任意输入n个数求出其中0的个数

数字也是字符，所以定义字符串数组char a[1000],再用循环依此判断输入的字符是否为’0’。

C语言输入一个自然数n，求n！ ，同时统计结果中有多少个0？

不用开新问题了，我已经把原回答修改了，改成你要的字符串运算。

但即使这样，n也不要太大，看我测试数据就知道了。

代码原理：n!就是循环累计乘法，多位数字符串与多位数字符串相乘和人算法一样，就是其中一个字符串每一位数字和另一个字符串数字相乘，同时所有乘积移位累加。

注意：我写的所有字符串运算函数，没有写字符串验证，如果你想单独把函数拿出来用，记得写个输入验证，不要把非数字的字符串传进去。

#include stdio.h

#include string.h

#include malloc.h

#include conio.h

void meError(void *p);//内存申请失败

char *addByStr(char *str1,char *str2);

char *inversion(char *str);//倒置字符串

char *multByStr1(char *str1,char c2);//多位数字符串与单位数字符串相乘

char *multByStr2(char *str1,char *str2);//多位数字符串相乘

char *p10ByStr(char *str,int n);//字符串数字乘n个10

char *num2Str(int n);//数字转字符串

int main()

{

    int n,i,len,cnt=0;

    char *nStr=NULL;

    while(1)

    {

        nStr=(char *)malloc(sizeof(char)*2);

        meError(nStr);

        nStr[0]=’1′,nStr[1]=0;

        printf(“输入一个自然数n,求n！\n”);

        scanf(“%d”,n);

        for(i=1;i=n;i++)

            nStr=multByStr2(nStr,num2Str(i));

        printf(“计算结果：%s\n”,nStr);

        len=strlen(nStr);

        for(i=len-1;i=0;i–)

            if(nStr[i]==’0′)

                cnt++;

        printf(“结果包含%d个0\n\n”,cnt);

        free(nStr);

        nStr=NULL;

    }

    return 0;

}

char *num2Str(int n)//数字转字符串

{

    int i=0,len=1;

    char *str=NULL,*strSave=NULL;

    while(n)

    {

        if(str==NULL)

        {

            str=(char *)malloc(sizeof(char)*2);

            meError(str);

        }

        else

        {

            strSave=(char *)realloc(str,sizeof(char)*(len+1));

            meError(strSave);

            str=strSave;

            strSave=NULL;

        }

        str[i]=n%10+’0′;

        str[i+1]=0;

        i++;

        len++;

        n=n/10;

    }

    inversion(str);

    return str;

}

char *p10ByStr(char *str,int n)//字符串数字乘n个10,注意：str必须是动态申请内存！！

{

    int len=strlen(str),i;

    char *p=NULL,*strSave=NULL;

    if(n0)

    {

        strSave=realloc(str,sizeof(char)*(len+1+n));

        meError(strSave);

        str=strSave;

        p=str[len];

        for(i=0;in;i++)

            *p=’0′,p++;

        *p=0;

    }

    return str;

}

char *multByStr2(char *str1,char *str2)//多位数字符串相乘

{

    int len2=strlen(str2),i,j=0;

    char **addStrs=(char **)malloc(sizeof(char *)*len2),*sum0=NULL,*sum1=NULL,*sum=NULL,c2;

    meError(addStrs);

    for(i=len2-1;i=0;i–)

    {

        c2=str2[i];

        addStrs[j++]=multByStr1(str1,c2);//这里addStrs存储的是str1和str2每一位的乘积

    }

    //——–sum0和sum1交替，为了及时释放内存——-

    sum0=(char *)malloc(sizeof(char)*2);

    meError(sum0);

    sum0[0]=’0′,sum0[1]=0;;

    for(i=0;ilen2;i++)

    {

        addStrs[i]=p10ByStr(addStrs[i],i);//在乘法运算中，最后累加要乘10

        if(sum1==NULL)

        {

            sum1=addByStr(sum0,addStrs[i]);

            free(sum0);

            sum0=NULL;

        }

        else

        {

            sum0=addByStr(sum1,addStrs[i]);

            free(sum1);

            sum1=NULL;

        }

        free(addStrs[i]);

        addStrs[i]=NULL;

    }

    if(sum0)

        sum=sum0;

    else

        sum=sum1;

    free(addStrs);

    addStrs=NULL;

    return sum;

}

char *multByStr1(char *str1,char c2)//多位数字符串与单位数字符串相乘

{

    int len1=strlen(str1),i=len1-1,a,b,c=0;

    char *mulStr=(char *)malloc(sizeof(char)*(len1+2)),*p=mulStr;

    meError(mulStr);

    memset(mulStr,0,sizeof(char)*(len1+2));

    b=c2-‘0’;

    while(1)

    {

        a=str1[i]-‘0’;

        *p=((a*b)+c)%10+’0′;

        c=((a*b)+c)/10;

        p++;

        if(i==0)

        {

            if(c0)

                *p=c+’0′;

            break;

        }

        i–;

    }

    inversion(mulStr);

    return mulStr;

}

char *addByStr(char *str1,char *str2)

{

    int len1=strlen(str1),len2=strlen(str2),maxSize,i=len1-1,j=len2-1,a,b,c=0;

    char *addStr=NULL,*p=NULL;

    if(len1len2)//多留两位，一位给结束符号，一位给进位

        maxSize=len1+2;

    else

        maxSize=len2+2;

    addStr=(char *)malloc(sizeof(char)*maxSize);

    meError(addStr);

    memset(addStr,0,sizeof(char)*maxSize);

    p=addStr;

    while(1)

    {

        if(i0)

            a=0;

        else

            a=str1[i]-‘0’;

        if(j0)

            b=0;

        else

            b=str2[j]-‘0’;

        *p=(a+b+c)%10+’0′;//从后往前，每一位做加运算并保存余数和进位（数组中结果是反向存储的，最后再将数组倒置）

        c=(a+b+c)/10;

        p++;

        if(i=0  j=0)

        {

            if(c0)

                *p=c+’0′;

            break;

        }

        i–;

        j–;

    }

    //————–数组倒置——————

    inversion(addStr);

    return addStr;

}

char *inversion(char *str)//倒置字符串

{

    char *p=str,*pd=str[strlen(str)-1],cs;

    while(ppd)

    {

        cs=*p;

        *p=*pd;

        *pd=cs;

        p++;

        pd–;

    }

    return str;

}

void meError(void *p)//内存申请失败

{

    if(p==NULL)

    {

        printf(“\n异常：内存申请失败！回车结束程序！\n”);

        while(getch()!=’\r’);

        exit(0);

    }

}

用C语言输入一个自然数n,求n!,同时统计结果中有多少个0

不用开新问题了，我已经把原回答修改了，改成你要的字符串运算。

但即使这样，n也不要太大，看我测试数据就知道了。

代码原理：n!就是循环累计乘法，多位数字符串与多位数字符串相乘和人算法一样，就是其中一个字符串每一位数字和另一个字符串数字相乘，同时所有乘积移位累加。

注意：我写的所有字符串运算函数，没有写字符串验证，如果你想单独把函数拿出来用，记得写个输入验证，不要把非数字的字符串传进去。

#include stdio.h

#include string.h

#include malloc.h

#include conio.h

void meError(void *p);//内存申请失败

char *addByStr(char *str1,char *str2);

char *inversion(char *str);//倒置字符串

char *multByStr1(char *str1,char c2);//多位数字符串与单位数字符串相乘

char *multByStr2(char *str1,char *str2);//多位数字符串相乘

char *p10ByStr(char *str,int n);//字符串数字乘n个10

char *num2Str(int n);//数字转字符串

int main()

{

    int n,i,len,cnt=0;

    char *nStr=NULL;

    while(1)

    {

        nStr=(char *)malloc(sizeof(char)*2);

        meError(nStr);

        nStr[0]=’1′,nStr[1]=0;

        printf(“输入一个自然数n,求n！\n”);

        scanf(“%d”,n);

        for(i=1;i=n;i++)

            nStr=multByStr2(nStr,num2Str(i));

        printf(“计算结果：%s\n”,nStr);

        len=strlen(nStr);

        for(i=len-1;i=0;i–)

            if(nStr[i]==’0′)

                cnt++;

        printf(“结果包含%d个0\n\n”,cnt);

        free(nStr);

        nStr=NULL;

    }

    return 0;

}

char *num2Str(int n)//数字转字符串

{

    int i=0,len=1;

    char *str=NULL,*strSave=NULL;

    while(n)

    {

        if(str==NULL)

        {

            str=(char *)malloc(sizeof(char)*2);

            meError(str);

        }

        else

        {

            strSave=(char *)realloc(str,sizeof(char)*(len+1));

            meError(strSave);

            str=strSave;

            strSave=NULL;

        }

        str[i]=n%10+’0′;

        str[i+1]=0;

        i++;

        len++;

        n=n/10;

    }

    inversion(str);

    return str;

}

char *p10ByStr(char *str,int n)//字符串数字乘n个10,注意：str必须是动态申请内存！！

{

    int len=strlen(str),i;

    char *p=NULL,*strSave=NULL;

    if(n0)

    {

        strSave=realloc(str,sizeof(char)*(len+1+n));

        meError(strSave);

        str=strSave;

        p=str[len];

        for(i=0;in;i++)

            *p=’0′,p++;

        *p=0;

    }

    return str;

}

char *multByStr2(char *str1,char *str2)//多位数字符串相乘

{

    int len2=strlen(str2),i,j=0;

    char **addStrs=(char **)malloc(sizeof(char *)*len2),*sum0=NULL,*sum1=NULL,*sum=NULL,c2;

    meError(addStrs);

    for(i=len2-1;i=0;i–)

    {

        c2=str2[i];

        addStrs[j++]=multByStr1(str1,c2);//这里addStrs存储的是str1和str2每一位的乘积

    }

    //——–sum0和sum1交替，为了及时释放内存——-

    sum0=(char *)malloc(sizeof(char)*2);

    meError(sum0);

    sum0[0]=’0′,sum0[1]=0;;

    for(i=0;ilen2;i++)

    {

        addStrs[i]=p10ByStr(addStrs[i],i);//在乘法运算中，最后累加要乘10

        if(sum1==NULL)

        {

            sum1=addByStr(sum0,addStrs[i]);

            free(sum0);

            sum0=NULL;

        }

        else

        {

            sum0=addByStr(sum1,addStrs[i]);

            free(sum1);

            sum1=NULL;

        }

        free(addStrs[i]);

        addStrs[i]=NULL;

    }

    if(sum0)

        sum=sum0;

    else

        sum=sum1;

    free(addStrs);

    addStrs=NULL;

    return sum;

}

char *multByStr1(char *str1,char c2)//多位数字符串与单位数字符串相乘

{

    int len1=strlen(str1),i=len1-1,a,b,c=0;

    char *mulStr=(char *)malloc(sizeof(char)*(len1+2)),*p=mulStr;

    meError(mulStr);

    memset(mulStr,0,sizeof(char)*(len1+2));

    b=c2-‘0’;

    while(1)

    {

        a=str1[i]-‘0’;

        *p=((a*b)+c)%10+’0′;

        c=((a*b)+c)/10;

        p++;

        if(i==0)

        {

            if(c0)

                *p=c+’0′;

            break;

        }

        i–;

    }

    inversion(mulStr);

    return mulStr;

}

char *addByStr(char *str1,char *str2)

{

    int len1=strlen(str1),len2=strlen(str2),maxSize,i=len1-1,j=len2-1,a,b,c=0;

    char *addStr=NULL,*p=NULL;

    if(len1len2)//多留两位，一位给结束符号，一位给进位

        maxSize=len1+2;

    else

        maxSize=len2+2;

    addStr=(char *)malloc(sizeof(char)*maxSize);

    meError(addStr);

    memset(addStr,0,sizeof(char)*maxSize);

    p=addStr;

    while(1)

    {

        if(i0)

            a=0;

        else

            a=str1[i]-‘0’;

        if(j0)

            b=0;

        else

            b=str2[j]-‘0’;

        *p=(a+b+c)%10+’0′;//从后往前，每一位做加运算并保存余数和进位（数组中结果是反向存储的，最后再将数组倒置）

        c=(a+b+c)/10;

        p++;

        if(i=0  j=0)

        {

            if(c0)

                *p=c+’0′;

            break;

        }

        i–;

        j–;

    }

    //————–数组倒置——————

    inversion(addStr);

    return addStr;

}

char *inversion(char *str)//倒置字符串

{

    char *p=str,*pd=str[strlen(str)-1],cs;

    while(ppd)

    {

        cs=*p;

        *p=*pd;

        *pd=cs;

        p++;

        pd–;

    }

    return str;

}

void meError(void *p)//内存申请失败

{

    if(p==NULL)

    {

        printf(“\n异常：内存申请失败！回车结束程序！\n”);

        while(getch()!=’\r’);

        exit(0);

    }

}

用c语言设计程序:输入一个自然数n，求n！同时统计计算结果有多少个0

#include stdio.h

int main()

{ int n,s=0;

  scanf(“%d”,n);

  printf(“%d!的末尾有”,n);

  for(; n; n/=5)s+=n/5;

  printf(“%d个0\n”,s);

  return 0;

}