C++编程题

Posted 2023-05-16

封装一个大整数类HugeInt，以支持任意大整数的四则运算，重载你认为需要的所有运算符，比如=,==,>等等运算符。
测试类是否正确:如计算 n=100! + 50!

谁能帮帮我,最好有完整代码,太麻烦的话也可以告诉我这题的思路及一些细节,如大概步骤,都要重载那些运算符等.

谢谢!

我写了最基本的四则运算和赋值，其它的都可以从这些推出来，留给楼主自己写一部分吧。

#include<iostream>
#include<string>
#include<math.h>
class HugeInt

unsigned char num[501];
int Exp;
public:
HugeInt();

inline unsigned char* getnum()return num;
inline int getExp()return Exp;
inline void setExp(int n)Exp=n;

void operator=(int n);
void operator=(long n);
void operator=(double n);
HugeInt operator+(int n);
HugeInt operator-(int n);
HugeInt operator*(int n);
HugeInt operator/(int n);
HugeInt operator+(HugeInt n);
;

HugeInt HugeInt::operator+(int n)

HugeInt H;
int i;
unsigned char *buf;
buf=H.getnum();
for(i=0;i<500;i++)

buf[i]=buf[i]+num[i]+n%100;
if(buf[i]>=100)

buf[i+1]+=buf[i]/100;
buf[i]%=100;

if(buf[i]!=0) H.setExp(i);
n/=100;

return H;


HugeInt HugeInt::operator-(int n)

HugeInt H;
int i;
unsigned char *buf;
buf=H.getnum();
for(i=0;i<500;i++)

buf[i]+=num[i]-n%100;
if(buf[i]<0)

buf[i+1]--;
buf[i]+=100;

if(buf[i]!=0) H.setExp(i);
n/=100;

return H;


HugeInt HugeInt::operator*(int n)

HugeInt H;
int i,sum,j;
unsigned char *buf;
buf=H.getnum();
for(i=0;i<500;i++)

sum=num[i]*n;
for(j=i;sum>0;j++)

buf[j]=buf[j]+sum%100;
if(buf[j]>=100)

buf[j+1]+=buf[j]/100;
buf[j]%=100;

sum/=100;

if(buf[j-1]!=0) H.setExp(j-1);

return H;


HugeInt HugeInt::operator/(int n)

HugeInt H;
int i,m=0;
unsigned char *buf;
buf=H.getnum();
for(i=Exp;i>=0;i--)

buf[i]=buf[i]+(num[i]+m*100)/n;
m=(num[i]+m*100)%n;

return H;


HugeInt HugeInt::operator+(HugeInt n)

HugeInt H;
int i;
unsigned char *buf,*add;
buf=H.getnum();
add=n.getnum();
for(i=0;i<500;i++)

buf[i]=num[i]+add[i];
if(buf[i]>=100)

buf[i+1]+=buf[i]/100;
buf[i]%=100;

if(buf[i]!=0) H.setExp(i);

return H;


void HugeInt::operator=(int n)

int i;
for(i=0;0<n;i++)

num[i]+=n%100;
n/=100;

if(i!=0) Exp=i-1;


void HugeInt::operator=(long n)

int i;
for(i=0;0<n;i++)

num[i]+=n%100;
n/=100;

if(i!=0) Exp=i-1;


void HugeInt::operator=(double n)

int i;
int a;
for(i=0;1<=n;i++)

a=(n/100-floor(n/100))*100;
num[i]+=a;
n/=100;

if(i!=0) Exp=i-1;


HugeInt::HugeInt()

memset(num,0,501);
Exp=0;


void main()

HugeInt a,b;
int i;
unsigned char *buf;
a=1;
b=1;
for(i=1;i<101;i++)
a=a*i;
for(i=1;i<51;i++) b=b*i;
a=a+b;
buf=a.getnum();
for(i=a.getExp();i>=0;i--)

printf("%02d",buf[i]);


参考技术A 看了下负家子弟的,他的好像实现一个大整数和小整数之间的运算,没有大整数与整数之间的运算.
我的写好了.不过只封装了大整数与大整数加法和乘法,减法和除法你自己写吧,减法简单,除法你就用减法的办法来实现吧,那些运算符"> < ="也都不难,另处我用友元函数重载了<<和>>的流操作符,输入与输出更加方便.代码如下(有时间了我会把此类完善一下,如果楼主有兴趣可留下E-mail) 运行通过:

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
class Cbigint

private:
char m_int[1000];
public:
Cbigint(char *p=NULL)

if(p==NULL)

char m[1000]=0;
strcpy(m_int,m);

else
strcpy(m_int,p);


void sinmult(int offset,int str1,char *str2,int n,int *dest);
void mult(char *str1,char *str2,int *dest);
void sum(char *str1,char*str2,int *dest);
friend ostream&operator<<(ostream &dirt,Cbigint &iv)

return dirt<<iv.m_int;

friend istream&operator>>(istream &dirt,Cbigint &iv)

return dirt>>iv.m_int;

Cbigint operator+(const Cbigint &n);
Cbigint operator*(const Cbigint &n);
;
void Cbigint::sinmult(int offset,int str1,char *str2,int n,int *dest)

int inc=0,i,x;
i=n-1;
while(i>=0)

x=str2[i]*str1+inc+dest[offset];
dest[offset]=x%10;
inc=x/10;
i--;
offset++;

while(inc)

x=dest[offset]+inc;
dest[offset]=x%10;
inc=x/10;
offset++;


void Cbigint::mult(char *str1,char *str2,int *dest)

int n=strlen(str1),i=0,m;
m=strlen(str2);
while(i<m)

str2[i]-=48;
i++;

i=n-1;
while(i>=0)

sinmult(n-i-1,str1[i]-48,str2,m,dest);
i--;



Cbigint Cbigint::operator *(const Cbigint &n)

Cbigint temp;
int dest[1000]=0;
int i=0,j=0;
char str1[1000],str2[1000];
strcpy(str1,m_int);
strcpy(str2,n.m_int);
mult(str1,str2,dest);
for(i=999;i>=0;i--)
if(dest[i]!=0)
break;
for(j=0;j<=i;j++)
temp.m_int[j]=dest[i-j]+48;
temp.m_int[j]='\0';
return temp;

Cbigint Cbigint::operator +(const Cbigint &n)

Cbigint temp;
int dest[1000]=0;
int i=0,j=0;
char str1[1000],str2[1000];
strcpy(str1,m_int);
strcpy(str2,n.m_int);
if(strlen(str1)>strlen(str2))
sum(str1,str2,dest);
else
sum(str2,str1,dest);
for(i=999;i>=0;i--)
if(dest[i]!=0)
break;
for(j=0;j<=i;j++)
temp.m_int[j]=dest[i-j]+48;
temp.m_int[j]='\0';
return temp;


void Cbigint::sum(char *str1,char *str2,int *dest)

int i=strlen(str1),j=strlen(str2),m=0,x=0,inc=0;
char temp;
while(m<(i+1)/2)

temp=str1[m];
str1[m]=str1[i-m-1];
str1[i-m-1]=temp;
m++;

m=0;
while(m<(j+1)/2)

temp=str2[m];
str2[m]=str2[j-m-1];
str2[j-m-1]=temp;
m++;

m=0;
while(m<j)

x=str1[m]+str2[m]+inc-96;
dest[m]=x%10;
inc=x/10;
m++;

while(m<i)

x=str1[m]+inc-48;
dest[m]=x%10;
inc=x/10;
m++;

dest[m]=inc;

int main()

Cbigint a,b;
cin>>a>>b;
cout<<(a*b)<<endl;
cout<<(a+b)<<endl;
return 1;
本回答被提问者采纳 参考技术B 思路:
1.实现正整数的加法.
2.实现取反运算.
3.实现大的正整数减小的正整数运算.
4.实现正整数乘以一位整数的运算
5.实现正整数乘以10的N次方的运算(就是尾部加0)
6.实现正整数乘法
7.实现正整数除法 参考技术C 说个思路吧，我觉得这个数要用字符存储，四则运算的时候 对本位，低位和高为进行判断 把结果保留到一个字符数组里 参考技术D dim a
for i=1 to 100
a=i*a
next

用C++编程思想解决一道题

有一百万个数，是在1到一亿当中随机取值，找出这一亿个数中没出现的数，要求用最小的时间复杂度。
说下思想就行，我想到的就是遍历，但感觉太复杂了。

思路是反过来，判断1个数不在这一百万个数里，那么肯定是在一亿里了
如何在一百万个数里查找？下面的思路来自网上，供参考：时间复杂度可以降到O（logn）
腾讯面试题：给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？
　　与上第6题类似，我的第一反应时快速排序+二分查找。以下是其它更好的方法： 方案1：oo，申请512M的内存，一个bit位代表一个unsigned int值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。
　　dizengrong： 方案2：这个问题在《编程珠玑》里有很好的描述，大家可以参考下面的思路，探讨一下：又因为2^32为40亿多，所以给定一个数可能在，也可能不在其中；这里我们把40亿个数中的每一个用32位的二进制来表示假设这40亿个数开始放在一个文件中。
　　然后将这40亿个数分成两类: 1.最高位为0 2.最高位为1 并将这两类分别写入到两个文件中，其中一个文件中数的个数<=20亿，而另一个>=20亿（这相当于折半了）；与要查找的数的最高位比较并接着进入相应的文件再查找
再然后把这个文件为又分成两类: 1.次最高位为0 2.次最高位为1
　　并将这两类分别写入到两个文件中，其中一个文件中数的个数<=10亿，而另一个>=10亿（这相当于折半了）； 与要查找的数的次最高位比较并接着进入相应的文件再查找。 ....... 以此类推，就可以找到了,而且时间复杂度为O(logn)，方案2完。 参考技术A 用位图法
用一亿个bit来标记一个数是否出现。
比如出现了数字1024，那么就把1024位置1.
从1到一亿扫描，没有标记1的就是缺少的数字。
100000000/1024/1024=95.367431640625
不到96MB的内存
一个int类型占32bit，需要3125000大小的int数组
时间复杂度是O(一百万)+O(一亿)本回答被提问者和网友采纳 参考技术B 一个建议，对一百万个数排序，或者找出最小和最大的，确定一百万个数的范围应该会快点 参考技术C 用位图法,用一亿个bit来标记一个数的出现，一个int类型占32bit，需要3125000大小的int数组即可解决。
位图法：所谓位图法（bitmap），就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。 参考技术D 先快速排序啊，再确定范围