CBE - Mini-Course - Data Structures - Project (Huge Integer).png

docker.tar.gz

Huge-integer

Manipulating large numbers is a vital tool that is essential across various domains. The challenge arises because the primitive data types provided by C++ cannot handle such large numbers.

You will address this challenge by crafting your HugeInt class in this course. This class has several constructors and assignment operators to facilitate efficient deep copying and features a comprehensive set of arithmetic operations. This class is designed to serve as a backbone for various application developments, providing a practical solution to the complexities posed by large integers.

The course will delve into the transformation of object-oriented programming (OOP) design into abstract data types (ADT). Additionally, you’ll explore the critical aspect of efficiency in designing libraries, emphasizing its significance in developing large-scale applications. By the end, you’ll possess the skills to create efficient and adaptable libraries that adhere to object-oriented principles.

Implementing an Advanced Huge Integer Class

#include "HugeInt.h"
#include<string>
using namespace std;
HugeInt HugeInt::add(const HugeInt& I2) const
{   
    HugeInt R(this->size + 1); 
    int carry = 0; 

    for (int i = 0; i < R.size; i++)
    {
        int s = (*this)[i] + I2[i] + carry; 
        R[i] = s % 10; 
        carry = s / 10; 
    }

    // Add the trim function call here
    return R;
}
HugeInt HugeInt::sub(const HugeInt& I2) const
{
    HugeInt R(this->size); 
    int carry = 0; 

    for (int i = 0; i < R.size; i++)
    {
        int s = (*this)[i] - I2[i] - carry; 
        if (s < 0) 
        {
            s += 10; 
            carry = 1; 
        }
        else
        {
            carry = 0; 
        }
        R[i] = s; 
    }

    // Add the trim function here
    return R;
}
void HugeInt::trim()
{
    // Write your code here
}
bool HugeInt::isLess(const HugeInt& I2)const
{
    // Write your code here
}
bool HugeInt::isGreater(const HugeInt& I2)const
{
    // Write your code here
}
bool HugeInt::isEqual(const HugeInt& I2)const
{
    // Write your code here
}



#include<fstream>
#include<string>
#include<iostream>
using namespace std;
class HugeInt
{
    bool isNeg;
    int size;
    int *Ds;
public:
    HugeInt(int s);

    // Prototypes added
    void trim();
    bool isLess(const HugeInt& I2)const;
    bool isGreater(const HugeInt& I2)const;
    bool isEqual(const HugeInt& I2)const;
    
    int operator[](int i)const;
    int& operator[](int i);
    HugeInt add(const HugeInt& I2)const;
    HugeInt sub(const HugeInt& I2)const;
    HugeInt(string s);
    friend ostream& operator<<(ostream&, const HugeInt& I);
};




















#include "HugeInt.h"
int main()
{
    HugeInt** Is; int noOfHugeIs;
    ifstream Rdr("HIs.txt");
    Rdr>>noOfHugeIs; // Read the total number of integers
    Rdr.ignore();
    Is = new HugeInt * [noOfHugeIs];
    for(int i=0; i<noOfHugeIs; i++)
    {
        string s;
        Rdr>>s;
        Is[i]= new HugeInt(s);
    }   
    for(int i=0; i<noOfHugeIs; i++)
        cout<<*Is[i]<<endl;  // print all integers

    // Trim your numbers and perfrom comparison

    Is[0]->trim();
    cout << *Is[0] << endl; 
    
    if ((*Is[0]).isLess(*Is[1]))
        cout <<"H1 is quantity-wise less than H2 "<< endl;
    else
        cout <<"H2 is quantity-wise less than H1 "<< endl;
    
    return 0;
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

# Comparison

In comparison, we’ll implement the following:
- Less than
- Greater than
- Equal to

Before moving towards the implementation, let's discuss a small issue that might arise when comparing two numbers. Consider the scenario where we have two numbers:
```text
Number 1: 1234
Number 2:  234
```
Which of these two numbers is greater when compared based on their respective number of digits? Since $1234$ has a length of four and $234$ has a length of three, we can say that $1234$ is the bigger number. However, what if the second number has two leading zeros, making it look like this:
```text
Number 1:  1234
Number 2: 00234
```
In this case, can we say that the second number is greater because it has a length of five? 

We can’t because we shouldn’t consider the leading zeros in the comparison. To address this issue, we need to write a `trim()` function that removes the leading zeros before any comparison takes place.

## Exercise 1: Writing the `trim()` function

Write the code for the `trim()` member function in `HugeInt` to remove the leading zeros from the number in [your implementation](#Your-implementation). Look at `main()` to understand how the function is called.

Here's the sample input:
```text
00234
```
Here's the sample output:
```text
234
```

If you're stuck, click the “Show Solution” button.

__default

Comparison

Your implementation

Comparison