bigInt help

This is a discussion on bigInt help within the C++ Programming forums, part of the General Programming Boards category; HI, im working on this code which is going to be tested with only positive numbers. I am having trouble ...

  1. #1
    Registered User
    Join Date
    Mar 2003
    Posts
    134

    bigInt help

    HI, im working on this code which is going to be tested with only positive numbers. I am having trouble with the overloaded + and *, it gives my an error and closes the program down. Is there anything wrong with them or something else has to be fixed???
    thanks in advance.

    bigInt.h
    Code:
    //class bigInt implements big integers by storing the digits of a big
    //integer in a private vector data member called digit. Since it uses a
    //vector the size of the big integer can be indefinitely large. This class 
    //implements input/output of bigInts, addition/multiplication/pre-increment 
    //of bigInts, assignment of a bigInt or long int to a bigInt and ==/< 
    //comparison of bigInts. The operators addition/multiplication/pre-increment/<
    //only work for big integers >= 0. By adding additional code they could be 
    //made to work for negative big integers also.
    #ifndef _bigInt_h
    #define _bigInt_h
    
    #include <iostream>
    #include <vector>
    #include <string>
    
    using namespace std;
    
    class bigInt
    {
    public:
        bigInt();                //default constructor, defined
        bigInt(long int k);      //construct bigInt with value like k, defined
        bigInt(const string& s); //construct bigInt with value like string s ,defined
        
        void print(ostream& os) const; //function to output a bigInt, defined
        void read(istream& is);        //function to input a bigInt, defined
    
        bigInt operator+(const bigInt& bi2) const;  //overloads + operator
        bigInt operator*(const bigInt& bi2) const;  //overloads * operator
        bigInt& operator++();                       //overloads pre-increment op, defined
       
        const bigInt& operator=(const bigInt& bi2);  //copy assignment operator, defined
        const bigInt& operator=(long int i);  //converts i to bigInt and assigns
        
            //overload comparison operators
        bool operator==(const bigInt& bi2) const; //defined
        bool operator<(const bigInt& bi2) const;//defined
          
    private:
        char sign;         //stores the sign '+' or '-'. Not really 
                           //needed in this program because you only have 
                           //to handle positive numbers (numbers >= 0), but
                           //would be needed in a complete program.
        vector<int> digit; //vector to store digits of a bigInt with
                           //one digit in each element of the vector.
                           //A more efficient version of the program
                           //would store several digits in each element.
                           //digit[0] is the 1's digit, digit[1] is the 10's
                           //digit, digit[2] is the 100's digit, etc.
                           
        void convertString(const string& s); //converts string into bigInt 
                                             //representaion., defined
     };   
        
        //overloads << and >> operators as non-member functions using
        //public member functions print and read.
    ostream& operator<<(ostream& os, const bigInt& bi); //defined
    istream& operator>>(istream& is, bigInt& bi);//defined
    
    #endif
    bigInt.cpp
    Code:
    #include <iostream>
    #include <string>
    #include <cctype>
    #include <cstdlib>
    
    #include "bigInt.h"
    
    using namespace std;
    
    bigInt::bigInt()
    {
    }
    
    bigInt::bigInt(long int i)
    /*this function should determine whether i is positive or
         negative and set the sign accordingly. It then extracts
         the digits from i and stores them in the vector digit.
         This can be done by nextdigit = i % 10; i = i / 10; For
         example if i is 456 then nextdigit = 456 % 10; sets 
         nextdigit to 6 and i = i / 10; sets i to 45 so i is ready 
         to have the next digit extracted.
       */
    {
    	long int nextdigit;
    	if(i < 0) 
    	{
    		sign = '-';
    		i=abs(i);
    	}
    	else sign='+';
    
    	while(i != 0)
    	{
    		nextdigit=i % 10;
    		digit.push_back(nextdigit);
    		i=i/10;
    		
    	}
    
    }
    
    bigInt::bigInt(const string& s)
    {  convertString(s);
    }
    
    void bigInt::print(ostream& os) const
    {  int k;
       
        os<<sign;
        for(k = digit.size() - 1; k >= 0; k--) //print right to left  
           os<<digit[k];                       //high order digits first
    }
    
    void bigInt::read(istream& is)
    {  string s;
    
       is>>s;
       convertString(s);
    }
    
    bigInt& bigInt::operator++() //++ only works correctly for positive bigInts
    { int i, sum, newdigit, carry;
      
      sum = digit[0] + 1;
      newdigit = sum % 10;
      carry = sum / 10;
      digit[0] = newdigit;
      i = 1;
      while(i < digit.size() && carry != 0)
      {  sum = digit[i] + carry;
         newdigit = sum % 10;
         carry = sum / 10;
         digit[i] = newdigit;
         i++;
      }
      if (carry != 0) digit.push_back(carry);
      return *this;
    }
    
    void bigInt::convertString(const string& s)
    {  int j, k, nextdigit;
       
       if (s[0] == '+' || s[0] == '-')
       {   sign = s[0];
           k = 1; //process from subscript 1 so sign not considered again
       }
       else
       {   sign = '+';  //no sign in string then positive number
           k = 0;       //no sign so process from subscript 0
       }
       
       digit.resize(0); //resize the vector digit to 0
       for(j = s.size() - 1; j >= k; j--) //process digits in string from right 
          if (isdigit(s[j]))              //to left - low order digits first
          {  nextdigit = s[j] - '0'; //convert character digit to int
             digit.push_back(nextdigit);
          }
          else
          {  cerr<<"Bad string argument for convertString function"<<endl;
             cin.get(); cin.get(); //to pause console i/o screen
             exit(1);
          }
    }
    
    ostream& operator <<(ostream& os, const bigInt& bi)
    {
    	bi.print(os);
    	return os;
    }
    
    istream& operator >>(istream& is, bigInt& bi)
    {
    	bi.read(is);
    	return is;
    }
    
    bigInt bigInt::operator *(const bigInt& bi2)const
    {
    	int mul;
    	int carry=0;
    	int k;
    	int len=this->digit.size();
    	bigInt tem;
    
    	if(len < bi2.digit.size())len=bi2.digit.size();
    
    	for(k=0;k<len;k++)
    	{
    		mul=this->(digit[k]*bi2.digit[k])+carry;
    		carry=sum/10;
    		mul=mul%10;
    		tem.digit.push_back(mul);
    
    	}
    	if(carry != 0)tem.digit.push_back(carry);
    
    	return temp;
    }
    
    bigInt bigInt::operator +(const bigInt& bi2)const
    {
    	int sum;
    	int carry=0;
    	int k;
    	int len=this->digit.size();
    	bigInt temp;
    
    	if(len < bi2.digit.size())len=bi2.digit.size();
    
    	for(k=0;k < len; k++)
    	{
    		sum=this->digit[k]+bi2.digit[k]+carry;
    		carry=sum/10;
    		sum=sum%10;
    		temp.digit.push_back(sum);
    	}
    	if(carry != 0)temp.digit.push_back(carry);
    	return temp;
    }
    
    const bigInt& bigInt::operator =(long int i)
    {
    	bigInt temp(i);
    	int k=0;
    
    	this->digit.resize(0);
    
    	while(k < temp.digit.size())
    	{
    		this->digit[k]=temp.digit[k];
    		k++;
    	}
    	return *this;
    
    
    
    }
    
    const bigInt& bigInt::operator =(const bigInt& bi2)
    {
    	int i=0;
    
    	while(i < this->digit.size())
    	{
    		this->digit.pop_back();
    		i++;
    	}
    	this->digit.resize(0);
    	i=0;
    
    	while(i < bi2.digit.size())
    	{
    		this->digit[i]=bi2.digit[i];
    		i++;
    	}
    	return *this;
    }
    
    bool bigInt::operator ==(const bigInt& bi2)const
    {
    	bool isIT=false;
    	
    	
    	if( bi2.digit.size() == this->digit.size() )
    	{	
    		for(int i=0; i < this->digit.size();i++)
    		{
    			if(bi2.digit[i] != this->digit[i])return isIT; 
    		}
    		isIT=true;
    
    	}
    
    	return isIT;;
    
    }
    
    bool bigInt::operator < (const bigInt& bi2)const
    {
    	bool isIt=false;
    
    	if(this->digit.size() != bi2.digit.size())return( this->digit.size() < bi2.digit.size());
    
    	for(int i=0;i < this->digit.size();i++)
    	{
    		if(this->digit[i] < bi2.digit[i])return isIt=true;
    	}
    	return isIt;
    
    
    }
    testbigInt.cpp
    Code:
    #include <iostream>
    #include "bigInt.h"
    
    int main()
    {  
    	bigInt bi1/*("+19999999999999999999999999999999999")*/(9000), bi2;
    	
    
    
       
       ++bi1;
       bi1.print(cout);
       cout<<endl;
       cout<<"Enter a bigInt: ";
       bi2.read(cin);
       ++bi2;
       bi2.print(cout);
       cout<<endl;
       bi2.print(cout);
       cout<<endl;
       cin.get();
       cin.get();  
       return 0;
    }

  2. #2
    carry on JaWiB's Avatar
    Join Date
    Feb 2003
    Location
    Seattle, WA
    Posts
    1,972
    Probably the best thing to do is run it through a debugger to find the line that gives you the problem...If you don't know how to use a debugger, its probably a good idea to learn
    "Think not but that I know these things; or think
    I know them not: not therefore am I short
    Of knowing what I ought."
    -John Milton, Paradise Regained (1671)

    "Work hard and it might happen."
    -XSquared

  3. #3
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    well it is the + and *, but i cant seem to understand why the code would go wrong.

  4. #4
    Registered User jlou's Avatar
    Join Date
    Jul 2003
    Posts
    1,088
    I think you should reread JaWiB's advice - the debugger would help you here.

    Meanwhile, one of things I noticed about those methods is how you set len. You set len to be the number of digits in the bigger number. You then access both vectors all the way up to the "len"th digit. Do you see what is wrong there?

    For example, if this = 436254 and bi2 = 31, then you'd access bi2.digits[0] through bi2.digits[5].

    Hope that helps.

  5. #5
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    i just had the same thought, ill try to modify it and im guessing the operator + might need 3 parts, once when this has more numbers, once when bi2 has more numbers and once when the numbers have the same length.

    Any ideas abt the multiplication?

  6. #6
    End Of Line Hammer's Avatar
    Join Date
    Apr 2002
    Posts
    6,231
    >>mul=this->(digit[k]*bi2.digit[k])+carry;
    You don't need the "this" pointer to access local variables.
    >>mul=(digit[k]*bi2.digit[k])+carry;

    In the operator* function, you've spelt temp wrong.
    When all else fails, read the instructions.
    If you're posting code, use code tags: [code] /* insert code here */ [/code]

  7. #7
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    okay, i modified the operator + function to this and it works now. But im still scratching my head over the operator *...any hinters?:-

    Code:
    int sum;
    	int carry=0;
    	int k;
    	int len=digit.size();
    	bigInt temp;
    
    	if(digit.size() == bi2.digit.size())//this addition to take place if both numbers are of equal length.
    	{
    
    		for(k=0;k < len; k++)
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}//end of code for addition if both numbers are equal.
    
    	if(digit.size() < bi2.digit.size())//if this has fewer numbers
    	{
    		for(k=0;k < digit.size();k++)//this loop will go on till the one with fewer numbers will be exhausted
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		for(k=digit.size();k<bi2.digit.size();k++)//this will work on the left over digits of the big digit.
    		{
    			sum=bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}
    
    	if(bi2.digit.size() < digit.size())//if bi2 is the smaller number, then it will be on the bottom.
    	{
    		
    		for(k=0;k<bi2.digit.size();k++)
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		for(k=bi2.digit.size();k<digit.size();k++)//this will work on the left over digits of big int.
    		{
    			sum=digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}
    
    
    
    	temp.sign='+';
    	return temp;

  8. #8
    Registered User jlou's Avatar
    Join Date
    Jul 2003
    Posts
    1,088
    You'll probably want to re-post the operator* as you have it now. I assume you fixed the same length problem in there as you did in operator+. If not, then fix that first and then see if you are still having troubles.

    Also, as posted the operator* shouldn't even compile (uses undeclared sum variable), so try to make sure that what you post at least compiles.

  9. #9
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    This is the code that compiles.

    bigInt2.cpp

    Code:
    #include <iostream>
    #include <string>
    #include <cctype>
    #include <cstdlib>
    
    #include "bigInt.h"
    
    using namespace std;
    
    bigInt::bigInt()
    {
    }
    
    bigInt::bigInt(long int i)
    /*this function should determine whether i is positive or
         negative and set the sign accordingly. It then extracts
         the digits from i and stores them in the vector digit.
         This can be done by nextdigit = i % 10; i = i / 10; For
         example if i is 456 then nextdigit = 456 % 10; sets 
         nextdigit to 6 and i = i / 10; sets i to 45 so i is ready 
         to have the next digit extracted.
       */
    {
    	long int nextdigit;
    	if(i < 0) 
    	{
    		sign = '-';
    		i=abs(i);
    	}
    	else sign='+';
    
    	while(i != 0)
    	{
    		nextdigit=i % 10;
    		digit.push_back(nextdigit);
    		i=i/10;
    		
    	}
    
    }
    
    bigInt::bigInt(const string& s)
    {  convertString(s);
    }
    
    void bigInt::print(ostream& os) const
    {  int k;
       
        os<<sign;
        for(k = digit.size() - 1; k >= 0; k--) //print right to left  
           os<<digit[k];                       //high order digits first
    }
    
    void bigInt::read(istream& is)
    {  string s;
    
       is>>s;
       convertString(s);
    }
    
    bigInt& bigInt::operator++() //++ only works correctly for positive bigInts
    { int i, sum, newdigit, carry;
      
      sum = digit[0] + 1;
      newdigit = sum % 10;
      carry = sum / 10;
      digit[0] = newdigit;
      i = 1;
      while(i < digit.size() && carry != 0)
      {  sum = digit[i] + carry;
         newdigit = sum % 10;
         carry = sum / 10;
         digit[i] = newdigit;
         i++;
      }
      if (carry != 0) digit.push_back(carry);
      return *this;
    }
    
    void bigInt::convertString(const string& s)
    {  int j, k, nextdigit;
       
       if (s[0] == '+' || s[0] == '-')
       {   sign = s[0];
           k = 1; //process from subscript 1 so sign not considered again
       }
       else
       {   sign = '+';  //no sign in string then positive number
           k = 0;       //no sign so process from subscript 0
       }
       
       digit.resize(0); //resize the vector digit to 0
       for(j = s.size() - 1; j >= k; j--) //process digits in string from right 
          if (isdigit(s[j]))              //to left - low order digits first
          {  nextdigit = s[j] - '0'; //convert character digit to int
             digit.push_back(nextdigit);
          }
          else
          {  cerr<<"Bad string argument for convertString function"<<endl;
             cin.get(); cin.get(); //to pause console i/o screen
             exit(1);
          }
    }
    
    ostream& operator <<(ostream& os, const bigInt& bi)
    {
    	bi.print(os);
    	return os;
    }
    
    istream& operator >>(istream& is, bigInt& bi)
    {
    	bi.read(is);
    	return is;
    }
    
    bigInt bigInt::operator *(const bigInt& bi2)const
    {
    	const int prodsize=bi2.digit.size()+digit.size()+1;
    	bigInt temp;
    	temp.digit.resize(prodsize);
    
    	unsigned long int x;
    	int iplusj;
    
    	for(int i=0; i < digit.size(); i++)
    	{
    		for(int j=0; j < bi2.digit.size(); j++)
    		{
    			x=bi2.digit[j]*digit[i];
    			iplusj=i+j;
    			temp.digit[iplusj]+=x%10;
    			temp.digit[iplusj+1]=temp.digit[iplusj]/10 +x/10+ temp.digit[iplusj+1];
    			temp.digit[iplusj]%=10;
    		}
    	}
    
    for( int g= temp.digit.size()-1; g>=0; g--)
    	{
    		if(temp.digit[g]==0)temp.digit.pop_back();
    
    		else if(temp.digit[g]>0)break;
    
    	}
                    
    	
    	temp.sign='+';
    
    	return temp;
    
    	
    
    }
    
    bigInt bigInt::operator +(const bigInt& bi2)const//works only for both numbers positive.
    {
    	int sum;
    	int carry=0;
    	int k;
    	int len=digit.size();
    	bigInt temp;
    
    	if(digit.size() == bi2.digit.size())//this addition to take place if both numbers are of equal length.
    	{
    
    		for(k=0;k < len; k++)
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}//end of code for addition if both numbers are equal.
    
    	if(digit.size() < bi2.digit.size())//if this has fewer numbers
    	{
    		for(k=0;k < digit.size();k++)//this loop will go on till the one with fewer numbers will be exhausted
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		for(k=digit.size();k<bi2.digit.size();k++)//this will work on the left over digits of the big digit.
    		{
    			sum=bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}
    
    	if(bi2.digit.size() < digit.size())//if bi2 is the smaller number, then it will be on the bottom.
    	{
    		
    		for(k=0;k<bi2.digit.size();k++)
    		{
    			sum=digit[k]+bi2.digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		for(k=bi2.digit.size();k<digit.size();k++)//this will work on the left over digits of big int.
    		{
    			sum=digit[k]+carry;
    			carry=sum/10;
    			sum=sum%10;
    			temp.digit.push_back(sum);
    		}
    		if(carry != 0)temp.digit.push_back(carry);
    	}
    
    
    
    	temp.sign='+';
    	return temp;
    }
    
    const bigInt& bigInt::operator =(long int i)
    {
    	 int k=0;
    	int nextdigit;
    
    	digit.erase(this->digit.begin(), this->digit.end());
    
        while(i != 0)
    	{
    		nextdigit=i % 10;
    		digit.push_back(nextdigit);
    		i=i/10;
    	}
    
    	return *this;
    	
         
     
    }
    
    const bigInt& bigInt::operator =(const bigInt& bi2)
    {
    	int size = bi2.digit.size(); // get vector size    
    	digit.erase(this->digit.begin(), this->digit.end()); // erase current vector
         this->digit.resize(size); // set new vector size
         for(int i= 0; i < size; i++)
         {
              this->digit[i]=bi2.digit[i];
         }
    	 this->sign='+';
         return *this;
    }
    
    bool bigInt::operator ==(const bigInt& bi2)const
    {
    	bool isIT=false;
    	
    	
    	if( bi2.digit.size() == this->digit.size() )
    	{	
    		for(int i=0; i < this->digit.size();i++)
    		{
    			if(bi2.digit[i] != this->digit[i])return isIT; 
    		}
    		isIT=true;
    
    	}
    
    	return isIT;;
    
    }
    
    bool bigInt::operator < (const bigInt& bi2)const
    {
    	bool isIt=false;
    
    	if(this->digit.size() != bi2.digit.size())return( this->digit.size() < bi2.digit.size());
    
    	for(int i=0;i < this->digit.size();i++)
    	{
    		if(this->digit[i] < bi2.digit[i])return isIt=true;
    	}
    	return isIt;
    
    
    }
    testbigInt.cpp
    Code:
    #include <iostream>
    #include "bigInt.h"
    
    int main()
    {  bigInt bi1, bi2("99999999999999999999999999999999"), bi3(7777777);
       
       cout<<"bi2 = "<<bi2<<endl;
       cout<<"bi3 = "<<bi3<<endl;
       bi1 = bi2 + bi3;
       cout<<"sum = "<<bi1<<endl;
       bi1 = bi2 * bi3;
       cout<<"product = "<<bi1<<endl;
       cout<<"Enter a bigInt: ";
       cin>>bi1;  //enter as input for this 9876543210
       cout<<"input value = "<<bi1<<endl;
       if(!(bi1 == bi2)) cout<<"bi1 != bi2"<<endl;
       bi2 = bi1;
       if(bi1 == bi2) cout<<"bi1 == bi2"<<endl;
       bi1 = 1;
       bi3 = 31;
       for(bi2 = 2; bi2 < bi3; ++bi2)
          bi1 = bi1 * bi2;
       cout<<"factorial of 30 = "<<bi1<<endl;
       cin.get(); cin.get();  //to pause console i/o screen
                              //press enter key 1 or 2 times to end
       return 0;
    }
    bigInt.h
    Code:
    //class bigInt implements big integers by storing the digits of a big
    //integer in a private vector data member called digit. Since it uses a
    //vector the size of the big integer can be indefinitely large. This class 
    //implements input/output of bigInts, addition/multiplication/pre-increment 
    //of bigInts, assignment of a bigInt or long int to a bigInt and ==/< 
    //comparison of bigInts. The operators addition/multiplication/pre-increment/<
    //only work for big integers >= 0. By adding additional code they could be 
    //made to work for negative big integers also.
    #ifndef _bigInt_h
    #define _bigInt_h
    
    #include <iostream>
    #include <vector>
    #include <string>
    
    using namespace std;
    
    class bigInt
    {
    public:
        bigInt();                //default constructor, defined
        bigInt(long int k);      //construct bigInt with value like k, defined
        bigInt(const string& s); //construct bigInt with value like string s ,defined
        
        void print(ostream& os) const; //function to output a bigInt, defined
        void read(istream& is);        //function to input a bigInt, defined
    
        bigInt operator+(const bigInt& bi2) const;  //overloads + operator
        bigInt operator*(const bigInt& bi2) const;  //overloads * operator
        bigInt& operator++();                       //overloads pre-increment op, defined
       
        const bigInt& operator=(const bigInt& bi2);  //copy assignment operator, defined
        const bigInt& operator=(long int i);  //converts i to bigInt and assigns
        
            //overload comparison operators
        bool operator==(const bigInt& bi2) const; //defined
        bool operator<(const bigInt& bi2) const;//defined
          
    private:
        char sign;         //stores the sign '+' or '-'. Not really 
                           //needed in this program because you only have 
                           //to handle positive numbers (numbers >= 0), but
                           //would be needed in a complete program.
        vector<int> digit; //vector to store digits of a bigInt with
                           //one digit in each element of the vector.
                           //A more efficient version of the program
                           //would store several digits in each element.
                           //digit[0] is the 1's digit, digit[1] is the 10's
                           //digit, digit[2] is the 100's digit, etc.
                           
        void convertString(const string& s); //converts string into bigInt 
                                             //representaion., defined
     };   
        
        //overloads << and >> operators as non-member functions using
        //public member functions print and read.
    ostream& operator<<(ostream& os, const bigInt& bi); //defined
    istream& operator>>(istream& is, bigInt& bi);//defined
    
    #endif
    Last edited by noob2c; 10-10-2003 at 07:04 PM.

  10. #10
    Registered User jlou's Avatar
    Join Date
    Jul 2003
    Posts
    1,088
    You still haven't fixed the same length problem that you fixed in the operator+. In your operator*, what if bi2's length is smaller than this?

  11. #11
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    im trying to figure out the algorithm for any case, then i can make the modifications like i did for the addition.

  12. #12
    Registered User jlou's Avatar
    Join Date
    Jul 2003
    Posts
    1,088
    Code:
          34693
        x 52627
    -----------
         242851
        0693860
       20815800
      069386000
     1734650000
    -----------
     1825788511
    Does that help?

    And by the way, make sure you fix the typo in the operator* where it sets the sign to '+'.

  13. #13
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    is my program outputting the wrong factorial of 30?
    Last edited by noob2c; 10-10-2003 at 07:04 PM.

  14. #14
    Registered User jlou's Avatar
    Join Date
    Jul 2003
    Posts
    1,088
    ??

    The example multiplication problem was meant to give you an idea of how to change your algorithm. Notice how when you multiply two numbers, you don't just multiply the first digit of each number, then the second digit of each number, etc.

    Instead, you multiply the first digit of the Second Number with each digit of the First Number (line 1). Then do the same for the second digit but add a 0 to the end of the result (in blue). Continue to do this for each digit of the Second Number, adding an extra 0 every time, then add the results together for the correct product.
    Code:
          34693    <---- First Number
        x 52627    <---- Second Number
    -----------
         242851    <---- Line 1
        0693860 <---- Line 2
       20815800 <---- Line 3
      069386000 <---- Line 4
     1734650000 <---- Line 5
    -----------
     1825788511    <---- Line 6
    I think that would help you think of one way to fix your algorithm. You would have to have two loops, one for each digit of the Second Number and one for each digit of the First Number. You also might want to make the number with fewer digits the second number, although it might not matter. Finally, I would consider adding the result of the current iteration to your temp variable for each digit in the outer loop.

    Does that make sense?

  15. #15
    Registered User
    Join Date
    Mar 2003
    Posts
    134
    yeah i did another thing, i added this line of code after after is done which removes all the 0's

    Code:
    for( int g= temp.digit.size()-1; g>=0; g--)
    	{
    		if(temp.digit[g]==0)temp.digit.pop_back();
    
    		else if(temp.digit[g]>0)break;
    
    	}

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. HugeInt (BigInt) optimization
    By LuckY in forum C++ Programming
    Replies: 2
    Last Post: 11-16-2004, 10:44 AM
  2. BigInt Linked List Long Division
    By abyssknight in forum C Programming
    Replies: 5
    Last Post: 04-01-2004, 06:02 PM
  3. large numbers
    By Alextheking in forum C++ Programming
    Replies: 13
    Last Post: 01-09-2004, 02:51 PM
  4. Program error
    By LouB in forum C++ Programming
    Replies: 5
    Last Post: 02-23-2003, 06:04 PM
  5. Help w/adjustment to program
    By LouB in forum C++ Programming
    Replies: 5
    Last Post: 02-16-2003, 06:23 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21