Question

In C++

Having heard you have gotten really good at programming, your friend has come to ask for your help with a simple task. She would like you to implement a program to encrypt the messages she exchanges with her friends.

The idea is very simple. Every letter of the alphabet will be substituted with some other letter according to a given key pattern like the one below.

"abcdefghijklmnopqrstuvwxyz"

"doxrhvauspntbcmqlfgwijezky" // key pattern

For example, every 'a' will become a 'd' and every 'k' will become a 'n'. Upper case letters are encoded the same way but they remain upper case (e.g. every 'A' will become a 'D'), while any characters which are not letters of the alphabet (e.g.: digits, space, punctuation, etc) remain as given (e.g. every '1' remains a '1'). The process is symmetrical so decoding of an encoded text can be done using the corresponding decoding key pattern.

Part 1: You will implement a simple encoder class which encodes strings based on a key pattern. The class has a single public function to encode a string since decoding can be done using a new encoder constructed with the symmetrical decoding key pattern.

Part 2: Your friend is pretty happy with your program but she needs an improvement. She uses a lot of common abbreviations like “LOL” when she IMs her friends and she is worried sooner or later someone will figure out the whole scheme once they notice “TMT” appearing so often in the logs.

You plan to implement a new encoder which is based on the previous one but which has the ability to pad each character with a fixed number of random letters/digits. For example, with a padding of 3, “LOL” would be encoded to a word like T###M###T### where the # are random chars from the set [a-z, A-Z, 0-9], for example TabiM8rcTyFp or ThV9MbolTJDj, each time appearing different.

The padding encoder has a new function used to decode which removes the junk characters from the encrypted texts. This way LOL can be retrieved from both TabiM8rcTyFp and ThV9MbolTJDj since LabiO8rcLyFp and LhV9ObolLJDj are not very funny :)

A starter file has been given to you here project4_first_last.cpp. All you need to do is implement the member functions for the basic encoder and then implement the padding encoder.

#include <iostream>

#include <string>

#include <cstdlib>

#include <ctime>

using namespace std;

class Encoder {

public:

/*

* Create an encoder object with the given encoding key

*/

Encoder(const string& encryption_key);

/*

* Get the encrypted text for the given plain text

*/

string encode(const string& plainText);

protected:

/*

* Encode the given char

*/

char encodeChar(char c);

private:

// your code here

};

class PaddingEncoder : public Encoder {

// your code here

};

// You code here for the function implementations

/*

*

* DO NOT MODIFY THE MAIN

*

*/

int main()

{

srand(time(0));

const string PLAIN_TEXT = "C++ is fun!";

// construct an encoder and the corresponding decoder

Encoder encoder("doxrhvauspntbcmqlfgwijezky");

Encoder decoder("gmnawrseuvyqokbjpdilhftczx");

string cipher_text = encoder.encode(PLAIN_TEXT);

cout<<"Encoded: "<<cipher_text<<endl;

cout<<"Decoded: "<<decoder.encode(cipher_text)<<endl;

// construct a padded encoder with 3 character padding and the corresponding decoder

PaddingEncoder padEncoder("doxrhvauspntbcmqlfgwijezky", 3);

PaddingEncoder padDecoder("gmnawrseuvyqokbjpdilhftczx", 3);

cipher_text = padEncoder.encode(PLAIN_TEXT);

cout<<"Pad Encoded: "<<cipher_text<<endl;

cout<<"Pad Decoded: "<<padDecoder.decode(cipher_text)<<endl;

return 0;

}

A sample output of the program for the string "Hello class!" is given below:

Encoded: Uhttm xtdgg!
Decoded: Hello class!
Pad Encoded: UfTohAlrty44tqiTm2OG 95Kx3zgtrNQd1GrgD5PgKQu!koU
Pad Decoded: Hello class!

Hints:
- Comment out anything related to the padding encoder and implement the simple encoder first
- Implement the function which encodes a single char and use that to encode a string
- Once you have completed the simple encoder, implement the padding encoder one function at a time

Answer 1

copyable code:

//Include the needed files
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>

//Use the namespace std
using namespace std;

//Encoder class
class Encoder
{

public:

   //Constructor
   Encoder(const string& encryption_key);

   //Encode function
   string encode(const string& plainText);

protected:

   //encodeChar method
   char encodeChar(char c);

private:

   //Private variables
   string key;
   string alpha;

};

//PaddingEncoder class
class PaddingEncoder : public Encoder
{

public:

   //Constructor
   PaddingEncoder(const string& encryption_key, int padamt);

   //Encode function
   string encode(const string& plainText);

   //decode function
   string decode(const string& cipherText);

private:
   int padAmount;
   string charSet;
};

//Constructor
Encoder::Encoder(const string& encryption_key)
{
   //Set key
   key=encryption_key;

   //set alpha
   alpha="abcdefghijklmnopqrstuvwxyz";
}

//Encode function
string Encoder::encode(const string& plainText)
{

//declare retStr
   string retStr="";

   //Declare kk
   int kk;

   //For loop
   for(kk=0;kk<plainText.length();kk++)
   {

       //Get character
       char charC=plainText[kk];

       //Check charC is letter
       if((charC>='a'&& charC<='z')||(charC>='A'&& charC<='Z'))

           //Call function
           retStr += encodeChar(charC);

       //If not letter
       else

           //save as it is
           retStr += charC;
   }

   //Return
   return retStr;
}

//Define method to encode single character charC
char Encoder::encodeChar(char c)
{

   //Declare fg
   int fg=0;

   //Declare retChar
   char retChar=c;

   //Check c is uppercase
   if(c>='A' && c<='Z')
   {

       //set fg value
       fg=1;

       //COnvert to lower
       c=tolower(c);
   }

   //Loop to get position of c
   for(int kk=0;kk<26;kk++)
   {

       //If c found
       if(c==alpha[kk])

           //get the key character
           retChar=key[kk];
   }

   //If c is uppercase
   if(fg==1)

       //Convert retChar to uppercase
       retChar=toupper(retChar);

   //Return
   return retChar;

}

//Constructor
PaddingEncoder::PaddingEncoder(const string& encryption_key, int padamt):Encoder(encryption_key)
{
   //Set the padAmount
   padAmount=padamt;

   //Declare the character set
   charSet="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
}

//Encode function
string PaddingEncoder::encode(const string& plainText)
{

   //Declare retStr
   string retStr="";

   //Declare kk
   int kk;

   //Loop to encrypt plainText
   for(kk=0;kk<plainText.length();kk++)
   {

       //Get character
       char charC=plainText[kk];

       //Check charC is letter
       if((charC>='a'&& charC<='z')||(charC>='A'&& charC<='Z'))
       {

           //Call Function
           retStr += encodeChar(charC);
              
       }

       //If not letter
       else

           //store as it is
           retStr += charC;

       //loop to pad padAmount characters
       for(int aa=0;aa<padAmount;aa++)
       {

           //Select random number
           int tp=rand()%62;

           //Pad random character
           retStr += charSet[tp];

       }

   }

   //Return
   return retStr;
}

//Decode function
string PaddingEncoder::decode(const string& cipherText)
{

   //Declare retStr
   string retStr="";

   //Declare kk
   int kk;

   //Loop to decrypt cipherText
   for(kk=0;kk<cipherText.length();kk=kk+padAmount+1)
   {

       //Get character
       char charC=cipherText[kk];

       //Check charC is letter
       if((charC>='a'&& charC<='z')||(charC>='A'&& charC<='Z'))
       {

           //Call function
           retStr += encodeChar(charC);
              
       }

       //If not letter
       else

           //Store as it is
           retStr += charC;
   }

   //Return
   return retStr;
}

//main
int main()
{
   srand(time(0));
   const string PLAIN_TEXT = "C++ is fun!";

   // construct an encoder and the corresponding decoder
   Encoder encoder("doxrhvauspntbcmqlfgwijezky");
   Encoder decoder("gmnawrseuvyqokbjpdilhftczx");

   //Call function
   string cipher_text = encoder.encode(PLAIN_TEXT);

   //Display value
   cout<<"Encoded: "<<cipher_text<<endl;

   //Display
   cout<<"Decoded: "<<decoder.encode(cipher_text)<<endl;

   // construct a padded encoder with 3 character padding and the corresponding decoder
   PaddingEncoder padEncoder("doxrhvauspntbcmqlfgwijezky", 3);
   PaddingEncoder padDecoder("gmnawrseuvyqokbjpdilhftczx", 3);

   //Call Function
   cipher_text = padEncoder.encode(PLAIN_TEXT);

   //Display
   cout<<"Pad Encoded: "<<cipher_text<<endl;

   //Display
   cout<<"Pad Decoded: "<<padDecoder.decode(cipher_text)<<endl;

   //Pause window
   system("pause");

   //Return
   return 0;

}