可用分押宝游戏火热进行中...	专题改版：Java Web 专题

一道面试题（求大家今天给我答案，要不我就死了）

楼主eagle002（坐不住板凳）2005-08-18 10:55:38 在 C/C++ / C++ 语言提问

用C++编程实现大数相乘的功能。编译工具不限，请在答卷中说明即可。答卷包括源代码和可执行文件。

A,B分别为500位以内的一个大数，请求出A*B的结果。

下面的内容可以用来验证你的功能

A= 2183924444444444448888888888888888888888500000000000000438888888888888333333333333333333333333333333333111111111111111111000000000004444444444444444475888888888888888888888888888888888888888888883499999999999999999999999999999999999999999992000000000000000000000

B= 38888888888899999999999999999999999999889999999999999999999999999999100000000000000000000000000036666666666666661711111111111111111111111111111111111111111111111111348999999999999999999999999998888888888899999999999999999999999999888888

A*B= 084930395061752661061728395061777777777522422632098761127690123456793012863061771166662666666618468966109876954310325589229851913558393813401259061729635920987666893089578354567901238378268246046746553283882310883951686248900617446672363367064666164327067654325713840070635796642855308566777190063032654321512917291554358024685185185209632790088518518570858122174339502222222222218728367117098765432038886985777777777777777778376548008888888888800000000000000000000000000888896000000000000000000000

***********************************************************************************

A= 218392444444444444044444444444444444758888888888888888888888888888888888888888888834999999999999999999999999999999999999999999920000008888888888888888888888500000000000000438888888888888333333333333333333333333333333333111111111111111111000000000004444444444444444475888888888888888888888888888888888888888888883499999999999999999999999999999999999999999992000000000000000000000

B= 3888888888889111111111111111111111111111111111111134899999999999999999999999999888888888889999999999999999999999999988889999999999999999999999999889999999999999999999999999999100000000000000000000000000036666666666666661711111111111111111111111111111111111111111111111111348999999999999999999999999998888888888899999999999999999999999999888888

A*B= 849303950617332480716049382715960495050000000000075071856804938271595422716049358240661801514251279012345678567901197203289571890122213845216790101408926381553092451407322634369444889174728395421728870318501187493790032617231707162296327851777431594889514539637277961784902110117269133818928788889019453983152957149517479011147523897533290301876458567845648319801409015506155920707870899113855038252567844183512690493833136047957481657679192421780617446915023580255777346144427654325713840070635796642855308566777190063032654321512917291554358024685185185209632790088518518570858122174339502222222222218728367117098765432038886985777777777777777778376548008888888888800000000000000000000000000888896000000000000000000000

[题目完]
问题点数：100、回复次数：77Top

1 楼VivianSnow（Phoenix）回复于 2005-08-18 11:14:46 得分 1

呵呵```Easy，高精度问题啊Top

2 楼VivianSnow（Phoenix）回复于 2005-08-18 11:15:54 得分 5

而且你第一个A*B输出，怎么有前导0?Top

3 楼VivianSnow（Phoenix）回复于 2005-08-18 11:16:25 得分 6

哈哈``我就编，分都给我啊`` ^_^` ` `Top

4 楼eagle002（坐不住板凳）回复于 2005-08-18 11:19:33 得分 0

呵呵，这个程序对我非常重要，谁编出来就给谁了。
谢谢大家！Top

5 楼eagle002（坐不住板凳）回复于 2005-08-18 11:20:06 得分 0

VivianSnow(Phoenix) ：
你编出来就都给你Top

6 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:22:54 得分 6

早就做过了！
现在就贴出来，不过效率不够高，我正在写一个更高效率的。

//--------------------------------------------------------------
//HugeInt.h
// HugeInt.h: interface for the HugeInt class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_HUGEINT_H__6712791B_7149_4548_B2B3_84AB8728D5D5__INCLUDED_)
#define AFX_HUGEINT_H__6712791B_7149_4548_B2B3_84AB8728D5D5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define Max_size 31
//这里把31改成1001就OK了
//因为你要的是500位的相乘，为了使结果不溢出，就要用到1000位了，
//再加上一个符号位，一共1001
#define sign_flag integer[Max_size-1]
class HugeInt
{
protected:
short int integer[Max_size];
public:
void SetValueN(int n,int val);
int Length();
HugeInt();
HugeInt(long);
HugeInt(const HugeInt&);
HugeInt(char *);
~HugeInt(){};
void HugeToString(char *);
const HugeInt&operator=(const HugeInt &);
HugeInt operator-();
int IsZero();
int operator==(const HugeInt &);
int operator>(const HugeInt &);
HugeInt operator+(HugeInt &);
HugeInt operator-(HugeInt &);
HugeInt operator*(HugeInt &);
HugeInt operator/(HugeInt &);
friend int operator<(HugeInt &,HugeInt &);
};

#endif // !defined(AFX_HUGEINT_H__6712791B_7149_4548_B2B3_84AB8728D5D5__INCLUDED_)

//----------------------------------------------------------
//HugeInt.cpp
// HugeInt.cpp: implementation of the HugeInt class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Calculator.h"
#include "HugeInt.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

HugeInt::HugeInt()
{
int i;
for(i=0;i<Max_size;i++)
integer[i]=0;
}

HugeInt::HugeInt(long val)
{
int i=0;
if(val<0){
sign_flag=1;
val=-val;
}
else
sign_flag=0;
while(val!=0){
integer[i]=val%10;
val/=10;
i++;
}
for(i;i<Max_size-1;i++)
integer[i]=0;
}

HugeInt::HugeInt(const HugeInt &h)
{
int i;
for(i=0;i<Max_size;i++)
integer[i]=h.integer[i];
}

HugeInt::HugeInt(char *string)
{
int i,j=0,len,symbol=0;
for(i=0;i<Max_size-1;i++)
integer[i]=0;
if(string[0]=='+'||string[0]=='-')
symbol=1;
len=strlen(string)-symbol;
i=(Max_size-1)>len?len:(Max_size-1);
for(j=j+symbol;j<i+symbol;j++)
if(!isdigit(string[j]))
return;
j=len-i+symbol;
i--;
len=i;
for(i;i>=0;i--,j++)
integer[i]=string[j]-'0';
if(string[0]=='-')
sign_flag=1;
else
sign_flag=0;
}

const HugeInt&HugeInt::operator=(const HugeInt &h)
{
int i;
sign_flag=h.sign_flag;
for(i=0;i<Max_size-1;i++)
integer[i]=h.integer[i];
return *this;
}

HugeInt HugeInt::operator+(HugeInt &h2)
{
HugeInt temp;
int i,carry=0;
if(sign_flag==0&&h2.sign_flag==0){
for(i=0;i<Max_size-1;i++){
temp.integer[i]=integer[i]+h2.integer[i]+carry;
if(temp.integer[i]>9){
temp.integer[i]=temp.integer[i]%10;
carry=1;
}
else
carry=0;
}
if(temp=="0")
temp.sign_flag=0;
else
temp.sign_flag=(sign_flag+h2.sign_flag+carry)%2;
}
else if(sign_flag==1&&h2.sign_flag==1)
temp=-((-*this)+(-h2));
else if(sign_flag==1&&h2.sign_flag==0)
temp=h2-(-*this);
else
temp=*this-(-h2);
return temp;
}

HugeInt HugeInt::operator-()
{
HugeInt temp(*this);
temp.sign_flag=(temp.sign_flag+1)%2;
if(temp=="0")
temp.sign_flag=0;
return temp;
}

HugeInt HugeInt::operator-(HugeInt &h2)
{
HugeInt temp;
int carry=0,i;
if(sign_flag==0&&h2.sign_flag==1) //(+)-(-)
temp=*this+(-h2);
else if(sign_flag==1&&h2.sign_flag==0) //(-)-(+)
temp=-(-*this+h2);
else if(sign_flag==1&&h2.sign_flag==1)
temp=-((-h2)-(-*this));
else{
if(*this<h2)
temp=-(h2-*this);
else{
for(i=0;i<Max_size-1;i++){
temp.integer[i]=integer[i]-h2.integer[i]-carry;
if(temp.integer[i]<0){
carry=0;
while(temp.integer[i]<0){
carry++;
temp.integer[i]+=10;
}
}
else
carry=0;
}
if(temp=="0")
temp.sign_flag=0;
else
temp.sign_flag=(sign_flag+carry)%2;
}
}
return temp;
}

HugeInt HugeInt::operator*(HugeInt &h2)
{
HugeInt temp;
int i,j,carry=0;
if(*this=="0"||h2=="0")
return (temp="0");
for(i=0;i<Max_size-1;i++)
for(j=0;j<Max_size-1;j++)
if(i+j<Max_size)
temp.integer[i+j]+=integer[i]*h2.integer[j];
for(i=0;i<Max_size-1;i++){
temp.integer[i]+=carry;
if(temp.integer[i]>9){
carry=temp.integer[i]/10;
temp.integer[i]%=10;
}
else
carry=0;
}
temp.sign_flag=(sign_flag+h2.sign_flag)%2;
return temp;
}

HugeInt HugeInt::operator/(HugeInt &h2)
{
HugeInt result,tobedived,diver,temp;
int i,bediver_length,diver_length,result_pos,resbit=9;
if(h2.IsZero())
return temp;
if(*this<HugeInt("0"))
tobedived=-*this;
else
tobedived=*this;
if(h2<HugeInt("0"))
diver=-h2;
else
diver=h2;
if(tobedived<diver)
return HugeInt("0");
diver_length=diver.Length();
bediver_length=tobedived.Length();
result_pos=bediver_length-diver_length;
for(i=0;i<diver_length;i++)
temp.integer[i]=tobedived.integer[result_pos+i];
if(temp<diver)
result_pos--;
temp=tobedived;
while(diver<tobedived||diver==tobedived){
resbit=9;
do{
result.SetValueN(result_pos,resbit);
resbit--;
if(resbit<0){
result_pos--;
resbit=9;
result.SetValueN(result_pos,resbit);
}
// temp=result*diver;
}while(result*diver>temp);
tobedived=temp-result*diver;
result_pos--;
}
result.sign_flag=(this->sign_flag+h2.sign_flag)%2;
return result;
}

int HugeInt::operator>(const HugeInt &h2)
{
int flag=0,i;
if(sign_flag>h2.sign_flag)
return 0;
if(sign_flag<h2.sign_flag)
return 1;
for(i=Max_size-2;i>=0;i--)
if(integer[i]>h2.integer[i]){
flag=1;
break;
}
else if(integer[i]<h2.integer[i]){
flag=0;
break;
}
return (sign_flag+flag)%2;
}

int operator<(HugeInt &h1,HugeInt &h2)
{
int flag=0,i;
if(h1.sign_flag<h2.sign_flag)
return 0;
if(h1.sign_flag>h2.sign_flag)
return 1;
for(i=Max_size-2;i>=0;i--)
if(h1.integer[i]<h2.integer[i]){
flag=1;
break;
}
else if(h1.integer[i]>h2.integer[i]){
flag=0;
break;
}
return (h1.sign_flag+flag)%2;
}

void HugeInt::HugeToString(char *string)
{
int i,j=0;
if(sign_flag)
string[j++]='-';
i=Max_size-2;
while(integer[i]==0&&i>0)
i--;
while(i>=0)
string[j++]=integer[i--]+'0';
string[j]='\0';
}

int HugeInt::operator==(const HugeInt &h)
{
int i,flag=1;
HugeInt temp(h);
if(IsZero()&&temp.IsZero())
return 1;
for(i=0;i<Max_size-1;i++)
if(integer[i]!=h.integer[i]){
flag=0;
return flag;
}
return flag;
}

int HugeInt::IsZero()
{
int i;
for(i=0;i<Max_size-1;i++)
if(integer[i]!=0)
return 0;
return 1;
}

int HugeInt::Length()
{
int i=Max_size-2;
while(integer[i]==0&&i>0)
i--;
return ++i;
}

void HugeInt::SetValueN(int n,int val)
{
if(n>=Max_size-1||val<0||val>9)
return;
else
integer[n]=val;
}
Top

7 楼windking21（想玩玩WOW 真的那么难吗）回复于 2005-08-18 11:24:02 得分 1

用字符串处理Top

8 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:26:16 得分 1

以上算法可以实现加减乘除算法，不过重载<<有点问题，我给去掉了，想输出的话，先用
HugeToString()给转成字符串型的就可以了。Top

9 楼eagle002（坐不住板凳）回复于 2005-08-18 11:27:19 得分 0

xiaocai0001(萧筱雨):
这个精度可以达到多高？Top

10 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:33:36 得分 1

在那个CPP文件头上再加上几个头文件
#include "string.h"
#include "ctype.h"
去掉
#include "stdafx.h"
#include "Calculator.h"

精度？
什么意思？
应该是要多长数据，只要宏定义时，给一下就可以了。
Top

11 楼VivianSnow（Phoenix）回复于 2005-08-18 11:36:45 得分 1

太长了吧````
我的，用Free Pascal写的，高效率：

program VivianSnow;
const max=2000;
var a,b,c:array[1..max]of longint;
i,j,k,l,m,n,s,t,l1,l2:longint;
ch:char;

procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
fillchar(c,sizeof(c),0);
l1:=0; l2:=0;
repeat
read(ch); inc(l1);
a[l1]:=ord(ch)-ord('0');
until eoln;
readln;
repeat
read(ch); inc(l2);
b[l2]:=ord(ch)-ord('0');
until eoln;
readln;
for i:=l1 downto 1 do
begin a[max-l1+i]:=a[i]; a[i]:=0; end;
for i:=l2 downto 1 do
begin b[max-l2+i]:=b[i]; b[i]:=0; end;
end;

procedure main;
var g:longint;
begin
for k:=max downto max-l1 do
begin
g:=0;
for i:=max downto max-l2 do
begin
inc(c[k-max+i],a[k]*b[i]+g);
g:=c[k-max+i] div 10;
c[k-max+i]:=c[k-max+i] mod 10;
end;
end;
end;

procedure print;
begin
for j:=max-l1-l2-1 to max do if c[j]<>0 then break;
for i:=j to max do write(c[i]);
writeln;
end;

begin
assign(input,'temp.in'); reset(input);
while not seekeof do
begin
init;
main;
print;
end;
end.
Top

12 楼VivianSnow（Phoenix）回复于 2005-08-18 11:38:54 得分 5

我的————————————————精度你可以调整max那一项，那一项代表结果的最大长度，你开大点没关系。
program VivianSnow;
const max=20000;
var a,b,c:array[1..max]of longint;
i,j,k,l,m,n,s,t,l1,l2:longint;
ch:char;

procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
fillchar(c,sizeof(c),0);
l1:=0; l2:=0;
repeat
read(ch); inc(l1);
a[l1]:=ord(ch)-ord('0');
until eoln;
readln;
repeat
read(ch); inc(l2);
b[l2]:=ord(ch)-ord('0');
until eoln;
readln;
for i:=l1 downto 1 do
begin a[max-l1+i]:=a[i]; a[i]:=0; end;
for i:=l2 downto 1 do
begin b[max-l2+i]:=b[i]; b[i]:=0; end;
end;

procedure main;
var g:longint;
begin
for k:=max downto max-l1 do
begin
g:=0;
for i:=max downto max-l2 do
begin
inc(c[k-max+i],a[k]*b[i]+g);
g:=c[k-max+i] div 10;
c[k-max+i]:=c[k-max+i] mod 10;
end;
end;
end;

procedure print;
begin
for j:=max-l1-l2-1 to max do if c[j]<>0 then break;
for i:=j to max do write(c[i]);
writeln;
end;

begin
while not seekeof do
begin
init;
main;
print;
end;
end.
Top

13 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:39:57 得分 1

用你的那个测试数据测了一下，结果没错。
int main()
{
HugeInt ht1("2183924444444444448888888888888888888888500000000000000438888888888888333333333333333333333333333333333111111111111111111000000000004444444444444444475888888888888888888888888888888888888888888883499999999999999999999999999999999999999999992000000000000000000000");
HugeInt ht2("38888888888899999999999999999999999999889999999999999999999999999999100000000000000000000000000036666666666666661711111111111111111111111111111111111111111111111111348999999999999999999999999998888888888899999999999999999999999999888888");
HugeInt ht3;
ht3 = ht1 * ht2;
char result[1024];
ht3.HugeToString(result);
cout<<result<<endl;
return 0;
}
//输出结果：
84930395061752661061728395061777777777522422632098761127690123456793012863061771166662666666618468966109876954310325589229851913558393813401259061729635920987666893089578354567901238378268246046746553283882310883951686248900617446672363367064666164327067654325713840070635796642855308566777190063032654321512917291554358024685185185209632790088518518570858122174339502222222222218728367117098765432038886985777777777777777778376548008888888888800000000000000000000000000888896000000000000000000000

//--------第二组
int main()
{
HugeInt ht1("218392444444444444044444444444444444758888888888888888888888888888888888888888888834999999999999999999999999999999999999999999920000008888888888888888888888500000000000000438888888888888333333333333333333333333333333333111111111111111111000000000004444444444444444475888888888888888888888888888888888888888888883499999999999999999999999999999999999999999992000000000000000000000");
HugeInt ht2("3888888888889111111111111111111111111111111111111134899999999999999999999999999888888888889999999999999999999999999988889999999999999999999999999889999999999999999999999999999100000000000000000000000000036666666666666661711111111111111111111111111111111111111111111111111348999999999999999999999999998888888888899999999999999999999999999888888");
HugeInt ht3;
ht3 = ht1 * ht2;
char result[1024];
ht3.HugeToString(result);
cout<<result<<endl;
return 0;
}

//--输出结果

8493039506173324807160493827159604950500000000000750718568049382715954227160493582406618015142512790123456785679011972032895718901222138452167901014089263815530924514073226343694448891747283954217288703185011874937900326172317071622963278517774315948895145396372779617849021101172691338189287888890194539831529571495174790111475238975332903018764585678456483198014090155061559207078708991138550382525678441835126904938331360479574816576791924217806174469150235802557773461444276543257138400706357966428553085667771900630326543215129172915543580246851851852096327900885185185708581221743395022222222222187283671170987654320388869857777777777
77777778376548008888888888800000000000000000000000000888896000000000000000000000

你对对看结果对不对，数据太多，我眼看花了
Top

14 楼VivianSnow（Phoenix）回复于 2005-08-18 11:41:17 得分 6

你这太``` `这程序又不是你刚才编的``拿上来充数不太好吧````Top

15 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:41:33 得分 7

结果没错，鉴定完毕！Top

16 楼eagle002（坐不住板凳）回复于 2005-08-18 11:42:31 得分 0

楼上的哥们：）：
你那个不是用c++编的啊，呵呵。辛苦你了，我要的是c++的。
我下午还会上的！希望大家多支持。
Top

17 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:43:49 得分 1

你这太``` `这程序又不是你刚才编的``拿上来充数不太好吧````

//--------------------
这怎么了啊？
又不是我抄别人的
他确实是我的劳动成果，只不过是以前的。
我可是有版权的啊～～
这是我以前用MFC做一个支持超大整数的运算时用到的。

嘿嘿～～，不好意思
不过这个版本有好多不完善的地方，我近来正想改一下呢。
Top

18 楼VivianSnow（Phoenix）回复于 2005-08-18 11:44:38 得分 1

来算算这两个的乘积：
13247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375132471823975812937054988123948129037581392489137513247182397581293705498812394812903758139248913751324718239758129370549881239481290375813924891375

000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324000000000000000000000000000000000002349857325092875234523451783940791324

你的是多少？
我的是：
31128988593797800468793082029875800533153921208009913982007189912634529817514400478851115860913883021274001252145184660988552523195695244173741897613540298923014987259180885128120102678338582196562437177702434086376427399925710808068302651301686119518303397329845649541075718890939417915639480024850628140201777646983983372422247862999570749085632872946607828274009811236040025255093039104784363820448581990834202064271414135113159813221891335179845326992165450082227674567432523988123272281328117120349725856421121565257212045480842203028665965633242979386725259966658308855057395633201664397032117379968548326529819752093512540646467976572290862247308267731450782444002433283940447330811150294231531909920955210832050752639806943530881583822505183066792628675004413082065063842163220746032759829719578060667969234390236382184749475995811282784055105616199384573948335051117272748068374210308281311094773859665401634588259537407394487930342241029907277854759622193334626486894660656799835307250800860373126471530746361446489934858762013406525613239958520653954157783954781581136385512753551359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184172626195457561323995852065395415778395478158113324148490557778127711654386240783572508008603731264404017577676486894660345509949369272796172442306141643752436109477385966540163458825953740739137500035387265606259807776355258340551056161993845739172060625234749475684521396846077100928268564275159200730984262867500441308206506384216321763313386932095093738355929745372815319099209552108320507215108183497330499860408293553905233024390533292716179279137652981975209351254064646797345939200283639923225834477898762929793867252599666583088550262666446078354675747305001382037329146359550849694727432527767456743252398812327227821521826096991468055321956446916319908342020642714141351131597820929027102530562644012829514133451115377107828242880822642242224786299957074908251997408722804819600151443925464473298456495410757188909394179156083510051278417459351840961610255420132934086376396270937117010267833858219655932427884305430632951696273412943021451846609885525231956952441737418664534227165314167179973057732224437689912634529786385411885053315392120800680108314781013258765047818242430500

0.0024s出结果Top

19 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:45:18 得分 5

VivianSnow(Phoenix)
你怎么用Pascal搞起来了？
看来你是Pascal起家的啊～～Top

20 楼VivianSnow（Phoenix）回复于 2005-08-18 11:45:43 得分 1

改成C++也Easy啊 ```等等我咯``Top

21 楼VivianSnow（Phoenix）回复于 2005-08-18 11:46:32 得分 1

总觉得Pascal写程序爽些 ``嘿嘿```而且相对于C来说，感觉短些，整齐些Top

22 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:47:41 得分 1

我的结果
373126440401757767648689466034550994936927279617244230614164375243610947738596654016345882595374073913750003538726560625980777635525834055105616199384573917206062523474947568452139684607710092826856427515920073098426286750044130820650638421632176331338693209509373835592974537281531909920955210832050721510818349733049986040829355390523302439053329271617927913765298197520935125406464679734593920028363992322583447789876292979386725259966658308855026266644607835467574730500138203732914635955084969472743252776745674325239881232722782152182609699146805532195644691631990834202064271414135113159782092902710253056264401282951413345111537710782824288082264224222478629995707490825199740872280481960015144392546447329845649
5410757188909394179156083510051278417459351840961610255420132934086376396270937117010267833858219655932427884305430632951696273412943021451846609885525231956952441737418664534227165314167179973057732224437689912634529786385411885053315392120800680108314781013258765047818242430500
程序运行时间我没算。很快，人的感觉<0.1sTop

23 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:49:36 得分 1

结果有出入！
你第二个怎么弄了那么多的前导0啊！Top

24 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:50:41 得分 1

楼主给的测试数据你试了没有啊？Top

25 楼VivianSnow（Phoenix）回复于 2005-08-18 11:53:03 得分 1

废话``他那么弱的测试数据不对才怪``Top

26 楼VivianSnow（Phoenix）回复于 2005-08-18 11:53:55 得分 1

前导零很正常啊``难道不行吗？Top

27 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 11:55:22 得分 1

你给的是什么数据啊！！
换一个，上面那个咱俩的尾数是一样的Top

28 楼VivianSnow（Phoenix）回复于 2005-08-18 11:59:28 得分 1

拜托``你这样的态度就不行啊`
你的程序应该对于任何合理的输入都有正确的结果啊``你既然这个不对 `那么程序就一定有BUG咯，要改成对的啊。Top

29 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:02:13 得分 1

关键是，谁的对啊？Top

30 楼VivianSnow（Phoenix）回复于 2005-08-18 12:06:30 得分 1

呵呵```你先看看你可能对吗？答案的位数可能只有你那么一点吗？你的位数比输入还少Top

31 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:07:45 得分 1

看出来了Top

32 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:13:19 得分 7

你耍我呢！！
你给的两个数都过1000位了，还不跟我说！！！Top

33 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:16:29 得分 1

这下行了！
你～～～
结果：
31128988593797800468793082029875800533153921208009913982007189912634529817514400478851115860913883021274001252145184660988552523195695244173741897613540298923014987259180885128120102678338582196562437177702434086376427399925710808068302651301686119518303397329845649541075718890939417915639480024850628140201777646983983372422247862999570749085632872946607828274009811236040025255093039104784363820448581990834202064271414135113159813221891335179845326992165450082227674567432523988123272281328117120349725856421121565257212045480842203028665965633242979386725259966658308855057395633201664397032117379968548326529819752093512540646467976572290862247308267731450782444002433283940447330811150294231531909920955210832050752639806943530881583822505183066792628675004413082065063842163220746032759829719578060667969234390236382184749475995811282784055105616199384573948335051117272748068374210308281311094773859665401634588259537407394487930342241029907277854759622193334626486894660656799835307250800860373126471530746361446489934858762013406525613239958520653954157783954781581136385512753551359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184203755184051359124464645147425291578928632079321334062472564968040346184172626195457561323995852065395415778395478158113324148490557778127711654386240783572508008603731264404017577676486894660345509949369272796172442306141643752436109477385966540163458825953740739137500035387265606259807776355258340551056161993845739172060625234749475684521396846077100928268564275159200730984262867500441308206506384216321763313386932095093738355929745372815319099209552108320507215108183497330499860408293553905233024390533292716179279137652981975209351254064646797345939200283639923225834477898762929793867252599666583088550262666446078354675747305001382037329146359550849694727432527767456743252398812327227821521826096991468055321956446916319908342020642714141351131597820929027102530562644012829514133451115377107828242880822642242224786299957074908251997408722804819600151443925464473298456495410757188909394179156083510051278417459351840961610255420132934086376396270937117010267833858219655932427884305430632951696273412943021451846609885525231956952441737418664534227165314167179973057732224437689912634529786385411885053315392120800680108314781013258765047818242430500Top

34 楼VivianSnow（Phoenix）回复于 2005-08-18 12:18:17 得分 2

- - ！你自己估量估量嘛````Top

35 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:21:06 得分 1

我哪有劲去数它的长度～～
你太不厚道了。
楼主说的也过不是500位内的Top

36 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:21:59 得分 1

我的程序没问题的，过长了，它就自动截掉高位了。
要不要再试试数据？Top

37 楼VivianSnow（Phoenix）回复于 2005-08-18 12:24:54 得分 1

Okay``好啊Top

38 楼VivianSnow（Phoenix）回复于 2005-08-18 12:34:20 得分 1

搂主，我把程序改成C++啦：
------------------------------------------------------
#include <stdafx.h>
#include <iostream>

const int max=20000;
int a[max+1],b[max+1],c[max+1];
int i,j,k,l,m,n,s,t,l1,l2;
char ch;

void init(){
l1=0; l2=0;
while (true){
scanf("%c",&ch);
if (ch==10){break;}
l1++;
a[l1]=ch-48;
}
while (true){
scanf("%c",&ch);
if (ch==10){break;}
l2++;
b[l2]=ch-48;
}
for (i=l1;i>=1;i--){
a[max-l1+i]=a[i];
a[i]=0;
}
for (i=l2;i>=1;i--){
b[max-l2+i]=b[i];
b[i]=0;
}
}

void doing(){
int g;
for (k=max;k>=max-l1;k--){
g=0;
for (i=max;i>=max-l2;i--){
c[k-max+i]+=a[k]*b[i]+g;
g=c[k-max+i]/10;
c[k-max+i]=c[k-max+i]%10;
}
}
}

void print(){
for (j=max-l1-l2-1;j<=max;j++){
if (c[j]!=0){break;}
}
for (i=j;i<=max;i++){
printf("%d",c[i]);
}
printf("\n");
}

int main(){
init();
doing();
print();

system("pause");
return 0;
}
Top

39 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:34:41 得分 1

来这个：
A=B=
1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890

我的结果：
1524157875323883675049535156256668194500838287337600975522511812231126352691000152415888766956267751867094662703856255022100304377381498325255296621277244341002895901987806736987532388377628410305650358177353787532414253924709312909617720042676450879439112975461058086297820487504953516638012498452552964524130467920300563938818808108560755982323963115379185063252597381496727625666819551318396634007011131288218259917573540670632525534950769700283828684707258039938613321140650083828743883554342275872581016338972780509068745938424021382594116817134583149600975461748849260853760097553263526902115104404890385611956926078342481359548927011126360588629782847614692963636640764251181223213869837000262155167913732663580124981036887669571576284103946380125073513183975238835544312635269110138698378901386984678890413146764212782563938425045145557183389727186226489865411400701220015241589889041305777655845256640755993551592746143910989293266270397214144186510166133329891784800876695626876421277366516994372964182290507666514371891479969301630850141411370335265965565639079409775156226298640451161976527969408901082262014936758313976529042645938225389422354651425088676390794188763907950988873648310135650152138393547326322207943880506115512879143663770767577625362078887364740001219327211370218042261850336338667886845115074005636335932676116446478859929969010821529013565006112604785932385307125351013565746349641895759792721688462125380094497859134278318025910685013839353822508763914363359244647584209785883249510700807804281329065749257735107038256363915073921712632220703375704923548818777676006706299713153483182563633639381191896050602042816308489602755677492388050602450053345566130163088725499162083798201529504648685062947721717543057492879134281400396281351287913456253619877737844840985032769419628105474075293400618777625383002591070412741960252522481346377076666750190519886267337309751562263087639079520012193273126047859425087639153757049236500533455762536198787501905199875019052100

Top

40 楼VivianSnow（Phoenix）回复于 2005-08-18 12:38:04 得分 1

1524157875323883675049535156256668194500838287337600975522511812231126352691000152415888766956267751867094662703856255022100304377381498325255296621277244341002895901987806736987532388377628410305650358177353787532414253924709312909617720042676450879439112975461058086297820487504953516638012498452552964524130467920300563938818808108560755982323963115379185063252597381496727625666819551318396634007011131288218259917573540670632525534950769700283828684707258039938613321140650083828743883554342275872581016338972780509068745938424021382594116817134583149600975461748849260853760097553263526902115104404890385611956926078342481359548927011126360588629782847614692963636640764251181223213869837000262155167913732663580124981036887669571576284103946380125073513183975238835544312635269110138698378901386984678890413146764212782563938425045145557183389727186226489865411400701220015241589889041305777655845256640755993551592746143910989293266270397214144186510166133329891784800876695626876421277366516994372964182290507666514371891479969301630850141411370335265965565639079409775156226298640451161976527969408901082262014936758313976529042645938225389422354651425088676390794188763907950988873648310135650152138393547326322207943880506115512879143663770767577625362078887364740001219327211370218042261850336338667886845115074005636335932676116446478859929969010821529013565006112604785932385307125351013565746349641895759792721688462125380094497859134278318025910685013839353822508763914363359244647584209785883249510700807804281329065749257735107038256363915073921712632220703375704923548818777676006706299713153483182563633639381191896050602042816308489602755677492388050602450053345566130163088725499162083798201529504648685062947721717543057492879134281400396281351287913456253619877737844840985032769419628105474075293400618777625383002591070412741960252522481346377076666750190519886267337309751562263087639079520012193273126047859425087639153757049236500533455762536198787501905199875019052100
Top

41 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:40:41 得分 1

呵呵，一样，都没问题。
OK！
楼主可以结贴了～～Top

42 楼K（）回复于 2005-08-18 12:45:05 得分 1

这个面试题超easyTop

43 楼eagle002（坐不住板凳）回复于 2005-08-18 12:47:35 得分 0

能帮我分析一下程序的流程么，因为这个程序我不是我写的，所以还是有我不懂的地方。
麻烦了。
Top

44 楼VivianSnow（Phoenix）回复于 2005-08-18 12:48:07 得分 1

OKay啦``楼主，我等分分啦，综合一下我的算法:

-------------------------------------------------
Free Pascal:
-------------------------------------------------
program VivianSnow;
const max=20000;
var a,b,c:array[1..max]of longint;
i,j,k,l,m,n,s,t,l1,l2:longint;
ch:char;

procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
fillchar(c,sizeof(c),0);
l1:=0; l2:=0;
repeat
read(ch); inc(l1);
a[l1]:=ord(ch)-ord('0');
until eoln;
readln;
repeat
read(ch); inc(l2);
b[l2]:=ord(ch)-ord('0');
until eoln;
readln;
for i:=l1 downto 1 do
begin a[max-l1+i]:=a[i]; a[i]:=0; end;
for i:=l2 downto 1 do
begin b[max-l2+i]:=b[i]; b[i]:=0; end;
end;

procedure main;
var g:longint;
begin
for k:=max downto max-l1 do
begin
g:=0;
for i:=max downto max-l2 do
begin
inc(c[k-max+i],a[k]*b[i]+g);
g:=c[k-max+i] div 10;
c[k-max+i]:=c[k-max+i] mod 10;
end;
end;
end;

procedure print;
begin
for j:=max-l1-l2-1 to max do if c[j]<>0 then break;
for i:=j to max do write(c[i]);
writeln;
end;

begin
while not seekeof do
begin
init;
main;
print;
end;
end.

-------------------------------------------------
C++
-------------------------------------------------
#include <stdio.h>
#include <iostream>

using namespace std;

const int maxn=20000;
int a[maxn+1],b[maxn+1],c[maxn+1];
int i,j,k,l,m,n,s,t,l1,l2;
char ch;

void init(){
l1=0; l2=0;
while (true){
scanf("%c",&ch);
if (ch==10){break;}
l1++; a[l1]=ch-48;
}
while (true){
scanf("%c",&ch);
if (ch==10){break;}
l2++; b[l2]=ch-48;
}
for (i=l1;i>=1;i--){a[maxn-l1+i]=a[i]; a[i]=0;}
for (i=l2;i>=1;i--){b[maxn-l2+i]=b[i]; b[i]=0;}
}

void doing(){
int g;
for (k=maxn;k>=maxn-l1;k--){
g=0;
for (i=maxn;i>=maxn-l2;i--){
c[k-maxn+i]+=a[k]*b[i]+g;
g=c[k-maxn+i]/10;
c[k-maxn+i]=c[k-maxn+i]%10;
}
}
}

void print(){
for (j=maxn-l1-l2-1;j<=maxn;j++){if (c[j]!=0){break;}}
for (i=j;i<=maxn;i++){printf("%d",c[i]);}
printf("\n");
}

int main(){
init();
doing();
print();
//-------------------------------------
system("pause");
return 0;
}
Top

45 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:50:40 得分 1

能帮我分析一下程序的流程么，因为这个程序我不是我写的，所以还是有我不懂的地方。
麻烦了。

------------------------------------
晕先～～
这个说来话长了
基本原理就是你小学学的乘法算法，一个位一个位的乘，乘完了再相加，还有进位等。
一般用一个int型保存数据的一位。
高效一点的可以保存2位到4位。Top

46 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 12:53:42 得分 1

先解释一下我的吧
HugeInt HugeInt::operator*(HugeInt &h2)
{
HugeInt temp;
int i,j,carry=0;
if(*this=="0"||h2=="0")
return (temp="0");
for(i=0;i<Max_size-1;i++)//被乘数
for(j=0;j<Max_size-1;j++)//乘数
if(i+j<Max_size)
temp.integer[i+j]+=integer[i]*h2.integer[j];//乘数的每一位与被乘数相乘
for(i=0;i<Max_size-1;i++){//再处理进位
temp.integer[i]+=carry;
if(temp.integer[i]>9){//超过10的进位
carry=temp.integer[i]/10;
temp.integer[i]%=10;
}
else
carry=0;
}
temp.sign_flag=(sign_flag+h2.sign_flag)%2;//最后进行符号运算
return temp;
}
Top

47 楼VivianSnow（Phoenix）回复于 2005-08-18 12:55:10 得分 1

#include <stdio.h>
#include <iostream>

using namespace std;

const int maxn=20000;
int a[maxn+1],b[maxn+1],c[maxn+1];
int i,j,k,l,m,n,s,t,l1,l2;
char ch;

void init(){
l1=0; l2=0; //l1,l2代表两个大数的位数，初始化都为0
while (true){ //读入第一个大数，存放在数组a里面，累加算出 l1
scanf("%c",&ch);
if (ch==10){break;}
l1++; a[l1]=ch-48;
}
while (true){ //读入第而个大数，存放在数组b里面，累加算出 l2
scanf("%c",&ch);
if (ch==10){break;}
l2++; b[l2]=ch-48;
}
for (i=l1;i>=1;i--){a[maxn-l1+i]=a[i]; a[i]=0;} //把数组a里面的数平移到最右端（右对齐）
for (i=l2;i>=1;i--){b[maxn-l2+i]=b[i]; b[i]=0;} //把数组b里面的数平移到最右端（右对齐）
}

void doing(){
int g; //g代表进位的数；数组c为两数相乘的结果。
//按照一般我们用的竖式乘法进行运算，下面的步骤要自己体会
//两个数都从右边开始乘，注意乘的时候会出现进位，要存到g里面
for (k=maxn;k>=maxn-l1;k--){
g=0; //初始化0
for (i=maxn;i>=maxn-l2;i--){
c[k-maxn+i]+=a[k]*b[i]+g; //得到乘积与进位的和
g=c[k-maxn+i]/10; //进位转移
c[k-maxn+i]=c[k-maxn+i]%10; //得到0~9之间的数
}
}
}

void print(){
for (j=maxn-l1-l2-1;j<=maxn;j++){if (c[j]!=0){break;}} //从最左边开始往右判断第一个不为0的数的坐标j
for (i=j;i<=maxn;i++){printf("%d",c[i]);} //从坐标j开始往右到最右端，输出c数组也就是结果的值
printf("\n"); //回车
}

int main(){
init(); //读入数据
doing(); //运算
print(); //输出
//-------------------------------------
system("pause");
return 0;
}
Top

48 楼eagle002（坐不住板凳）回复于 2005-08-18 12:57:38 得分 0

谢谢，其实也不是要用注释的形式，不过是帮我说一下这个循环有什么作用什么的。Top

49 楼VivianSnow（Phoenix）回复于 2005-08-18 13:15:55 得分 1

你用我的代码去跟踪调试调试，注意k,i,a,b,c的变量值，
可以先测试测试小一点的数，比如说1234*5678，把const int max的值改成20。
调试的过程中你就明白怎么运算的了，这个需要自己理解的。Top

50 楼eagle002（坐不住板凳）回复于 2005-08-18 14:36:55 得分 0

真是谢谢二位了，我把100分分给你们俩吧，这样平均点。
ok？Top

51 楼eagle002（坐不住板凳）回复于 2005-08-18 14:39:55 得分 0

谢谢你们，向你们学习，呵呵Top

52 楼eagle002（坐不住板凳）回复于 2005-08-18 14:55:21 得分 0

我该怎么给你们俩分啊？我从来没给过别人分。Top

53 楼OMA_yudy（太平洋深深）回复于 2005-08-18 15:52:30 得分 1

#include <iostream>
using namespace std;

#define N 5

int result[N*2];

void fun(int a[],int b[]);

void fun(int a[],int b[])
{
int carry=0, tmp=0, att=0, b1 = 0, b2 = 0;
int c[N+1];

for (int i=0; i<N; i++) {
for (int j=0; j<N; j++) {
tmp = a[j] * b[i];
att = (tmp % 10 + carry);
c[j] = (att>=10)?(b1 = 1, (att-10)):(b1 = 0, att);
carry = tmp/10 + b1;
att = c[j] + result[j+i] + b2;
result[j+i] = (att>=10)?(b2 = 1, (att-10)):(b2 = 0, att);
cout<<c[j];
}
c[N] = carry;
att = c[N] + result[N+i] + b2;
result[N+i] = (att>=10)?(b2 = 1, (att-10)):(b2 = 0, att);
cout<<c[N];
carry=0, tmp=0, att=0, b1 = 0, b2 = 0;
cout<<endl;
}
}

int main(int argc, char* argv[])
{
int n[]={1,2,3,4,6}; // 64321
int m[]={6,9,4,9,8}; // 89496
for (int i=0; i<N*2; i++) {
result[i] = 0;
}
fun(m,n);
for (i=N*2-1; i>=0; i--) {
cout<<result[i];
}

return 0;
}
Top

54 楼OMA_yudy（太平洋深深）回复于 2005-08-18 15:55:02 得分 0

#define N 5 每个数组的大小

int n[]={1,2,3,4,6}; // 这是整数 64321
int m[]={6,9,4,9,8}; // 整数 89496
//注意数组里数的顺序

测试通过Top

55 楼eagle002（坐不住板凳）回复于 2005-08-18 16:04:42 得分 0

怎么把散分？怎么结贴？Top

56 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 16:06:39 得分 1

此贴你的题目上面有个“管理”链接，点它就是了Top

57 楼xingbozy（3951263）回复于 2005-08-18 16:13:50 得分 1

哦耶!!!精彩!!!Top

58 楼VivianSnow（Phoenix）回复于 2005-08-18 16:16:23 得分 1

呵呵``楼主还没给过分啊```哈哈``Top

59 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 16:18:08 得分 3

你等不及了？？Top

60 楼VivianSnow（Phoenix）回复于 2005-08-18 16:22:28 得分 3

？？？？Top

61 楼eagle002（坐不住板凳）回复于 2005-08-18 16:22:47 得分 0

我是想给分，但是我不会给啊，管理那里边也没找到啊，就有个给分，但是他说超过范围什么了的。
Top

62 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 16:24:35 得分 2

要分升级啊Top

63 楼eagle002（坐不住板凳）回复于 2005-08-18 16:27:35 得分 0

我想给，但是不知道怎么给，明白么？我没骗你们的。
有分大家赚Top

64 楼VivianSnow（Phoenix）回复于 2005-08-18 16:29:54 得分 1

我倒````` - -~ ` 那就要看你的悟性了`` - - !Top

65 楼eagle002（坐不住板凳）回复于 2005-08-18 16:33:48 得分 0

你别倒啊，我要是不给分的话，我在这个bbs上还怎么混了啊？
我真的不知道Top

66 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-08-18 16:38:14 得分 1

http://www.csdn.net/help/help.asp?bigclass=社区帮助&smallclass=社区使用
看看吧Top

67 楼eagle002（坐不住板凳）回复于 2005-08-18 16:48:44 得分 0

吗的，系统说给分的次数少与帖子回复的次数！Top

68 楼eagle002（坐不住板凳）回复于 2005-08-18 16:49:36 得分 0

我会想办法给分的，Top

69 楼junmayang（笨猪）回复于 2005-08-18 17:01:48 得分 1

有意思Top

70 楼SammyLan（(基础决定你能走多远)--英语菜才是真的菜）回复于 2005-08-18 17:06:19 得分 1

核心代码就在这里,其它的就自己想着办吧
template <typename T,int size1,int size2>
void Mul(T (&ver1)[size1],T (&ver2)[size2],T (&ver)[size1+size2])
{
//for(int i=0;i<size1+size2);++i)ver[i]=0;
//可以假如该句以防止ver没有初始化
for (int i=0;i<size1;++i) {
T Add=0;
for (int j=0;j<size2;++j) {
int cur=i+j;
T temp=ver1[i]*ver2[j];
ver[cur]+=temp%10+Add;
Add=temp/10;
temp=ver[cur]/10;
while (temp) {
ver[cur]=ver[cur]%10;
++cur;
ver[cur]+=temp;
temp=ver[cur]/10;
}
}
}
}

Top

71 楼SammyLan（(基础决定你能走多远)--英语菜才是真的菜）回复于 2005-08-18 17:13:28 得分 1

学计算机的这道题做不出有点说不过去
要是叫你实现大数相加你还不想死Top

72 楼ChenLiuqing（没有心的鸟^_^(★★★★★)）回复于 2005-09-08 17:35:04 得分 0

markTop

73 楼csucdl（csucdl）回复于 2005-09-12 10:29:50 得分 0

#include <iostream>
#include <Cstring>

const int MSL = 500;
const int MRL = 1000;

using namespace std;

void Initial(char* A);
void ShiftLeft(char* A, int time);
void Add(char* A, char* B);
void Print(char* A);

int main ()
{
char A[MSL] = "21839244444444444488888888888888888888885"
"00000000000000438888888888888333333333333"
"33333333333333333333311111111111111111100"
"00000000044444444444444444758888888888888"
"88888888888888888888888888888883499999999"
"99999999999999999999999999999999999200000"
"0000000000000000";
//{'\0'};
char B[MSL] = "38888888888899999999999999999999999999889"
"99999999999999999999999999910000000000000"
"00000000000000366666666666666617111111111"
"11111111111111111111111111111111111111111"
"34899999999999999999999999999888888888889"
"9999999999999999999999999888888";
//{'\0'};
char C[MRL];
char D[MRL];
Initial(C);
Initial(D);

//cin>>A;
//cin>>B;

int fal = strlen(A);
int fbl = strlen(B);
int carry = 0;

for(int i = 0; i < fbl; i++)
{
carry = 0;
Initial(C);

for(int j = 0; j < fal; j++)
{
int k = MRL - j - 1;
int g = fal - j - 1;
int h = fbl - i - 1;
int facta = A[g] - 48;
int factb = B[h] - 48;
int result = facta * factb + carry;
C[k] = (char)((result % 10) + 48);
carry = result / 10;

}

C[MRL - j - 1] = (char)(carry + 48);
ShiftLeft(C, i);
Add(D, C);
}

Print(D);
return 0;

}

void Initial(char* A)
{
for(int i = 0; i < MRL; i++)
{
A[i] = '0';
}
return;
}

void ShiftLeft(char* A, int time)
{
for(int j = 0; j < time; j++)
{
for(int i = 0; i < MRL - 1; i++)
{
A[i] = A[i + 1];
}
A[MRL - 1] = '0';
}
return;
}

void Add(char* A, char* B)
{
int carry = 0;
int result = 0;
for(int i = MRL - 1; i >= 0; i--)
{
result = A[i] + B[i] + carry - 48*2;
A[i] = (char)((result % 10) + 48);
carry = result / 10;
}
return;
}

void Print(char* A)
{
bool flag = true;
for(int i = 0; i < MRL; i++)
{
if(A[i] == '0' && flag)
{
;
}
else
{
flag = false;
cout<<A[i];
}
}
cout<<endl;
return;
}Top

74 楼SaSir（沙子）回复于 2005-09-15 13:49:37 得分 0

#include "stdafx.h"

void Multiple(char A[], char B[], char C[])
{
int TMP, In=0, LenA=-1, LenB=-1;
while(A[++LenA] != '\0');
while(B[++LenB] != '\0');
int Index, Start = LenA + LenB - 1;
for(int i=LenB-1; i>=0; i--)
{
Index = Start--;
if(B[i] != '0')
{
for(int In=0, j=LenA-1; j>=0; j--)
{
TMP = (C[Index] - '0') + (A[j] - '0') * (B[i] - '0') + In;
C[Index--] = TMP % 10 + '0';
In = TMP / 10;
}
C[Index] = In + '0';
}
}
}

int main(int argc, char* argv[])
{
char A[] = "218392444444444444888888888800088888889";
char B[] = "38888888888899999999999999999999988";
char C[sizeof(A) + sizeof(B) - 1];

for(int k=0; k<sizeof(C); k++)
C[k] = '0';
C[sizeof(C)-1] = '\0';

Multiple(A, B, C);
for(int i=0; C[i] != '\0'; i++)
printf("%c", C[i]);
return getchar();
}

Top

75 楼xiaocai0001（高楼目尽欲黄昏/梧桐叶上萧萧雨）回复于 2005-09-15 13:55:00 得分 0

太强了,都结帖多少天了
还有人往上帖~~~Top

76 楼niefuhua（阳光）回复于 2005-09-16 11:19:41 得分 0

upTop

77 楼csucdl（csucdl）回复于 2005-09-16 21:39:26 得分 0

简洁的代码出来了
恭喜，恭喜
Top