一笔试题 求100！

[叁叁玖玖]

求100！ 希望各位能给点代码。。。

[AnYidan]

[Quote=引用 12 楼 twhtwhtwhtwh 的回复:]
如果 不用数组 存放位数 用C能实现否 ？
[/Quote]

好象用数组是一种标准的算法，此外还真不知道有何更好的，等高人！

[hy890512]

循环 加 数组 就可以解决了

[hndcwynui]

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

int bigN[10000];
int len;

void fact(int n)
{
	int i, j, k, t;
	memset(bigN, 0, sizeof(bigN));
	bigN[0] = 1;
	len = 1;
	for (i = 2; i <= n; i++) {
		for (j = 0; j < len; j++)
			bigN[j] = bigN[j] * i;
		k = 0;
		for (j = 0; j < len; j++) {
			t = k + bigN[j];
			bigN[j] = t % 10;
			k = t / 10;
		}
		while (k > 0) {
			t = k + bigN[len];
			bigN[len] = t % 10;
			k = t / 10;
			len++;
		}
	}
}

int main()
{
	fact(100);
	for (int i = len-1; i >= 0; i--)
		printf("%d", bigN[i]);
	printf("\n");
	return 0;
}

[shijiemoxing]

学习哦

[pathuang68]

参考下面这个：

#include <iostream>
#include <string>

using namespace std;
 int COMPARE(string number1, string number2)
{
    int j;
 
    int length1 = number1.size();
    int length2 = number2.size();
 
    if(number1.size() == 0) number1 = "0";
    if(number2.size() == 0) number2 = "0";
 
    j = 0;
    for(int i = 0; i < length1; ++i)
    {
        if(number1[i] == '0') ++j;
        else break;
    }
    number1 = number1.substr(j);
 
    j = 0;
    for(int i = 0; i < length2; ++i)
    {
        if(number2[i] == '0') ++j;
        else break;
    }
    number2 = number2.substr(j);
 
    length1 = number1.size();
    length2 = number2.size();
 
    if(length1 > length2)
    {
        return 1;
    }
    else if(length1 == length2)
    {
        if(number1.compare(number2) > 0)
        {
            return 1;
        }
        else if(number1.compare(number2) == 0)
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }
    else
    {
        return -1;
    }
 
    return 0;
}


string PLUS(string number1,string number2)
{
    int i;
    int length1 = number1.size();
    int length2 = number2.size();
 
    string result="";
 
    reverse(number1.begin(), number1.end());
    reverse(number2.begin(), number2.end());
 
    for(i = 0; i < length1 && i < length2; i++)
    {
        char c = (char)(number1[i] + number2[i] - 48);
        result = result + c;
    }
 
    while(i < length1)
    {
        result = result + number1[i];
        ++i;
    }
 
    while(i < length2)
    {
        result = result + number2[i];
        ++i;
    }
  
    int carry = 0;
    for(i = 0; i < (int)result.size(); ++i)
    {
        int value = result[i] - 48 + carry;
        result[i] = (char)(value % 10 + 48);
        carry = value / 10;
    }
  
    if(carry !=0 )
    {
        result = result + (char)(carry + 48);
    }
 
    for(i = result.size() - 1; i >= 0; i--)
    {
        if(result[i] != '0') break;
    }
 
    result = result.substr(0, i + 1);
 
    reverse(result.begin(), result.end());
    if(result.length() == 0) result = "0";
    return result;
}
 
 
string MINUS(string number1,string number2)
{
    int i;
    string result = "";
 
    int length1 = number1.size();
    int length2 = number2.size();
 
    if(COMPARE(number2,number1) > 0)
    {
        return "-" + MINUS(number2, number1);
    }
 
    reverse(number1.begin(),number1.end());
    reverse(number2.begin(),number2.end());
   
    for(i = 0; i < length1 && i < length2; i++)
    {
        char c = number1[i] - number2[i] + 48;
        result = result + c;
    }

    if(i < length1)
    {
        for(; i < length1; i++)
        {
                    result = result + number1[i];
        }
    }
  
    int carry = 0;
    for(i = 0; i < (int)result.length(); i++)
    {
            int value = result[i] - 48 + carry;
            if(value < 0)
            {
                        value = value + 10;
                        carry = -1;
            }
            else carry = 0;
            result[i]=(char)(value + 48);
    }
 
    for(i = result.size() - 1; i >= 0; i--)
    {
            if(result[i] != '0')break;
    }
 
    result = result.substr(0, i+1);
 
    reverse(result.begin(), result.end());
    if(result.length()==0) result = "0";
    return result;
}
 
 
string MULTIPLY(string number1, string number2)
{
    int i, j;
    int *iresult;
    int length1 = number1.size();
    int length2 = number2.size();
    string result = "";
 
    reverse(number1.begin(), number1.end());
    reverse(number2.begin(), number2.end());
 
    iresult = (int*)malloc(sizeof(int) * (length1 + length2 + 1));
    memset(iresult, 0, sizeof(int) * (length1 + length2 + 1));
 
    for(i = 0; i < length1; i++)
    {
        for(j = 0; j < length2; j++)
        {
            iresult[i+j] += ((number1[i] - 48) * (number2[j] - 48));
        }
    }
 
    int carry = 0;
    for(i = 0; i < length1 + length2; i++)
    {
        int value = iresult[i] + carry;
        iresult[i] = value % 10;
        carry = value / 10;
    }
  
    for(i = length1 + length2 - 1; i >= 0; i--)
    {
        if(iresult[i] != 0)break;
    }
 
    for(; i >= 0; i--)
    {
        result = result + (char)(iresult[i]+48);
    }
 
    free(iresult);

    if(result == "") result = "0";
    return result;
}

string factorial(string n)
{
    string temp = "1";
    string i;
    for(i = "1"; COMPARE(i, n) <= 0; i = PLUS(i, "1"))
    {
        temp = MULTIPLY(temp, i);
    }
    return temp;
}

int main(void)
{
    cout << factorial("100") << endl;

    return 0;
}

你用这个程序求100000的阶乘也木有问题:)

[wuyuwww]

不错 标记一下 看完书在回来做

[玩笑]

实际上，动态分配内存不会降低多少效率，你自己试一下就行了，而且，代码很容易修改，功能都被独立出来了，进位由相应的函数来实现，不用去担心它的问题，你可以修改一个节点存储的位数来少申请空间，这样，理论上，速度应该不会比数组低

[Quote=引用 26 楼 twhtwhtwhtwh 的回复:]
引用 25 楼 zouyuncheng 的回复:
引用 20 楼 twhtwhtwhtwh 的回复:
谢谢 前面各位分享的代码 和思路。
小弟在想 用数组来实现 阶乘的话 多有不便！ 是否 可以自己定义一个类型， 让他装的下100的阶乘、甚至是100000000的阶乘。

我的代码，理论上，只要内存够，多大数的阶乘都没问题（内存是动态申请的）

嗯 你的代码我也分析了 只是觉得 ……
[/Quote]

[awsqsh]

用数组存储位数。。。。

[AndyZhang]

大数乘法

[叁叁玖玖]

[Quote=引用 29 楼 zouyuncheng 的回复:]
实际上，动态分配内存不会降低多少效率，你自己试一下就行了，而且，代码很容易修改，功能都被独立出来了，进位由相应的函数来实现，不用去担心它的问题，你可以修改一个节点存储的位数来少申请空间，这样，理论上，速度应该不会比数组低


引用 26 楼 twhtwhtwhtwh 的回复:
引用 25 楼 zouyuncheng 的回复:
引用 20 楼 twhtwhtwhtwh 的回复:
谢谢 前……
[/Quote]
哈哈 谢谢 我试过了 很好哈！本来这帖子 改早结了 只是看到很多算法都是 用数组来存放位数的 所以才一直在问 ， 谢谢你的思路！

[叁叁玖玖]

谢谢 前面各位分享的代码 和思路。
小弟在想 用数组来实现 阶乘的话 多有不便！ 是否 可以自己定义一个类型， 让他装的下100的阶乘、甚至是100000000的阶乘。

[LouisScola]

学习，MARK

[zhangbin101004]

mark 跟踪学习的来了。。呵呵，楼主加油1

[zecard_fu]

学习了 回复内容太短了！

[赵4老师]

用python语言

[玩笑]

[Quote=引用 20 楼 twhtwhtwhtwh 的回复:]
谢谢 前面各位分享的代码 和思路。
小弟在想 用数组来实现 阶乘的话 多有不便！ 是否 可以自己定义一个类型， 让他装的下100的阶乘、甚至是100000000的阶乘。
[/Quote]
我的代码，理论上，只要内存够，多大数的阶乘都没问题（内存是动态申请的）

[叁叁玖玖]

[Quote=引用 25 楼 zouyuncheng 的回复:]
引用 20 楼 twhtwhtwhtwh 的回复:
谢谢 前面各位分享的代码 和思路。
小弟在想 用数组来实现 阶乘的话 多有不便！ 是否 可以自己定义一个类型， 让他装的下100的阶乘、甚至是100000000的阶乘。

我的代码，理论上，只要内存够，多大数的阶乘都没问题（内存是动态申请的）
[/Quote]
嗯 你的代码我也分析了 只是觉得 数太大了之后 动态分配内存的效率不是很好。谢谢你的思路 其实我只是在考虑另一个方面的问题，就是自定义一个 类型（就像int一样），只是他能够表达出 大数的阶乘，这样就可以 不在用去 考虑 进位的问题了。。。。 哈哈 只是想法哈 谢谢你的算法，学习了！

[hbl19871121]

用递归,没调试过，大概就是这样，
#include <stdio.h>
int jiecheng(int num)
{
if ( num == 0 || num == 1 )
return num;
else
return jiecheng(num)*jiecheng(num-1);
}
int main()
{
jiecheng(100);
return 0;
}

[hjhee]

C++里面可以重载bign的运算符，乘除运算很清晰。但C就不清楚了。
还有以万进制存放阶乘数可以放更大的阶乘。

#include <stdio.h>
#define BIT 4
#define LEN 10000
#define LIMIT 10000

int number[LEN]={0},n;

void multiply(int z[], int m){
int i,k=0;
for(i=0;i<LEN;++i){
k=z[i]*m+k;
z[i]=k%LIMIT;
k/=LIMIT;
}
}

int main(void){
number[0]=1;
int i;
scanf("%d", &n);
for(i=1;i<=n;++i)
multiply(number, i);
for(i=LEN-1;!number[i]&&i>-1;--i);
printf("%d", number[i--]);
for(;i>-1;--i)
printf("%0*d", BIT, number[i]);
printf("\n");
return 0;
}

[玩笑]

[Quote=引用 12 楼 twhtwhtwhtwh 的回复:]

如果 不用数组 存放位数 用C能实现否 ？
[/Quote]
用链表啊,呵呵,我看到大数阶乘时的第一反应是用链表,而不是数组,数组有大小限制,,,即使用变长数组,也不好预料结果的位数,比较蛋疼,所以我第一反应是用链表,不过我是习惯性的使用了递归,可能效率上不太理想,呵呵,在我的机器上,计算10000的阶乘用了半分钟(我的CPU可不差了,超到3.1G的FX5000)
再贴一次代码吧

#include <stdio.h>
#include <stdlib.h>
 
typedef struct node {
    int n;
    struct node * next;
} NODE;
 
NODE * jc(int);
void print(NODE *);
 
int main()
{
    for(int n = 10000; n < 10001; n++){
        print(jc(n));
        printf("\n");
    }
    return 0;
}
 
void print(NODE * head) {
    if(head) {
        print(head->next);
        printf("%1d", head->n);
        free(head);
    }
}
 
NODE * newnode(int n) {
    NODE * head;
    head = (NODE *)malloc(sizeof(NODE));
    head->n = n;
    head->next = NULL;
    return head;
}
 
void jw(NODE * head, long n) {
    if(n>0) {
        int x = head->n + n%10;
        head->n = x%10;
        if((x>=10 || n>=10) && head->next == NULL) head->next = newnode(0);
        jw(head->next, x/10);
        jw(head->next, n/10);
    }
}
 
NODE * lj(NODE * head, int n) {
    if(head) {
        lj(head->next, n);
        long x = head->n * n;
        head->n = 0;
        jw(head, x);
    }
    return head;
}
 
NODE * jc(int n) {
    return n==1 ? newnode(1) : lj(jc(n-1), n);
}