/***************************************************
Ceasar-Shift Encryption on 4-Letter Messages

The "Ceasar-Shift" method of encryption scrambles
a message a letter at a time.  First we view each
letter as being represented by its distance from
the letter 'a' when we write the alphabet in a line.
So, a->0, b->1, c->2, ..., z->25.  Given a key k,
which is just an integer between 0 and 25, we map 
each letter to a new one as follows:

   if the letter is i away from 'a', then it maps
   to the letter i + k away from 'a'.  If i + k is 
   greater than 25, we simply wraparound.  The mod
   operator (%) does this wraparound for us.

So, the rule becomes:  

   If letter L1 is i away from letter 'a', then it 
   maps to the letter that is (i + k) % 26 away from 
   the letter 'a'.  

The thing to notice is that (L1 - 'a') tells you 
precisely how far away letter L1 is from letter 'a',
and for distance d, char('a' + d) is the letter that
is d away from the letter 'a'.

Ex: key = 1, message = busy, encrypted message = cvtz
***************************************************/
#include <iostream>
using namespace std;

int main()
{
  // Read in key value
  int k;
  cout << "Enter key value: ";
  cin >> k;
  
  // Read in 4-letter message
  cout << "Enter 4-letter message: ";
  char c1, c2, c3, c4;
  cin >> c1 >> c2 >> c3 >> c4;

  // Compute distances for original letters
  int d1,d2,d3,d4;
  d1 = c1 - 'a';
  d2 = c2 - 'a';
  d3 = c3 - 'a';
  d4 = c4 - 'a';
  
  // Compute distances for encrypted letters
  int ed1,ed2,ed3,ed4;
  ed1 = (d1 + k) % 26;
  ed2 = (d2 + k) % 26;
  ed3 = (d3 + k) % 26;
  ed4 = (d4 + k) % 26;

  // Compute encrypted letters
  char e1,e2,e3,e4;
  e1 = 'a' + ed1;
  e2 = 'a' + ed2;
  e3 = 'a' + ed3;
  e4 = 'a' + ed4;

  // Write out encrypted message
  cout << "Encrypted message is:  ";
  cout << e1 << e2 << e3 << e4 << endl;

  return 0;
}