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;

}