Question

2 3 4 // do not add more #includes. #include <string> #include <Cassert > #include <algorithm» 6 #include <vector» 7 #include <iostream> 8 9 using namespace std; 18 IIThe class LargeNumber is used to add and multiply large values up to hundreds of digits and/or more. 11 12 13 class LargeNumber 14 15 private: 16 17 18 public: 19 20 21 Post condition: construct a "LargeNumber" with value of e LargeNumber() { 23 24 25 26 27 28 29 // Pre condition: // n greater than or equal to θ, if not return /Post-condition: constructs new "LargeNumber" with a value of n 31 32 LargeNumber(int n) { 34 35 36 37 38 39 40 Pre condition: sconsists of 1, or more, digit characters, if not return Post condition construct a "LargeNumber" representation of str such that this->to_string) str LargeNumber(const string& str) { 42 43 45 /Post condition:

I am writing a class that can multiply and add very large values with hundreds and thousands of digits in C++. Cannot add any more #includes

Please implement with array of size 1000

Answer 1

#include <iostream>
#include <cassert>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

class LargeNumber {
private:
   int digits[1000];               // digits are stored in for operational convenience
public:
   LargeNumber() {
       for (int i = 0; i < 1000; i++)            //default constructor initializes all digits to 0
           digits[i] = 0;
   }

   LargeNumber(int n) {
       if (n < 0)
           for (int i = 0; i < 1000; i++)
               digits[i] = 0;
       else
       {
           int i = 0;
           while (n)                                // adds digits of n in reverse order to the biginning of array
           {
               digits[i++] = n % 10;
               n /= 10;
           }
           for (; i < 1000; i++)                       // assigns the rest of the array as 0
               digits[i] = 0;
       }
   }

   LargeNumber(const string& str) {
       bool isValid = true;
       for (int i = 0; i < str.length(); i++)        // checks if the string is a number
       {
           if (str[i] < '0' || str[i] > '9')
           {
               isValid = false;
               break;
           }
       }
       if (isValid)
       {
           int i = 0;
           for (int j = str.length() - 1; j >= 0; j--)     // store digits in reverse order
               digits[i++] = str[j] - 48;               // 48 is subtracted to convert '0' to number 0 (ASCII value of '0' is 48)
           for (; i < 1000; i++)       //initialize rest to 0
               digits[i] = 0;
       }
   }

   LargeNumber(const LargeNumber& other) {
       string str = other.to_string();            //since array of other is private we have to get the string form
       int i = 0;
       for (int j = str.length() - 1; j >= 0; j--)     //remaining procedure is similar to string parameter constructor
           digits[i++] = str[j] - 48;
       for (; i < 1000; i++)
           digits[i] = 0;

   }

   int num_digits() const {
       int i = 999;
       while (i >= 0 && digits[i] == 0)   // starts to check from 1000 for non zero nos., the first non-zero index is no. of digits
           i--;
       return i + 1;
   }

   bool is_zero() const {
       return num_digits() == 0;    //checks if no. of digits is zero which implies that number is zero
   }

   LargeNumber operator+(const LargeNumber& a) const {
       int carry = 0;                                    // number to store the carry over value
       int l1 = num_digits();
       int l2 = a.num_digits();
       string str = a.to_string();                    //get second parameter as string and reverse it
       for (int i = 0; i < str.length() / 2; i++)
       {
           char t = str[str.length() - i - 1];
           str[str.length() - i - 1] = str[i];
           str[i] = t;
       }
       string ans;
       int i = 0;
       for (; i < l2; i++)
       {
           int sum = digits[i] + (str[i] - 48) + carry;              //sum is digit of one num + second num + carry over
           carry = sum / 10;                                             // rest is carried over
           ans += (sum % 10) + 48;                                  //one digit is stored
       }
       for (; i < l1; i++)
       {
           int sum = digits[i] + carry;
           carry = sum / 10;
           ans += (sum % 10) + 48;
       }
       if (carry != 0)
           ans += carry + 48;
       for (int i = 0; i < ans.length() / 2; i++)                      //reverse the answer string for constructor use
       {
           char t = ans[ans.length() - i - 1];
           ans[ans.length() - i - 1] = ans[i];
           ans[i] = t;
       }
       LargeNumber S(ans);             //make a LargeNumber using ans
       return S;                                //return it
   }

   LargeNumber operator*(const LargeNumber& a) const {
       int l1 = num_digits();
       int l2 = a.num_digits();
       string str = a.to_string();                          // get string from a
       for (int i = 0; i < str.length() / 2; i++)          //reverse it
       {
           char t = str[str.length() - i - 1];
           str[str.length() - i - 1] = str[i];
           str[i] = t;
       }
       string *addends = new string[l1];       //an array of string to store product of each digit of 1st no. with whole of 2nd no.
       for (int i = 0; i < l1; i++)
       {
           int carry = 0;                           //calculate product for each digit of 1st no.
           for (int j = 0; j < i; j++)              //add the ending zeros
           {
               addends[i] += '0';
           }
           for (int j = 0; j < l2; j++)              //find the product
           {
               int sum = carry + (str[j] - 48) * digits[i];
               addends[i] += sum % 10 + 48;
               carry = sum / 10;
           }
           while (carry)              //append the carry
           {
               addends[i] += carry % 10 + 48;
               carry /= 10;
           }
       }
       LargeNumber ans;          // to store final answer
       for (int i = 0; i < l1; i++)
       {
           for (int j = 0; j < addends[i].length() / 2; j++)            //reverse the string to pass to constructor
           {
               char t = addends[i][addends[i].length() - j - 1];
               addends[i][addends[i].length() - j - 1] = addends[i][j];
               addends[i][j] = t;
           }
           ans = ans + LargeNumber(addends[i]);          //add each part to ans
       }
       return ans;          //return ans
   }

   string to_string() const {
       string str;
       for (int i = num_digits() - 1; i >= 0; i--)             //since digits are stored in reverse order append nos. from the back
       {
           str += digits[i] + 48;
       }
       return str;   //return answer
   }
};