I notice you help with C++

bliksta · Post by **bliksta** » Mon Nov 22, 2004 1:37 am

Me and my buddy have been working on our project thats due monday night for a while. can't figure it out. Any help would be nice :D

Definition: A very long number (VLI) is a nonnegative integer that has no more than 100 digits and it is represented as a pair of two elements <Size, Numb>, where:

? Size ? number of decimal digits;

? Numb - an array of decimal digits (each decimal digit is store in one array element).

Example:

const int MAXDIGITS = 100;

int Size = 21;

int VLI[MAXDIGITS]={1,2,3,4,5,6,7,8,9,0,9,8,7,6,5,4,3,2,1,0,9};

//

// The number is: 123456789098765432109

// The number has 21 decimal digits

//

1. Write a C++ function named InputVLI that inputs a VLI.

2. Write a C++ function named OutputVLI that outputs a VLI.

3. Write a C++ function named AddVLI that returns the sum of two VLIs.

4. Write a C++ function named CompVLI that compares VLIs.

5. Write a main function that calls the functions InputVLI, OutputVLI, AddVLI, and CompVLI. Execute the program for 5 different input data.

MikeJ · Post by **MikeJ** » Mon Nov 22, 2004 7:43 am

Ok i went ahead and gave this a shot, it seems to work pretty good. One thing to keep in mind is there is no bounds checking, so if you input or your sum goes over the 100 digit place value, you'll seg-fault. But that would be considered invalid input anyway and the assignment didn't mention anything about bounds checking or input validation. What's with these vague assignment instructions anyway?

Here's my code...

It's kinda C-ish, but that probably doesn't matter since he didn't mention anything about taking an OOP approach or using C++ standard library containers. You could always impress the teacher with a VLI class and operator overloading :D

/*
 Sample Output:
 
 Inputting First Very Long Integer
 Please input a Very Long Integer
 :93758491017274263974
 Inputting Second Very Long Integer
 Please input a Very Long Integer
 :643981765943721098
 
 
 ---ANSWER---
 
 93758491017274263974
 PLUS (+)
 643981765943721098
 EQUALS (=):
 94402472783217985072
 
 Your First Very Long Integer is Larger than your Second!

*/


#include <iostream>
#include <cctype>

using namespace std;

const int MAXDIGITS = 100;

struct VLI
{
 /* Our very long integer */
 int Size; /* number of digits */
 int Numb[MAXDIGITS]; /* array of digits for VLI */
};

VLI InputVLI( void );
void OutputVLI ( VLI myVLI );
VLI AddVLI ( VLI VLI1, VLI VLI2 );
void CompVLI ( VLI VLI1, VLI VLI2 );


int main()
{
 VLI myVLI1, myVLI2;
 VLI* compareVLI;
 cout << "Inputting First Very Long Integer\n";
 myVLI1 = InputVLI();
 cout << "Inputting Second Very Long Integer\n";
 myVLI2 = InputVLI();

 AddVLI( myVLI1, myVLI2 );

 cout << "\n\n---ANSWER---\n\n";
 OutputVLI( myVLI1 );
 cout << " PLUS (+)\n";
 OutputVLI( myVLI2 );
 cout << "EQUALS (=):\n";
 OutputVLI( AddVLI( myVLI1, myVLI2 ) );

 cout << "\n";
 
 CompVLI( myVLI1, myVLI2 );

 return 0;
}

VLI InputVLI()
{
 /*
 strDigit is a 2 element string of chars
 the first element holds the inputted digit
 the second element holds the terminating null 0
 this allows us to use the C library function atoi
 which converts the string to an INTEGER for insertion into the VLI array
 */

 char cInput;
 char strDigit[2];
 VLI myVLI;

 myVLI.Size = 0;

 cout << "Please input a Very Long Integer\n:";

 while ( ( cInput = getchar() ) != EOF && cInput != '\n' )
 {
   /* inputting the number */
   if ( isdigit( cInput ) )
   {
     strDigit[0] = cInput;
     strDigit[1] = '\0';
     myVLI.Numb[myVLI.Size] = atoi( strDigit );
     myVLI.Size++;
   }
 }

 return myVLI;
}

void OutputVLI ( VLI myVLI )
{
 int size = myVLI.Size;
 int i;
 bool padding = true;

 /* this ignores padding 0s in the front */

 for ( i = 0; i < size; i++ )
 {
   if ( myVLI.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     cout << myVLI.Numb[i];
   }
 }

 cout << "\n";
}

VLI AddVLI ( VLI VLI1, VLI VLI2 )
{
 VLI answerVLI;
 VLI carryVLI;

 VLI VLIa;
 VLI VLIb;

 int i, a;
 int sum;

 bool carry = false;

 /* before we do anything we pad every VLI
 we are working on with preceding 0s */

 VLIa.Size = MAXDIGITS;

 a = 0;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   if ( MAXDIGITS - i <= VLI1.Size )
   {
     VLIa.Numb[i] = VLI1.Numb[a++];
   }
   else
   {
     VLIa.Numb[i] = 0;
   }
 }

 VLIb.Size = MAXDIGITS;

 a = 0;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   if ( MAXDIGITS - i <= VLI2.Size )
   {
     VLIb.Numb[i] = VLI2.Numb[a++];
   }
   else
   {
     VLIb.Numb[i] = 0;
   }
 }

 carryVLI.Size = MAXDIGITS;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   carryVLI.Numb[i] = 0;
 }

 answerVLI.Size = MAXDIGITS;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   answerVLI.Numb[i] = 0;
 }

 /* END Padding */

 for ( i = MAXDIGITS - 1; i >= 0; i-- )
 {
   sum = VLIa.Numb[i] + VLIb.Numb[i];
   if ( sum >= 10 )
   {
     /* if the sum carries we send the carry digit over
     to a carry VLI in the next highest place value
     and just insert the sum minus the carry digit ( which is always 1 )
     into the answer VLI */
     carry = true;
     carryVLI.Numb[i - 1] = 1;
     answerVLI.Numb[i] = sum - 10;
   }
   else
   {
     answerVLI.Numb[i] = sum;
   }
 }

 if ( carry )
 {
   /* if we carried any digits, recursively simplify */
   answerVLI = AddVLI( carryVLI, answerVLI );
 }

 return answerVLI;

}

void CompVLI ( VLI VLI1, VLI VLI2 )
{
 /* prints the VLI with the greatest value */
 VLI newVLI1, newVLI2;

 int i;
 int result = 0;
 bool padding = true;

 /* remove padding 0s in the front */
 int size = VLI1.Size;
 newVLI1.Size = 0;
 
 for ( i = 0; i < size; i++ )
 {
   if ( VLI1.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     newVLI1.Numb[i] = VLI1.Numb[i];
     newVLI1.Size++;
   }
 }
 
 padding = true;
 
 size = VLI2.Size;
 newVLI2.Size = 0;
 
 for ( i = 0; i < size; i++ )
 {
   if ( VLI2.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     newVLI2.Numb[i] = VLI2.Numb[i];
     newVLI2.Size++;
   }
 }
 
 if ( newVLI1.Size > newVLI2.Size )
 {
   result = 1;
 }
 else if ( newVLI2.Size > newVLI1.Size )
 {
   result = 2;
 }
 else
 {
   /* equal size, check value */
   for ( i = 0; i < newVLI1.Size; i++ )
   {
     if ( newVLI1.Numb[i] > newVLI2.Numb[i] )
     {
       result = 1;
       break;
     }
     
     if ( newVLI1.Numb[i] < newVLI2.Numb[i] )
     {
       result = 2;
       break;
     }
   }
 }
 
 if ( result == 1 )
 {
   cout << "Your First Very Long Integer is Greater Than your Second!\n";
 }
 else if ( result == 2 )
 {
   cout << "Your Second Very Long Integer is Greater Than your First!\n";
 }
 else
 {
   cout << "Your Very Long Integers are of equal value!\n";
 }
}

Michael-Corleone · Post by **Michael-Corleone** » Mon Nov 22, 2004 3:43 pm

Ok i went ahead and gave this a shot, it seems to work pretty good. One thing to keep in mind is there is no bounds checking, so if you input or your sum goes over the 100 digit place value, you'll seg-fault. But that would be considered invalid input anyway and the assignment didn't mention anything about bounds checking or input validation. What's with these vague assignment instructions anyway?

Here's my code...

It's kinda C-ish, but that probably doesn't matter since he didn't mention anything about taking an OOP approach or using C++ standard library containers. You could always impress the teacher with a VLI class and operator overloading :D

/*
 Sample Output:
 
 Inputting First Very Long Integer
 Please input a Very Long Integer
 :93758491017274263974
 Inputting Second Very Long Integer
 Please input a Very Long Integer
 :643981765943721098
 
 
 ---ANSWER---
 
 93758491017274263974
 PLUS (+)
 643981765943721098
 EQUALS (=):
 94402472783217985072
 
 Your First Very Long Integer is Larger than your Second!

*/


#include <iostream>
#include <cctype>

using namespace std;

const int MAXDIGITS = 100;

struct VLI
{
 /* Our very long integer */
 int Size; /* number of digits */
 int Numb[MAXDIGITS]; /* array of digits for VLI */
};

VLI InputVLI( void );
void OutputVLI ( VLI myVLI );
VLI AddVLI ( VLI VLI1, VLI VLI2 );
void CompVLI ( VLI VLI1, VLI VLI2 );


int main()
{
 VLI myVLI1, myVLI2;
 VLI* compareVLI;
 cout << "Inputting First Very Long Integer\n";
 myVLI1 = InputVLI();
 cout << "Inputting Second Very Long Integer\n";
 myVLI2 = InputVLI();

 AddVLI( myVLI1, myVLI2 );

 cout << "\n\n---ANSWER---\n\n";
 OutputVLI( myVLI1 );
 cout << " PLUS (+)\n";
 OutputVLI( myVLI2 );
 cout << "EQUALS (=):\n";
 OutputVLI( AddVLI( myVLI1, myVLI2 ) );

 cout << "\n";
 
 CompVLI( myVLI1, myVLI2 );

 return 0;
}

VLI InputVLI()
{
 /*
 strDigit is a 2 element string of chars
 the first element holds the inputted digit
 the second element holds the terminating null 0
 this allows us to use the C library function atoi
 which converts the string to an INTEGER for insertion into the VLI array
 */

 char cInput;
 char strDigit[2];
 VLI myVLI;

 myVLI.Size = 0;

 cout << "Please input a Very Long Integer\n:";

 while ( ( cInput = getchar() ) != EOF && cInput != '\n' )
 {
   /* inputting the number */
   if ( isdigit( cInput ) )
   {
     strDigit[0] = cInput;
     strDigit[1] = '\0';
     myVLI.Numb[myVLI.Size] = atoi( strDigit );
     myVLI.Size++;
   }
 }

 return myVLI;
}

void OutputVLI ( VLI myVLI )
{
 int size = myVLI.Size;
 int i;
 bool padding = true;

 /* this ignores padding 0s in the front */

 for ( i = 0; i < size; i++ )
 {
   if ( myVLI.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     cout << myVLI.Numb[i];
   }
 }

 cout << "\n";
}

VLI AddVLI ( VLI VLI1, VLI VLI2 )
{
 VLI answerVLI;
 VLI carryVLI;

 VLI VLIa;
 VLI VLIb;

 int i, a;
 int sum;

 bool carry = false;

 /* before we do anything we pad every VLI
 we are working on with preceding 0s */

 VLIa.Size = MAXDIGITS;

 a = 0;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   if ( MAXDIGITS - i <= VLI1.Size )
   {
     VLIa.Numb[i] = VLI1.Numb[a++];
   }
   else
   {
     VLIa.Numb[i] = 0;
   }
 }

 VLIb.Size = MAXDIGITS;

 a = 0;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   if ( MAXDIGITS - i <= VLI2.Size )
   {
     VLIb.Numb[i] = VLI2.Numb[a++];
   }
   else
   {
     VLIb.Numb[i] = 0;
   }
 }

 carryVLI.Size = MAXDIGITS;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   carryVLI.Numb[i] = 0;
 }

 answerVLI.Size = MAXDIGITS;

 for ( i = 0; i < MAXDIGITS; i++ )
 {
   answerVLI.Numb[i] = 0;
 }

 /* END Padding */

 for ( i = MAXDIGITS - 1; i >= 0; i-- )
 {
   sum = VLIa.Numb[i] + VLIb.Numb[i];
   if ( sum >= 10 )
   {
     /* if the sum carries we send the carry digit over
     to a carry VLI in the next highest place value
     and just insert the sum minus the carry digit ( which is always 1 )
     into the answer VLI */
     carry = true;
     carryVLI.Numb[i - 1] = 1;
     answerVLI.Numb[i] = sum - 10;
   }
   else
   {
     answerVLI.Numb[i] = sum;
   }
 }

 if ( carry )
 {
   /* if we carried any digits, recursively simplify */
   answerVLI = AddVLI( carryVLI, answerVLI );
 }

 return answerVLI;

}

void CompVLI ( VLI VLI1, VLI VLI2 )
{
 /* prints the VLI with the greatest value */
 VLI newVLI1, newVLI2;

 int i;
 int result = 0;
 bool padding = true;

 /* remove padding 0s in the front */
 int size = VLI1.Size;
 newVLI1.Size = 0;
 
 for ( i = 0; i < size; i++ )
 {
   if ( VLI1.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     newVLI1.Numb[i] = VLI1.Numb[i];
     newVLI1.Size++;
   }
 }
 
 padding = true;
 
 size = VLI2.Size;
 newVLI2.Size = 0;
 
 for ( i = 0; i < size; i++ )
 {
   if ( VLI2.Numb[i] )
   {
     padding = false;
   }
   if ( !padding )
   {
     newVLI2.Numb[i] = VLI2.Numb[i];
     newVLI2.Size++;
   }
 }
 
 if ( newVLI1.Size > newVLI2.Size )
 {
   result = 1;
 }
 else if ( newVLI2.Size > newVLI1.Size )
 {
   result = 2;
 }
 else
 {
   /* equal size, check value */
   for ( i = 0; i < newVLI1.Size; i++ )
   {
     if ( newVLI1.Numb[i] > newVLI2.Numb[i] )
     {
       result = 1;
       break;
     }
     
     if ( newVLI1.Numb[i] < newVLI2.Numb[i] )
     {
       result = 2;
       break;
     }
   }
 }
 
 if ( result == 1 )
 {
   cout << "Your First Very Long Integer is Greater Than your Second!\n";
 }
 else if ( result == 2 )
 {
   cout << "Your Second Very Long Integer is Greater Than your First!\n";
 }
 else
 {
   cout << "Your Very Long Integers are of equal value!\n";
 }
}

<{POST_SNAPBACK}>

I like your coding style.

bliksta · Post by **bliksta** » Mon Nov 22, 2004 7:10 pm

thanks you very much :D

What education do you have on programming mc?

bliksta · Post by **bliksta** » Mon Nov 22, 2004 9:17 pm

struct VLI
{
/* Our very long integer */
int Size; /* number of digits */
int Numb[MAXDIGITS]; /* array of digits for VLI */
};

VLI InputVLI( void );
void OutputVLI ( VLI myVLI );
VLI AddVLI ( VLI VLI1, VLI VLI2 );
void CompVLI ( VLI VLI1, VLI VLI2 );

Our class has never learned this struct command so it would be pretty weird if we used it. how can we change it to get rid of this?