Question

Write a C++ program which performs +, -, *, / and $ on hexadecimal operands. The

maximum length of any operand or a solution is 40 digits. The input will be in the

following format:

Op1 op op2 =

There is no space between operands and operator.

Note

5/2 = quotient 2, remainder 1

2$3 = 8

The output should be of the form

2*3=6.

Read date from a file.

TEST DATA (input.txt):

AAAA+BBF=

BFD+2DE=

100*AA=

100$5=

100/F=

10000000000000-1=

AAAAABBBBBCCCCCDDDDDEEEEEFFFFF-ABCDEF0123456789ABCDEF=

FACDFDB1/45CDF521=

I am posting code below that I tried but It is not working like they want in output please can someone help me out with this. When you test this program you can see the output in output file.

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct brokenString {
   string leftOp;
   string rightOp;
};

int hexToDec(char);
string decToHex(int, string&);
brokenString splitUpString(string);
string addition(brokenString);
string subtraction(brokenString);
string multiplication(brokenString);
string division(brokenString);
string power(brokenString);

int main() {
   ifstream inputFile;
   ofstream outputFile;
   string equation;
   brokenString splitEquation;

   inputFile.open("input.txt");
   outputFile.open("output.txt");

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << addition(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << addition(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << multiplication(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << power(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << division(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << subtraction(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << subtraction(splitUpString(equation)) << endl;

   getline(inputFile, equation, '=');
   outputFile << equation << " = " << division(splitUpString(equation)) << endl;

   outputFile.close();
   inputFile.close();

   system("PAUSE");
   return 0;
}

int hexToDec(char value) {
   switch (value) {
   case 'A':
       return 10;
   case 'B':
       return 11;
   case 'C':
       return 12;
   case 'D':
       return 13;
   case 'E':
       return 14;
   case 'F':
       return 15;
   default:
       return atoi(&value);
   }
}

string decToHex(int value, string& convertedDec) {
   int remainder;
   string convertedReversed;

   remainder = value % 16;

   if (remainder > 9) {
       switch (remainder) {
       case 10:
           convertedDec.push_back('A');
           break;
       case 11:
           convertedDec.push_back('B');
           break;
       case 12:
           convertedDec.push_back('C');
           break;
       case 13:
           convertedDec.push_back('D');
           break;
       case 14:
           convertedDec.push_back('E');
           break;
       case 15:
           convertedDec.push_back('F');
           break;
       }
   }
   else {
       convertedDec.push_back('0' + remainder);
   }

   if (value / 16)
       return decToHex(value / 16, convertedDec);
   else
       for (int i = convertedDec.size() - 1; i > -1; i--) {
           convertedReversed.push_back(convertedDec[i]);
       }

   return convertedReversed;
}

brokenString splitUpString(string myString) {
   brokenString temp;
   int i = 0;

   while (myString[i] != '+' &&
       myString[i] != '-' &&
       myString[i] != '/' &&
       myString[i] != '*' &&
       myString[i] != '$')
   {
       if (myString[i] != '\n') {
           temp.leftOp.push_back(myString[i]);
       }
       i++;
   }

   i++;
   for (i; i < myString.size(); i++)
       temp.rightOp.push_back(myString[i]);

   return temp;
}

string addition(brokenString myEquation) {
   string output = "", dummy = "";
   int op1, op2;
   bool done = false;
   int i, j, sum, carry = 0;

   i = myEquation.leftOp.size() - 1;
   j = myEquation.rightOp.size() - 1;

   //cout << myEquation.leftOp[i] << endl << myEquation.rightOp[j] << endl;
   for (i; i > -1; i--) {
       op1 = hexToDec(myEquation.leftOp[i]);

       if (j < 0)
           op2 = 0;
       else
           op2 = hexToDec(myEquation.rightOp[j]);

       sum = op1 + op2 + carry;
       output.insert(0, decToHex(sum, dummy));

       if (dummy.size() > 1) {
           carry = 1;
           output.erase(output.begin());
       }
       else
           carry = 0;

       j--;
       dummy.clear();
   }
   if (carry == 1)
       output.insert(0, "1");
   return output;
}

string subtraction(brokenString myEquation) {
   string output;

   return output;
}

string multiplication(brokenString myEquation) {
   string output = "0";
   vector<string> products;
   int op2, counter = 0;
   brokenString tempProduct;
   int b = myEquation.leftOp.size();
   op2 = hexToDec(myEquation.rightOp[myEquation.rightOp.size() - 1]);

   for (int i = myEquation.rightOp.size() - 1; i > -1; i--) {
       for (int j = myEquation.leftOp.size() - 1; j > -1; j--) {
           tempProduct.rightOp = myEquation.leftOp[j];
           for (int k = 0; k < op2; k++) {
               tempProduct.leftOp = output;
               output = addition(tempProduct);
           }
       }
       op2 = hexToDec(myEquation.rightOp[i]);
   }

   /*for (int i=0; i < products.size(); i++) {
           tempProduct.leftOp = output;
           tempProduct.rightOp = products[i];
           output = addition(tempProduct);
   }*/

   return output;
}

string division(brokenString myEquation) {
   string output;

   return output;
}

string power(brokenString myEquation) {
   string output;

   return output;
}

Answer 1

We need to make one small change in your decToHex() function. It cannot to be recursive given the return value in your funciton is the reversed string. The point here is that the string must be reversed in the very end, when you do recursion, the string is reversed at every recursive funciton call. We will rectify this using a while loop instead pf recursive function call.

Our altered decToHex() functions is:

string decToHex(long value) {
int remainder;
string convertedDec;
string convertedReversed;

while(value>0)
{
remainder = value % 16;

if (remainder > 9) {
switch (remainder) {
case 10:
convertedDec.push_back('A');
break;
case 11:
convertedDec.push_back('B');
break;
case 12:
convertedDec.push_back('C');
break;
case 13:
convertedDec.push_back('D');
break;
case 14:
convertedDec.push_back('E');
break;
case 15:
convertedDec.push_back('F');
break;
}
}
else {
convertedDec.push_back('0' + remainder);
}
value /= 16;
}
for (int i = convertedDec.size() - 1; i > -1; i--) {
convertedReversed.push_back(convertedDec[i]);
}
return convertedReversed;
}

Everything else is fine. Now we will write the definition for functions performing hexadecimal arithmetic.

We will follow this algorithm for all our functions:
1.) convert the operands to decimal values

2.) perform the desired operation

3.) convert the result back to hexadecimal

string addition(brokenString myEquation) {
string output;
long op1, op2;
bool done = false;
int i, j;
long sum;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
op1=0;
op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}

//cout << myEquation.leftOp[i] << endl << myEquation.rightOp[j] << endl;
sum = op1+op2;
output = decToHex(sum);
return output;
}

string subtraction(brokenString myEquation) {
string output;
int i, j;
long diff;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
diff = op1-op2;
output = decToHex(diff);
return output;
}

string multiplication(brokenString myEquation) {
string output;
int i, j;
long mul;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}   
mul = op1*op2;
output = decToHex(mul);
return output;
}

string division(brokenString myEquation) {
string output;
int i, j;
long div;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
div = op1/op2;
output = decToHex(div);
return output;
}

string power(brokenString myEquation) {
string output;
int i, j;
long power;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
cout<<"\n"<<op1<<" "<<op2<<"\n";
power = pow(op1, op2);
cout<<power;
output = decToHex(power);
return output;
}

So those are our functions peforming hexadecimal arithmetic.

The entire program looks like:

#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

struct brokenString {
string leftOp;
string rightOp;
};

int hexToDec(char);
string decToHex(int, string&);
brokenString splitUpString(string);
string addition(brokenString);
string subtraction(brokenString);
string multiplication(brokenString);
string division(brokenString);
string power(brokenString);

int main() {
ifstream inputFile;
ofstream outputFile;
string equation;
brokenString splitEquation;

inputFile.open("input.txt");
outputFile.open("output.txt");

getline(inputFile, equation, '=');
outputFile << equation << " = " << addition(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << addition(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << multiplication(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << power(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << division(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << subtraction(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << subtraction(splitUpString(equation)) << endl;

getline(inputFile, equation, '=');
outputFile << equation << " = " << division(splitUpString(equation)) << endl;

outputFile.close();
inputFile.close();

system("PAUSE");
return 0;
}

int hexToDec(char value) {
switch (value) {
case 'A':
return 10;
case 'B':
return 11;
case 'C':
return 12;
case 'D':
return 13;
case 'E':
return 14;
case 'F':
return 15;
default:
return atoi(&value);
}
}

string decToHex(long value) {
int remainder;
string convertedDec;
string convertedReversed;

while(value>0)
{
remainder = value % 16;

if (remainder > 9) {
switch (remainder) {
case 10:
convertedDec.push_back('A');
break;
case 11:
convertedDec.push_back('B');
break;
case 12:
convertedDec.push_back('C');
break;
case 13:
convertedDec.push_back('D');
break;
case 14:
convertedDec.push_back('E');
break;
case 15:
convertedDec.push_back('F');
break;
}
}
else {
convertedDec.push_back('0' + remainder);
}
value /= 16;
}
for (int i = convertedDec.size() - 1; i > -1; i--) {
convertedReversed.push_back(convertedDec[i]);
}
return convertedReversed;
}

brokenString splitUpString(string myString) {
brokenString temp;
int i = 0;

while (myString[i] != '+' &&
myString[i] != '-' &&
myString[i] != '/' &&
myString[i] != '*' &&
myString[i] != '$')
{
if (myString[i] != '\n') {
temp.leftOp.push_back(myString[i]);
}
i++;
}

i++;
for (i; i < myString.size(); i++)
temp.rightOp.push_back(myString[i]);
return temp;
}

string addition(brokenString myEquation) {
string output = "", dummy = "";
long op1, op2;
bool done = false;
int i, j;
long sum;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
op1=0;
op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}

//cout << myEquation.leftOp[i] << endl << myEquation.rightOp[j] << endl;
sum = op1+op2;
output = decToHex(sum);
return output;
}

string subtraction(brokenString myEquation) {
string output;
int i, j;
long diff;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
diff = op1-op2;
output = decToHex(diff);
return output;
}

string multiplication(brokenString myEquation) {
string output;
int i, j;
long mul;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}   
mul = op1*op2;
output = decToHex(mul);
return output;
}

string division(brokenString myEquation) {
string output;
int i, j;
long div;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
div = op1/op2;
output = decToHex(div);
return output;
}

string power(brokenString myEquation) {
string output;
int i, j;
long power;
i = myEquation.leftOp.size() - 1;
j = myEquation.rightOp.size() - 1;
long op1=0;
long op2=0;
for(i; i>-1; i--)
{
op1 += hexToDec(myEquation.leftOp[i])*pow(16,myEquation.leftOp.size()-1-i);
}
for(j; j>-1; j--)
{
op2 += hexToDec(myEquation.rightOp[j])*pow(16,myEquation.rightOp.size()-1-j);
}
cout<<"\n"<<op1<<" "<<op2<<"\n";
power = pow(op1, op2);
cout<<power;
output = decToHex(power);
return output;
}

Output.txt file:

That concludes our solution, if you need more information, please reach out to me in comments.