Videos
Compute the Godel numbers of arithmetical expressions
Program Plan:
- In function “addingLargeNumbers()”:
- It takes two stacks corresponding to two large numbers as parameters.
- Till any one of stack becomes empty,
- Pop each digit from both stacks and add them with carry.
- Push resultant digit into resultant stack and store carry digit in “carryy”.
- If first stack not empty, till stack becomes empty,
- Pop each digit from stack and add them with carry.
- Push resultant digit into resultant stack and store carry digit in “carryy”.
- If second stack not empty, till stack becomes empty,
- Pop each digit from stack and add them with carry.
- Push resultant digit into resultant stack and store carry digit in “carryy”.
- If carry not “0”, push it into resultant stack.
- Return resultant stack.
- In function “compareNumbers()”,
- If count of digits in first number is greater than second , set flag value as “1”
- If count of digits in second number is greater than first set flag value as “2”.
- If count of digits in both numbers are same.
- Compare each digits of both number from left to right, if found any digits of first number greater than second, set flag as “1” and break.
- If found any digits of first number lesser than second, set flag as “2” and break.
- Otherwise set continue.
- Return flag value.
- In function “substractLargeNumbers()”,
- If first number is less than second exchange both numbers.
- Till any of stack for numbers becomes empty,
- For each digit from both stacks, perform subtraction.
- If digit of first number less than second, add “10” with it.
- Till stack for first number becomes empty,
- For each digit from both stacks, perform subtraction.
- If digit of first number less than second, add “10” with it.
- Return resultant stack.
- In function “divisionLargeNumbers()”,
- Initialize count value as “0”.
- Till first number become equal or less than second number,
- Subtract second number from first and compare them.
- If first number greater than second increment count value.
- Return count value.
- Print resultant stack.
- In function “multiplyLargeNumbers()”,
- Initialize resultant stack as “0”.
- Till second stack becomes empty,
- Multiply first number with each digit of second number.
- Add sum to resultant stack
- Return resultant stack.
- To compute power of two numbers repeatedly call function “multiplyLargeNumbers()”.
- To compute Godel number for each expression, choose corresponding prime number from array and perform repeated multiplication.
/**********************************************************
* Program to perform arithmetic operations on large *
* numbers. *
**********************************************************/
Explanation of Solution
Program:
//Include header files
#include <iostream>
#include<stack>
#include<queue>
using namespace std;
//Declare global variables
int flagg;
int size1,size2;
/*Function addingLargeNumbers() add two large numbers using stacks*/
stack<int> addingLargeNumbers(stack<int> Numm1_stack, stack<int> Numm2_stack)
{
//Initialize carryy as 0
int carryy=0;
//Declare variables
stack<int> Resultt_stack;
int numb1,numb2,resultt_num,resultdgt;
//If both stacks for input numbers are not empty
if(!Numm1_stack.empty() && !Numm2_stack.empty())
{
//Till any one of stack becomes empty
while(!Numm1_stack.empty() && !Numm2_stack. empty())
{
/*Take stack tops of Numm1_stack and Numm2_stack*/
numb1=Numm1_stack.top();
numb2=Numm2_stack.top();
//Add Both stack tops with carryy
resultt_num=numb1+numb2+carryy;
/*Push Last digit of result into stack Resultt_stack*/
resultdgt=resultt_num % 10;
Resultt_stack.push(resultdgt);
//Store carry digit into carryy
carryy=resultt_num / 10;
//Pop both stack tops
Numm1_stack.pop();
Numm2_stack.pop();
}
}
//If Numm1_stack is not empty
if(!Numm1_stack.empty())
{
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take stack top from Numm1_stack
numb1=Numm1_stack.top();
//Add stack top with carryy to get result
resultt_num=numb1+carryy;
/*Push Last digit of result into stack Resultt_stack*/
resultdgt=resultt_num % 10;
Resultt_stack.push(resultdgt);
//Store carry digit into carryy
carryy=resultt_num / 10;
//Pop stack top of Numm1_stack
Numm1_stack.pop();
}
}
//If Numm2_stack is not empty
if(!Numm2_stack.empty())
{
//Till Numm2_stack becomes empty
while(!Numm2_stack.empty())
{
//Take stack top from Numm2_stack
numb2=Numm2_stack.top();
//Add stack top with carryy to get result
resultt_num=numb2+carryy;
// Compute Last digit of result
resultdgt=resultt_num % 10;
/*Push Last digit of result into stack Resultt_stack*/
Resultt_stack.push(resultdgt);
//Store carry digit into carryy
carryy=resultt_num / 10;
//Pop stack top of Numm2_stack
Numm2_stack.pop();
}
}
//If carryy is not 0
if(carryy!=0)
{
//Push carryy into Resultt_stack
Resultt_stack.push(carryy);
}
//Return Resultt_stack
return Resultt_stack;
}
//Function to compare two large numbers
int compareNumbers(stack<int> Numm1_stack, stack<int> Numm2_stack)
{
//Declare variables
stack<int> rough1,rough2;
size1=Numm1_stack.size();
size2=Numm2_stack.size();
int num1,num2,sizeroug;
//Set flagg as 0
flagg=0;
/*If number of digits in first number is less than second*/
if(size1<size2)
//Set flagg as 2
flagg=2;
/*If number of digits in first number is greater than second*/
if(size1>size2)
//Set flagg as 1
flagg=1;
//If number of digits in both numbers are same
if(size1==size2)
{
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Push to stack rough1
rough1.push(num1);
//Pop top of Numm1_stack
Numm1_stack.pop();
//Take top of Numm2_stack
num2=Numm2_stack.top();
//Push to stack rough2
rough2.push(num2);
//Pop top of Numm2_stack
Numm2_stack.pop();
}
//Set sizeroug as size1
sizeroug=size1;
//Till sizeroug >0
while(sizeroug>0)
{
//Take top of rough1
num1=rough1.top();
//Push to Numm1_stack
Numm1_stack.push(num1);
//Pop top of rough1
rough1.pop();
//Take top of rough2
num2=rough2.top();
//Push to Numm2_stack
Numm2_stack.push(num2);
//Pop top of rough2
rough2.pop();
//Decrement sizeroug by 1
sizeroug--;
//If num1>num2
if(num1>num2)
{
//Set flagg as 1
flagg=1;
break;
}
//If num1<num2
else if(num1<num2)
{
//Set flagg as 2
flagg=2;
break;
}
//Otherwise
else
//Continue
continue;
}
}
//Return flagg
return flagg;
}
/*Function subtractLargeNumbers() add two large numbers using stacks*/
stack<int> substractLargeNumbers(stack<int> Numm1_stack, stack<int> Numm2_stack)
{
//Declare variables
int num1,num2,reslt,roughh,sizerou;
stack<int> rough1,rough2;
size1=Numm1_stack.size();
size2=Numm2_stack.size();
//If number digits in both numbers are equal
if(size1==size2)
{
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of stack Numm1_stack
num1=Numm1_stack.top();
//Push into rough1
rough1.push(num1);
//Pop top of Numm1_stack
Numm1_stack.pop();
//Take top of Numm2_stack
num2=Numm2_stack.top();
//Push into rough2
rough2.push(num2);
//Pop top of Numm2_stack
Numm2_stack.pop();
}
//Set sizerou as size1
sizerou=size1;
//Till sizerou becomes 0
while(sizerou>0)
{
//Take top of rough1
num1=rough1.top();
//Push into Numm1_stack
Numm1_stack.push(num1);
//Pop top of rough1
rough1.pop();
//Take top of rough2
num2=rough2.top();
//Push into Numm2_stack
Numm2_stack.push(num2);
//Pop top of rough2
rough2.pop();
//Decrement sizerouby 1
sizerou--;
/*If number of digits in first number is greater than second*/
if(num1>num2)
{
//Set flagg as 1
flagg=1;
break;
}
//If num1<num2
else if(num1<num2)
{
//Set flagg as 2
flagg=2;
break;
}
//Otherwise
else
//Continue
continue;
}
//Till rough1 becomes empty
while(!rough1.empty())
{
//Take top of rough1
num1=rough1.top();
//Push into Numm1_stack
Numm1_stack.push(num1);
//Pop top of rough1
rough1.pop();
}
//Till rough2 becomes empty
while(!rough2.empty())
{
//take top of rough2
num2=rough2.top();
//Push into Numm2_stack
Numm2_stack.push(num2);
//Pop top of rough2
rough2.pop();
}
}
//If size1 < size2 or flagg is 2
if(size1<size2 || flagg == 2)
{
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Push into rough1
rough1.push(num1);
//Pop top of Numm1_stack
Numm1_stack.pop();
}
//Till Numm2_stack becomes emty
while(!Numm2_stack.empty())
{
//Take top of Numm2_stack
num2=Numm2_stack.top();
//Push into rough2
rough2.push(num2);
//Pop top of Numm2_stack
Numm2_stack.pop();
}
//Till rough1 becomes empty
while(!rough1.empty())
{
//Take top of rough1
num1=rough1.top();
//Push into Numm2_stack
Numm2_stack.push(num1);
//Pop top of rough1
rough1.pop();
}
//Till rough2 becomes empty
while(!rough2.empty())
{
//Take top of rough2
num2=rough2.top();
//Push into Numm1_stack
Numm1_stack.push(num2);
//Pop top of rough2
rough2.pop();
}
}
/*Subtraction process Till Numm1_stack or Numm2_stack becomes empty */
while(!Numm1_stack.empty() && !Numm2_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//Take top of Numm2_stack
num2=Numm2_stack.top();
//Pop top of Numm2_stack
Numm2_stack.pop();
//If num1 greater or equal to num2
if(num1 >= num2)
{
//Calculate result
reslt=num1-num2;
//Push result into resultant stack
rough1.push(reslt);
}
//Otherwise
else
{
//If Numm1_stack not empty
if(!Numm1_stack.empty())
{
//Add num1 with 10
num1=num1+10;
//Take top of Numm1_stack
roughh=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//Subtract 1 from next digit
roughh=roughh-1;
//Push new digit into same stack
Numm1_stack.push(roughh);
//Calculate result
reslt=num1-num2;
//Push result into resultant stack
rough1.push(reslt);
}
}
}
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty() )
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//If num1 <0
if(num1<0)
{
//Add 10 with num1
num1=10+num1;
//If Numm1_stack not empty
if(!Numm1_stack.empty())
{
//Take top of Numm1_stack
roughh=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//Decrement roughh1 by 1
roughh=roughh-1;
//Push into Numm1_stack
Numm1_stack.push(roughh);
}
}
//Push into rough1
rough1.push(num1);
}
//Return resultant stack
return rough1;
}
//Function to multiply large numbers
stack<int> multiplyLargeNumbers(stack<int> Numm1_stack, stack<int> Numm2_stack)
{
//Declare variables
stack<int> rough1,rough2,mresultStck;
mresultStck.push(0);
int num1,num2,qsize1,qsize2,mresult,addzero2;
int mcarry=0,addzero=0;
std::queue<int> numQueue1,numQueue2;
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//Push into Queue numQueue1
numQueue1.push(num1);
}
//Calculate size of numQueue1
qsize1=numQueue1.size();
//Till Numm2_stack becomes empty
while(!Numm2_stack.empty())
{
//Initialize mcarry as0
mcarry=0;
//Take top of Numm2_stack
num2=Numm2_stack.top();
//Pop top of Numm2_stack
Numm2_stack.pop();
//Set addzero2 as addzero
addzero2=addzero;
//Till addzero becomes 0
while(addzero2>0)
{
//Push zeros into rough1
rough1.push(0);
//Decrement addzero by 1
addzero2--;
}
//Set qsize2 as qsize1
qsize2=qsize1;
//Till qsize2 becomes 0
while(qsize2>0)
{
//Take from of queue numQueue1
num1=numQueue1.front();
//Remove front of queue numQueue1
numQueue1.pop();
//Push it into numQueue1
numQueue1.push(num1);
//Calculate result
mresult=(num1*num2)+mcarry;
//Push reslutant digit into stack
rough1.push(mresult%10);
//Set mcarry as resultant carry
mcarry=mresult/10;
//Decrement qsize2 by 1
qsize2--;
}
//If mcarry is not 0
if(mcarry!=0)
{
//Push carry into rough1
rough1.push(mcarry);
}
//Increment addzero by 1
addzero++;
//Till rough1 becomes empty
while(!rough1.empty())
{
//Take top of rough1
num1=rough1.top();
//Pop top of rough1
rough1.pop();
//Push into rough2
rough2.push(num1);
}
/*Reverse resultant stack
Till mresultStck becomes empty
*/
while(!mresultStck.empty())
{
//Take top of mresultStck
num1=mresultStck.top();
//Pop top of mresultStck
mresultStck.pop();
//Insert into queue numQueue2
numQueue2.push(num1);
}
//Till numQueue2 becomes empty
while(!numQueue2.empty())
{
//Take front of numQueue2
num1=numQueue2.front();
//Remove front of numQueue2
numQueue2.pop();
//Insert into mresultStck
mresultStck.push(num1);
}
//Call addition for addition
mresultStck=addingLargeNumbers(mresultStck,rough2);
//Till rough2 becomes empty
while(!rough2.empty())
//Pop top of rough2
rough2.pop();
}
//Return resultant stack
return mresultStck;
}
//Function for division of two large numbers
void divisionLargeNumbers(stack<int> Numm1_stack, stack<int> Numm2_stack)
{
//Declare variables
stack<int> divrough1,divrough2,divresultStck,stackfor1;
int num1,flaggg;
divresultStck.push(0);
stackfor1.push(1);
//Call function compareNumbers() to compare two numbers
flaggg=compareNumbers(Numm1_stack, Numm2_stack);
//If flaggg is 1 or 0
while(flaggg==1 || flaggg==0)
{
//Till divresultStck becomes empty
while(!divresultStck.empty())
{
//Take top of divresultStck
num1=divresultStck.top();
//Pop top of divresultStck
divresultStck.pop();
//Push into divrough1
divrough1.push(num1);
}
//Till divrough1 becomes empty
while(!divrough1.empty())
{
//Take top of divrough1
num1=divrough1.top();
//Pop top of divrough1
divrough1.pop();
//Push into divrough2
divrough2.push(num1);
}
//Till divrough2 becomes empty
while(!divrough2.empty())
{
//Take top of divrough2
num1=divrough2.top();
//Pop top of divrough1
divrough2.pop();
//Push into divresultStck
divresultStck.push(num1);
}
//Call function addingLargeNumbers()
divresultStck=addingLargeNumbers(divresultStck,stackfor1);
/*Call function substractLargeNumbers() to subtract second number from first*/
Numm1_stack=substractLargeNumbers(Numm1_stack, Numm2_stack);
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//If num1 is 0
if(num1==0)
{
//Pop top of Numm1_stack
Numm1_stack.pop();
}
//Otherwise
else
{
//Push into divrough2
divrough2.push(num1);
//Pop top of Numm1_stack
Numm1_stack.pop();
//Till Numm1_stack becomes empty
while(!Numm1_stack.empty())
{
//Take top of Numm1_stack
num1=Numm1_stack.top();
//Pop top of Numm1_stack
Numm1_stack.pop();
//Push into divrough2
divrough2.push(num1);
}
}
}
//Till divrough2 becomes empty
while(!divrough2.empty())
{
//Take top of divrough2
num1=divrough2.top();
//Pop top of divrough2
divrough2.pop();
//Push into divrough1
divrough1.push(num1);
}
//Till divrough1 becomes empty
while(!divrough1.empty())
{
//Take top of divrough1
num1=divrough1.top();
//Pop top of divrough1
divrough1.pop();
//Push into Numm1_stack
Numm1_stack.push(num1);
}
/*Call function compareNumbers() to compare new first number with second*/
flaggg=compareNumbers(Numm1_stack,Numm2_stack);
}
cout<<"\n Quotient is: "<<endl;
//Till divresultStck becomes empty
while(!divresultStck.empty())
{
//Take top of divresultStck
num1=divresultStck.top();
//Pop top of divresultStck
divresultStck.pop();
//Print number
cout<<num1;
}
}
//Program begins with main function
int main()
{
//Declare variables
stack<int> Numm1_stackk,Numm2_stackk,Resultt_stackk,powStack,powResultStack,godelResultStack,godelNum1;
char numm;
int ii,nnumm,jj,basenum,pwe;
int primearray[25]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
std::queue<int> roughQue;
powResultStack.push(1);
godelResultStack.push(1);
//Prompt and Read first number from user
cout<<"Enter first number"<<endl;
cin.get(numm);
//If input character is not new line or space
while(numm!='\n'&& numm!=' ')
{
//Push each digits into stack Numm1_stackk
Numm1_stackk.push(numm-48);
//Read next digit from user
cin.get(numm);
}
//Prompt and Read second number from user
cout<<"Enter second Number"<<endl;
cin.get(numm);
//If input character is not new line or space
while(numm!='\n'&& numm!=' ')
{
//Push each digits into stack Numm2_stackk
Numm2_stackk.push(numm-48);
cin.get(numm);
}
/*Call function addingLargeNumbers() to add first two numbers*/
Resultt_stackk=addingLargeNumbers(Numm1_stackk,Numm2_stackk);
//Print message for sum of numbers
cout<<"Sum of numbers is: ";
//If Resultt_stackk is not empty
while(!Resultt_stackk.empty())
{
//Print stack top of Resultt_stack
cout<<Resultt_stackk.top();
//Pop stack top of Resultt_stack
Resultt_stackk.pop();
}
cout<<"\n Difference of two numbers is : "<<endl;
/*Call function substractLargeNumbers() to compute difference*/
Resultt_stackk=substractLargeNumbers(Numm1_stackk,Numm2_stackk);
//If first number > second
if(size1 < size2 || flagg == 2)
{
//Print neagtive sign
cout<<"-";
}
//Till Resultt_stackk is not empty
while(!Resultt_stackk.empty())
{
//Print stack top of Resultt_stack
cout<<Resultt_stackk.top();
//Pop stack top of Resultt_stack
Resultt_stackk.pop();
}
cout<<"\n Product of two numbers is "<<endl;
/*Call function multiplyLargeNumbers() to compute product*/
Resultt_stackk=multiplyLargeNumbers(Numm1_stackk,Numm2_stackk);
//If Resultt_stackk is not empty
while(!Resultt_stackk.empty())
{
//Print stack top of Resultt_stack
cout<<Resultt_stackk.top();
//Pop stack top of Resultt_stack
Resultt_stackk.pop();
}
/*Call function divisionLargeNumbers() to perform division*/
divisionLargeNumbers(Numm1_stackk,Numm2_stackk);
/*To compute power
Insert base number into stack
*/
powStack.push(1);
powStack.push(2);
powStack.push(3);
//Initialize ii as 0
ii=0;
//Till ii becomes 45
while(ii<45)
{
//Till powResultStack becomes empty
while(!powResultStack.empty())
{
//Take top of powResultStack
nnumm=powResultStack.top();
//Pop top of powResultStack
powResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into powResultStack
powResultStack.push(nnumm);
}
/*Call function multiplyLargeNumbers() for repeated multiplication*/
powResultStack=multiplyLargeNumbers(powResultStack, powStack);
//Increment ii by 1
ii++;
}
cout<<" \n Power(123,45) is: "<<endl;
//Till powResultStack becomes empty
while(!powResultStack.empty())
{
//Print stack top of powResultStack
cout<<powResultStack.top();
//Pop stack top of powResultStack
powResultStack.pop();
}
//Godel Number calculation
cout<<" \n Enter Godel expression: "<<endl;
//initialize ii as 0
ii=0;
//Read character
cin.get(numm);
//Till character becomes newline
while(numm!='\n')
{
//Switch statement
switch(numm)
{
//If character is =
case '=':
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
/*Push last digit of basenum into stack*/
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
/*To reverse order digits in stack, Till godelNum1 becomes empty*/
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty
*/
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is +
case '+':
//Set pwe as 2
pwe=2;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
/*Push last digit of basenum into stack*/
godelNum1.push(basenum%10);
/*Set basenum as basenum/10*/
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
/*Till godelResultStack becomes empty*/
while(!godelResultStack.empty())
{
/*Take top of godelResultStack*/
nnumm=godelResultStack.top();
/*Pop top of godelResultStack*/
godelResultStack.pop();
/*Insert into queue roughQue*/
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
/*Insert into godelResultStack*/
godelResultStack.push(nnumm);
}
/*Call function multiplyLargeNumbers()*/
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is *
case '*':
//Set pwe as 3
pwe=3;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
/* Call function multiplyLargeNumbers() */
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is /
case '/':
//Set pwe as 5
pwe=5;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is )
case ')':
pwe=7;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
/*Call function multiplyLargeNumbers() */
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character as 0
case '0':
//Set pwe as 9
pwe=9;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is S
case 'S':
//Set pwe as 10
pwe=10;
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
/* Push last digit of basenum into stack */
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
/* To reverse order gigits in stack, Till godelNum1 becomes empty */
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is x
case 'x':
//Read next character (i)
cin.get(numm);
//Set pwe as 11+2*i
pwe=11+2*(numm-48);
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//If character is X
case 'X':
//Read next character (i)
cin.get(numm);
//Set pwe as 12+2i
pwe=12+2*(numm-48);
//Take prime number at iith positon
basenum=primearray[ii];
//Increment ii by 1
ii++;
//If basenum<10
if(basenum<10)
{
//Push into godelNum1
godelNum1.push(basenum);
}
//Otherwise
else
{
//Till basenum becomes 0
while(basenum>0)
{
//Push last digit of basenum into stack
godelNum1.push(basenum%10);
//Set basenum as basenum/10
basenum=basenum/10;
}
}
//To reverse order gigits in stack, Till godelNum1 becomes empty
while(!godelNum1.empty())
{
//Take top of godelNum1
nnumm=godelNum1.top();
//Pop top of godelNum1
godelNum1.pop();
//Insert imto queue roughQue
roughQue.push(nnumm);
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Push into godelNum1
godelNum1.push(nnumm);
}
//Set jj as 0
jj=0;
/*To reverse order of digits in resultant stack
Till godelResultStackbecomes empty */
while(jj<pwe)
{
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Take top of godelResultStack
nnumm=godelResultStack.top();
//Pop top of godelResultStack
godelResultStack.pop();
//Insert into queue roughQue
}
//Till roughQue becomes empty
while(!roughQue.empty())
{
//Take front of roughQue
nnumm=roughQue.front();
//Pop front of roughQue
roughQue.pop();
//Insert into godelResultStack
godelResultStack.push(nnumm);
}
//Call function multiplyLargeNumbers()
godelResultStack=multiplyLargeNumbers(godelResultStack, godelNum1);
//Increment jj by 1
jj++;
}
//Till godelNum1 becomes empty
while(!godelNum1.empty())
//Pop top of godelNum1
godelNum1.pop();
break;
//Otherwise
default:
//Print error meassage
cout<<"Invalid Input"<<endl;
}
//Read next character
cin.get(numm);
}
//Godel number calculation
cout<<" \n Godel number is: "<<endl;
//Till godelResultStack becomes empty
while(!godelResultStack.empty())
{
//Print stack top of Resultt_stack
cout<<godelResultStack.top();
//Pop stack top of Resultt_stack
godelResultStack.pop();
}
//Return from program
system("pause");
return 0;
}
Output:
Enter first number
5476532
Enter second Number
214
Sum of numbers is: 5476746
Difference of two numbers is :
5476318
Product of two numbers is
1171977848
Quotient is:
25591
Power(123,45) is:
11110408185131956285910790587176451918559153212268021823629073199866111001242743
283966127048043
Enter Godel expression:
x1+x2=x3
Godel number is:
7960790698863876893250000000000000
Want to see more full solutions like this?
Chapter 4 Solutions
EBK DATA STRUCTURES AND ALGORITHMS IN C
- Implement the quadratic_formula() function. The function takes 3 arguments, a, b, and c, and computes the two results of the quadratic formula: x1=−b+b2−4ac2a x2=−b−b2−4ac2a The quadratic_formula() function returns the tuple (x1, x2). Ex: When a = 1, b = -5, and c = 6, quadratic_formula() returns (3, 2). Code provided in main.py reads a single input line containing values for a, b, and c, separated by spaces. Each input is converted to a float and passed to the quadratic_formula() function. Ex: If the input is: 2 -3 -77 the output is: Solutions to 2x^2 + -3x + -77 = 0 x1 = 7 x2 = -5.50 code: # TODO: Import math module def quadratic_formula(a, b, c):# TODO: Compute the quadratic formula results in variables x1 and x2return (x1, x2) def print_number(number, prefix_str):if float(int(number)) == number:print("{}{:.0f}".format(prefix_str, number))else:print("{}{:.2f}".format(prefix_str, number)) if __name__ == "__main__":input_line = input()split_line = input_line.split(" ")a =…arrow_forwardc++ Implement a function that recursively calculates the nth number in the Fibonacci sequence of numbers. The Fibonacci sequence starts at 0 and 1. Each number thereafter is the sum of the two preceding numbers. This gives us the following first ten numbers: 0,1,1,3,5,8,13,21,34, .... Input Expected output0 01 17 139 34arrow_forwardWrite a function timestable(n), which prints a multiplication table of size n. For example, timestable(5) would print: 1 2 3 4 5 2 3 4 5 4 6 8 10 6 9 12 158 12 16 2010 15 20 25Use the function in a program where you ask the user for n and you print the corresponding table.arrow_forward
- Write a program in C that take 5 digit number as an input from the user and perform the following tasks:1. Split a number into digits.2. Find the sum of the all the digits in the number.3. Find the product of the all the digits in the number.4. Find maximum number with in the number along with position.5. Printing the digits in the reverse order.arrow_forwardWrite a program in python with a function timestable(n), which prints a multiplication table of size n. For example, timestable(5) would print: 12345 2 3 4 5 4 6 8 10 6 9 12 15 8 12 16 20 10 15 20 25Use the function in a program where you ask the user for n and you print the corresponding table.arrow_forwardAnswer the given question with a proper explanation and step-by-step solution. Write an MIPS program that computes terms of the Fibonacci series, defined as: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ... (This is sometimes started with a 0th term: 0, 1, 1, 2, etc.)The first two terms in the series are fixed, and each subsequent term in the series is the sum of the preceding two terms. So, for example, the term 13 is the sum of the terms 5 and 8.Write the program as a counting loop that terminates when the 100th term of the series has been computed. Use a register for the current term and a register for the previous term. Each execution of the loop computes a new current term and then copies the old current term to the previous term register. Count the number of passes to stop after the 100th term. Do not worry about overflow: this will FAR exceed the capacity of a register to hold the value. Stop the program with a syscall with 10 in $v0.arrow_forward
- Write a C++ program: to iteratively compute Fibonacci numbers (named after an Italian mathematician). Some Fibonacci numbers are 1,1,2,3,5,8,... where the next number is found by summing the preceding two numbers. Your program is not assured of recieving good data, thus if -2 is recieved as the number of numbers, then an error should be reported. Try n = 5, 7, 10, -3arrow_forwardC++ Programming Language: Enhance the code given by outputting: The largest number of the sequence a0 ,a1 ,a2 , ..., ak. The position of the largest number Test your program for the following values of x: 75, 111, 678, 732, 873, 2048, and 65535. Example: "For example, for the input sequence: 75, 226, 113, 340, 170, 85, 256, 128, 64, 32, 16, 8, 4, 2, 1, the program output should contain the following: The largest number of the sequence is 340 The position of the largest number is 4" Code Given: #include <iostream> #include <iomanip> using namespace std; int main() { long x; int count; long a_n; cout << "Enter a nonnegative integer: "; cin >> x; cout << endl; count = 0; a_n = x; cout << a_n << ", "; while (a_n !=1) { if (a_n %2==0) a_n = a_n / 2; else a_n = 3 * a_n + 1; count++; cout << a_n <<", "; } cout << endl; cout << "The integer k such that a_k = 1 is " << count << endl; return0; }arrow_forwardWrite a C++ program to perform addition of two hexadecimal numeralseach with up to 4 hex digits. If the result of the addition is more than 4 hex digitslong, then simply give the output message “Addition overflow” and stop. Use dynamicarrays to store hexadecimal numbers as arrays of characters. Assume the numbers canbe of different length (i.e. if adding hex numbers 12ab + 90 (first number is stored as 4characters in size, second number is stored as 2 characters in size), the second numberwill then be interpreted as 0090 but the leftmost zeros will not be included in the array(the size of the array variable will be useful here). To perform hex addition, you canconvert each individual hex digit to decimal, perform the addition, and then convert tohex, including adding a carry as necessary.arrow_forward
- Implement the function (in C or C++) with the following prototype: /** Implement a function which rotates a word left by n-bits, and returns that rotated value. Assume 0 <= n < w Examples: when x = 0x12345678 and w = 32: n=4 -> 0x23456781 n=20 -> 0x67812345 */ unsigned rotate_left(unsigned x, int n); The function should follow the bit-level integer coding rules above. Be careful of the case n = 0.arrow_forwardWrite a program to convert a number from a binary representation to a decimal format—that is, from base 2 to base 10. Your program should make use of recursion to do the conversion.arrow_forwardIn C, write a function that gets 3 pointers int* a, int* b, int* c, and rotates the values in their addresses to the left. That is, a gets the value of b, b gets the value of c, and c gets the value of a. void rotate3 (int* a, int* b, int* c); For example, if we have int x=1, y=2, z=3, then after calling rotate3 (&x, &y, &z) we should have x==2, y==3, and z==1. if we have int x=7, y=1, z=6, then after calling rotate3 (&x, &y, &z) we should have x==1, y==6, and z==7.arrow_forward
C++ for Engineers and ScientistsComputer ScienceISBN:9781133187844Author:Bronson, Gary J.Publisher:Course Technology Ptr
C++ Programming: From Problem Analysis to Program...Computer ScienceISBN:9781337102087Author:D. S. MalikPublisher:Cengage Learning