×
I have been continually playing contest on the forum since Dec 2004. Having often been addressed as a he my new avatar shows that I am a "Lady". And one with a very sharp sword, too.

I love the monthly contests but it took me a long while before I even placed. 21 contests in fact.

Virtual Burning Man was the first contest I took any place in and I got 1st, wow!. Yes, I have received my prize, a sweatshirt from the DROD store, and I love it.

It took 14 more contest but next I took 1st prize in Media of the Eighth Nov07, followed by a win in the Secret Santa 2007. Check out my entry: http://www.gailswebplace.com/NightSky/index.html

Suddenly I was a winner but, still the goal of a winning hold based contest eludes me....

I keep trying so come and join me.
http://forum.caravelgames.com/viewboard.php?BoardID=83

×
To code this I wrote the message into a grid, and read down the columns (rearranged slightly.) The key that I used was the first sentence, so there are 13 columns (13 words in the sentence). To unjumble, divide 201 (number of letters) by 13 = 15 with 6 letters left over. I rearranged the colums according to the alphabetical order of the words in the first sentence, so write the coded message into columns marked with their respective word's place in the alphabetical order. The extra letters went into the first 6 columns, so columns marked 1 to 6 have one extra letter. Then rearrange the columns so that they are in the correct order, and read across the rows.
Oh, and maybe I should mention, I also used a simple substitution cipher with the first sentence also as the key:
THERWASONCUPIMLGDYZBFJKQVX
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Replace each of the letters in the top row with the corresponding letters in the bottom row.
You should get:
T H E R E W A S , O N C E
U P O N A T I M E , A P L
A C E W H E R E T R O G L
O D Y T E S L I V E D I N
P E A C E . I T W A S D I
R T Y , F I L T H Y , A N
D W H O L L Y U N S A N I
T A R Y . T H U S , T H E
T R O G L O D Y T E S D I
D C O N S I D E R C H A N
G I N G , B U T H A V I N
G O N L Y D I S C O V E R
E D S Q U A R E W H E E L
S , M O V I N G W A S A R
A T H E R P A I N F U L P
R O C E S S
As you can see, the first 16 letters of the coded message are the 5th column, the next 15 are the 7th column, etc.

×
Components of the cipher:

1) The plaintext alphabet. It defines, what characters can be used in encoding of a message.
2) The cipher alphabet. This will be clarified in the example.
3) The original message. It must contain only the characters from the plaintext alphabet.
4) The encoded message. It too, must contain only the characters from the plaintext alphabet.

Contest's message was encoded using alphabet "ABC...XYZabc...xyz .," (uppercase letters + lowercase letters + punctuation). Note the space between lowercase z and the period.

The example, used in explanation

For the sake of simplicity, I will use the following example throughout all my explanations:

Plaintext alphabet: "ABCDEFG"
Original message: "FBCDA"
This message is encoded to "BCEAA".

Encoding and decoding explained

Encoding procedure is very simple:

1) Produce the initial state of the cipher alphabet. Take the plaintext alphabet, split it in half (if its size is odd, make sure the left side is the smaller one), swap these two portions together and join it again.
Example: "ABCDEFG" -> "ABC", "DEFG" -> "DEFGABC"

2) Take the first character from the original string and find its position in the plaintext alphabet.
Example: "F" is the 6th character in the plaintext alphabet.

3) Substitute this character with the character in the cipher alphabet, whose position you have found in the previous step.
Example: "F" becomes "B", because "B" is 6th in the cipher alphabet.

4) Split the cipher alphabet at the character you have just used, swap the two portions and join them again.
Example: "DEFGABC" -> "DEFGA", "BC" -> "BCDEFGA"

5) If the original string isn't fully encoded yet, move on to the next character and go to step 2 with the new cipher alphabet.

The example is encoded like this:

ABCDEFG -> ABCDEFG -> ABCDEFG -> ABCDEFG -> ABCDEFG
DEFGABC -> BCDEFGA -> CDEFGAB -> EFGABCD -> ABCDEFG

  [B]        [C]        [E]        [A]        [A]

To decode the message you should follow exactly the same procedure as above, except you should substitute original message with the encoded message (and vice-versa) and in steps 2 and 3 subsitute plaintext alphabet with the cipher alphabet (and vice-versa).

Encoding a message with pen and paper

It is far simpler to maintain the cipher alphabet as an offset from the plaintext alphabet. I.e. the amount of characters you should move to the right, in order to get a corresponding letter from the cipher alphabet. So, here is a way to encode a message using offsets:

First, write the alphabet and number all the letters in order, starting with a zero. This way 'A' becomes 0, 'B' becomes 1 etc. Now, take the length of the alphabet and divide it by 2 (drop the remainder, if any). This will be the initial offset.

Now, take the first character of the message and find it in the alphabet you wrote down before. Add its number to the offset and calculate the sum modulo alphabet's length. The result is the offset for the next letter in the message AND it corresponds to the first character in the encoded string. Repeat this until you encode the entire message.

The example string is encoded like so:

A B C D E F G      Initial offset is 7 / 2 = 3.
0 1 2 3 4 5 6      Length of the alphabet is 7.

 Original  |        |                 | Enc. 
char (pos) | Offset |    New offset   | char 
-----------+--------+-----------------+------
   F (5)   |    3   | (3 + 5) % 7 = 1 |   B  
   B (1)   |    1   | (1 + 1) % 7 = 2 |   C  
   C (2)   |    2   | (2 + 2) % 7 = 4 |   E  
   D (3)   |    4   | (4 + 3) % 7 = 0 |   A  
   A (0)   |    0   | (0 + 0) % 7 = 0 |   A  

Decoding a message with pen and paper

As with encoding, write the alphabet and number all the letters in order, starting with a zero. Find the initial offset by diving length of the alphabet by two and dropping the remainder.

Now take the first character of the encoded string and find its numeric value in the alphabet. Add alphabet's length to it and subtract current offset. This value modulo alphabet's length will correspond to the first letter in the original message. The offset for the next letter equals the numeric value of the current encoded letter. Repeat this for other characters in the message until you decode it all.

Decoding the example goes like this:

A B C D E F G      Initial offset is 7 / 2 = 3.
0 1 2 3 4 5 6      Length of the alphabet is 7.

 Encoded   |        |                     | Orig
char (pos) | Offset |  Original char pos  | char
-----------+--------+---------------------+-----
   B (1)   |    3   | (1 + 7 - 3) % 7 = 5 |   F
   C (2)   |    1   | (2 + 7 - 1) % 7 = 1 |   B
   E (4)   |    2   | (4 + 7 - 2) % 7 = 2 |   C
   A (0)   |    4   | (0 + 7 - 4) % 7 = 3 |   D
   A (0)   |    0   | (0 + 7 - 0) % 7 = 0 |   A

And now you know.

×#4365

Progress in game:
DROD:AE - Complete
DROD:JtRH - Mastered
DROD:TCB - Mastered

DROD:SS - Perfection - Perfection 4
DROD:SS - Smitemastery 101 - Mastered
DROD:SS - Master Locks - Mastered
DROD:SS - DDDD - Conquered (67%)
DROD:SS - Suit Pursuit - Mastered

DRPG:TT - Conquered (62%)

×
Components of this cipher

1) The original message.
2) The encoded message.
3) A lattice of crosses, used to shuffle letters.

Making the lattice of crosses

You will have to make a lattice of crosses in order to use this cipher. First, get some graph paper. Then, find the length of the message you want to encode, divide it by 5 and take the ceiling of that number (ceil(13/5)=3, for example). That is the amount of crosses you will have to draw.

One cross looks like this (you will have to place one character in each space later):

[ ]   [ ]
   [ ]
[ ]   [ ]

Begin drawing crosses in the following pattern, until you have the amount needed:

X--X  X--X  X--X
   |  |  |  |  |
X--X  X  X  X  X
|     |  |  |  ...
X--X--X  X  X
         |  |
X--X--X--X  X
|           |
X--X--X--X--X

Thus, if you want to encode a phrase "Quick brown fox jumped over a lazy dog." (whose length is 39 characters), you will have to make yourself this lattice:

[ ]   [ ]   [ ]   [ ]
   [ ]         [ ]
[ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[ ]   [ ]   [ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[ ]   [ ]   [ ]   [ ]   [ ]   [ ]

Encoding a message

Once you have the lattice, you can begin encoding. Start by filling the top row of empty cells with the beginning of the message.

[Q]   [u]   [i]   [c]
   [ ]         [ ]
[ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[ ]   [ ]   [ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[ ]   [ ]   [ ]   [ ]   [ ]   [ ]

Then, fill the bottom row with subsequent characters going from right to left.

[Q]   [u]   [i]   [c]
   [ ]         [ ]
[ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[ ]   [ ]   [ ]   [ ]   [ ]   [ ]

[ ]   [ ]   [ ]   [ ]   [ ]   [ ]
   [ ]         [ ]         [ ]
[w]   [o]   [r]   [b]   [ ]   [k]

Alternate between top and bottom like this, until you have entered the entire message into the lattice. The example phrase looks like this:

[Q]   [u]   [i]   [c]
   [n]         [ ]
[ ]   [j]   [u]   [m]

[e]   [r]   [ ]   [a]   [ ]   [l]
   [g]         [.]         [ ]
[o]   [d]   [ ]   [y]   [z]   [a]

[v]   [o]   [ ]   [d]   [e]   [p]
   [x]         [o]         [f]
[w]   [o]   [r]   [b]   [ ]   [k]

Now, write the characters from the first column going bottom-up and characters from the second column going top-down.

wvoe Qngx

Repeat this for subsequent columns, until you have the entire message.

wvoe Qngxoodrjuiu   ro. cmaydb ez  fkpal

You're done.

Decoding a message

To decode a message, follow he above procedure in reverse order. Make yourself a cross lattice, fill in the encoded message in the way you read it down originally and restore the original message by reading lines.

×#4365

Progress in game:
DROD:AE - Complete
DROD:JtRH - Mastered
DROD:TCB - Mastered

DROD:SS - Perfection - Perfection 4
DROD:SS - Smitemastery 101 - Mastered
DROD:SS - Master Locks - Mastered
DROD:SS - DDDD - Conquered (67%)
DROD:SS - Suit Pursuit - Mastered

DRPG:TT - Conquered (62%)

×Explanation

I wanted an encryption method that fulfilled a few criteria, aside from the ones the contest outlined: it must not require a decryption key in advance; it should be able to be used over and over because it would be different every time; it must contain the decryption information within the message; and, of course, it shouldn’t be too easy to crack.

The method I decided upon is a variation on the very simple, and easily crackable, substitution method. It uses double substitution, with every other character using a different mapping. I’ve included the decryption key within the message, which does two things: it adds some “junk” to the message; and it gives the recipient the key to decipher the message, with no worrying over intercepted or lost decryption keys. Normally, a double substitution wouldn’t be that difficult to crack, but the addition of punctuation and my decryption key characters make this version a bit trickier. It would probably work well enough for shorter messages.

This method does require that both parties know a few basic rules, which sound more complicated than they actually are. Hopefully I can make it clear.

The rules:

1. The characters used in all messages are: all letters of the alphabet followed by the following punctuation marks: apostrophe, colon, comma, left bracket, period, question mark, quote, right bracket, semi-colon and underscore (_), to represent a space.

2. To encrypt or decrypt a message the characters are placed in a 6x6 grid in alphabetical order, beginning with the alphabet, followed by the punctuation marks. You start on the outside ring of the grid and spiral inward in a clockwise direction.

3. The first 14 characters of a message, broken into 2 sets of 7 characters, indicate the starting position for the alphabet on the grid. A letter in the first set of seven will indicate row. A letter in the second set of seven will indicate column. The first letter in each set is called the Base. Count up alphabetically six letters (since it's a 6x6 grid, this is easy to remember) from the Base letter to get a Sum letter. That Sum letter will appear in the next six letters and its position, 1st, 2nd, 3rd, etc. after the Base, indicates the row (for the first set of seven) or column (for the second set) that the alphabet would begin in on the grid.

Example:
In this message, the first 14 characters are: MB_VOFSJWW;?OP. So the first set is: MB_VOFS. M is the Base letter. Counting up 6 letters from M takes you to the letter S. The letter S is in the 6th position after the first letter. Since this is the first set, that indicates the 6th row.

The second set is JWW;?OP. Six letters up from the Base letter J is P. P is also in the 6th position, indicating the 6th column. So now I know that I’ll be starting the grid from the 6th row, 6th column. I can now fill in my 6x6 grid.

4. The text is encrypted using a double substitution method using the grid. Each character is alternately encoded and always in the following order: odd numbered characters are encoded by first moving up and then right on the grid; even numbered characters are encoded by first moving down and then left. The encryption details (how many positions up/down and right/left) are signified in the last 12 characters of the message (2 sets of six.)

The position of agreed upon letters in each set of six indicate the shifts used to encrypt a message. Vertical shifts (up/down) are indicated in the first set of six. Horizontal shifts (right/left) are indicated in the second set of six. Using the letters U, D, R and L for Up, Down, Right and Left would become obvious after just a few messages, so instead I decided to use letters already “flagged” in the message as special and which would change with every message: the Base and Sum letters from the 14 starting characters. The Base letters would be used for the "odd" shift and the Sum letters would be used for the "even" shift. The first Base letter (1st letter in the 1st set of seven characters) would indicate the Up shift and the second Base (1st letter in the 2nd set of seven characters) would indicate the Right shift. The Sum letter for Row would be used to indicate the Down shift and then the Sum letter for Column would indicate the Left shift.

Example:
In this message, we would be looking at the positions of the Base letters M and J for the odd letter shift (M used for Up and J for Right) and the positions of the Sum letters S and P for the even letter shift (S for Down and P for Left).

The last 12 characters in my message are: XMSN?IHJ(PBN. To find the shift for the odd characters (Up and Right) we look for M in the first set of six for the vertical shift, and for J in the second set for the horizontal shift. M appears in the 2nd position in the first set -- XMSN?I -- and J appears in the 2nd position in the second set -- HJ(PBN. Therefore, odd letters were encrypted by moving up 2 positions and then right two positions from the original character on the grid.

And now the even letters shift: S appears in the 3rd position in the first set and P appears in 4th spot, so they were encrypted by moving down 3 spots and left 4 spots on the grid.

5. To decrypt a message, after working out what shifts were done to encrypt the message, simply do the reverse. For example: if a character was encrypted by shifting up 2 spots and then right 2 spots, it is decrypted by moving left 2 spots and then down 2 spots. If, when shifting, you reach an outer edge of the grid you simply “loop” back from the opposite side.

×It's a subsitution cipher on the phonemic level. (Regrettably but inevitably, I had to use the variety of English I myself speak as a baseline; the phonemic representations of some words will vary in other dialects.) The following key shows the representation of each phoneme (values in X-SAMPA):

/p b t d k g f v T D s z S Z m n N w l r\ j h/
 a b c d e f g h i j k L m n o p q r s t  u v

/{ E E: I i: @ 3: a: Q O: V U u: a/
 w x y  z 0  1 2  3  4 5  6 7 8  9

Affricates and diphthongs are represented by two characters. The rare phoneme /7:/ is not represented (it did not occur in the text).

Spaces between words represent the original commas; new lines, the original full stops.

×To solve, simply change the shift-number keys into letters. Unless I've missed how to make letters appear correctly in the human mind, you (the solver) can either read the words easily or use the original text to solve.

The puzzle was firstly, scrambling the inner letters and secondly, replacing the outer letters with shift number keys in a special method.

Alright, here we go. The first letter in the code "@" is the shift key for 2. According to a simple number to letter theory, 2 can either stand for "b" or begin the letter "t". If you'll notice the next character ")", this is equivalent to "0". Add the value places together and you get "20". "20", better known as "T" starts the sentence. The next character, "%", is equivalent to "5", and is better known as "e", indicating the last letter of the sentence is "e". The next character, "@", also known as "2", doesn't necessarily have to make either "b" or "t", since any other number can take the place of the units value.

Every value over 10 causes the next front or back letter of a word to become the shift key number of the tenth place value. The units value will then be added with the next letter's number value and that next letter will become the tenth (or units, if the number is less than 10) value's shift key equivalent.

At the end, you'll notice two shift-key numbers in a row. Try to guess why this is.

×I made three mistakes that I've noticed so far. I omitted the /w/ in "once"; I misread the /l/ in "wholly" as /I/ and so represented it as "z"; and my key uses /a:/ for the vowel of "father", which should be /A:/.

(I decided to ignore the controversy over the correct phonemic representation of "wholly" and wrote it as /h@Uli:/, the same as "holy", to keep things simple. In fact I pronounce "wholly" as [h@U5i:], with the so-called "dark l", which casts some doubt over whether it should be represented as a separate phoneme.)

In hindsight, since /a/ only occurs in diphthongs, I should have used the same representation for /a/ and /{/, thus allowing all 37 phonemes to be encoded with just letters and numerals.

I apologise for the similarity of my entry to Tahnan's; for the last two weeks nearly all my free time has been given to constructing Mole Miner levels, so I had not solved his or any other of the entries before submitting mine. This is also why my entry was posted on the very last day.