Secret Code Language

I am bored to tears, so here is my attempt at writing a secret coding language.

By Stephen Paden

 

 

     1             2              3              4               5

           

ABCDE | FGHIJ | KLMNO | PQRST | UVWXY

 

 

In the above category I have sectioned off the alphabet in groups of 5, removing z altogether.

 

If we assign each letter a sub-number represented as a number behind a decimal, the first group would look something like this:

 

1.1, 1.2, 1.3, 1.4, 1.5

 

The next group of numbers would look something like this:

 

2.1, 2.2, 2.3, 2.4, 2.5

 

And so on…

 

If we were to form the word ‘Hello’, it would look like this:

 

2.3, 1.5, 3.2, 3.2, 3.5

 

However, this is problematic. It eludes to a pattern indicated by the two identical numbers 3.2 next to each other. Any code-breaker would sniff this out. It is also not very efficient. For a simple word such as hello, 19 characters are needed including the punctuation.

 

We could remove the punctuation altogether, and it would look like this:

 

2315323235

 

This is a much better example of code, but it still hints at a pattern. We could spell it backwards such as:

 

3532321523

 

The above is merely the letters, represented in numerical format, rearranged backwards. We could even go as far as rearranging the numbers backwards as well such as:

 

5323235132

 

This would make things a bit more interesting, however, but a problem exists to where the code-reader could possibly find new lettering in this format. If he were to break this code as the basic rule applies, it would read like this:

 

WHHUL

 

Not very helpful unless a sub-code would be to make letters filter through the first set of coding instructions and then take the letters from that as a product for recoding. For example:

 

WHHUL = OLLEH

 

Where as W=O, H=L, U=E, L=H

 

If this seems like a viable code system, we can work the entire alphabet into it:

 

The primer is as follows:

 

 

A=11, B=12, C=13, D=14, E=15, F=21, G=22, H=23, I=24, J=25,

K=31, L=32, M=33, N=34, O=35, P=41, Q=42, R=43, S=44, T=45

U=51, V=52, W=53, X=54, Y=55

 

Ok now that my brain is working, let’s try to form a sentence using this above method of transposing the order of the letters and the order of the numbers.

 

The newly transposed alpha-numeric system should look like this:

 

A=A, B=F, C=K, D=P, E=U, F=B, G=G, H=L, I=Q, J=V, K=C, L=H, M=M, N=R

O=W, R=N, S=S, T=X, U=E, V=J, W=O, X=T, Y=Y

 

 

This presents a problem because the letters fall into each other such as k=c and c=k. In the name of clarity, we would need a clear separation of the letters and their context within the secret message. An argument can be made that we don’t even need the primer at this point, because we have transposed the letters and the numbers are now irrelevant. This would be true if the message were completely written in Alpha. We will incorporate an alpha-numeric message, but we will get to that later.

 

So, to clear up the mess I have created, I will need to create yet another sub-code. My brain is already hurting and what started out as a fun little adventure into the world of cryptography, is becoming a pain in the ass. But I will see it through.

 

Ok.

 

Let’s address the most common problem of A=A. In order for our system to work the way any code system is intended to work, I will need to rework the letters that equal themselves, and put them into a sub-class of code that will hide them.

 

So far, we have:

 

A=A, G=G, M=M, S=S, Y=Y. The easiest thing to do is to simply remove them from the code, but the practice of removing certain letters from any encoded message has already been done, and should be anticipated. Instead, I propose that we assign each letter it’s own sub-letter. Being a sucker for patterns, I notice that there are 5 of these letters that need addressing. I also notice that there are 5 common vowels in the alphabet

 

So we can assign a vowel to each set and hope for the best:

 

  A         E          I        O        U

A=A   G=G    M=M   S=S    Y=Y

 

But, oh no, A still equals A! No problem. We will simply reverse the order in which they occur.

 

  A          E         I        O        U

Y=Y     S=S    G=G   M=M   A=A

 

Head hurt yet?

 

Ok, let’s take our amendment to the same-same letters and add them to the finished code and it should look something like this:

 

A=U, B=F, C=K, D=P, E=U, F=B, G=I, H=L, I=Q, J=V, K=C, L=H, M=O, N=R

O=W, R=N, S=E, T=X, U=E, V=J, W=O, X=T, Y=A

 

What? Now we have labeled the problem letters with letters already corresponding to other sets! That is ok, for the newly changed letters, we will simply underline them to add another layer of encryption. Why not, right?

 

The new-new code should look like this:

 

A=U, B=F, C=K, D=P, E=U, F=B, G=I, H=L, I=Q, J=V, K=C, L=H, M=O, N=R

O=W, R=N, S=E, T=X, U=E, V=J, W=O, X=T, Y=A

 

Ok, I think we are almost there. Let’s try a sentence:

 

Encryption: XLU UUIHU LUE HURPUP

 

You can also mix it up by slurring the words into each other so the structure is not the same as it would be normally.

2 thoughts on “Secret Code Language

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s