```/***************************************************
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()
{
int k;
cout << "Enter key value: ";
cin >> k;

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;
}

```