×
-85(5 /1)^%35=&^%1-9$51‡/85)5-(^7#^4x-5)#9+549%&51359-/1)49(-x69#-8x1%4/8^##x=%)1%9-1(x-8=)-85-(^7#^4x-5)4943^%)945(381%79%72=-81+9%7^%#x49)3^+5(54)*=1(5/855#)$^+9%7/1)1(1-85(&19%6=#&r^35))6^(=%1-5#x6^)-85$^3t17^%/855#)^665(9%7$=38)$^^-85(-(1%s&^(-/5(5!=)-1(^=%4-833^(%5(2=-1##-89) /1(&=(5#x13145$931-851)-5(^94#^^$54%51(5(

The first nine letters are rreplaced by the first nine numbers.
The next ten are replaced by the ten symbols above the base-10 digits on a keyboard.
The next four are replaced by -, =, + and /, in that order.
The last three are locally shifted left by one.
Yes, this is all hand typed.

×^h^rt s?w’ ^nc4 n%4u ? ^imt ? ^l?c% ^h^rw sroglodyt^t div^l ni ^^?c%+ Ti s?w yirtyd' yilthf' dn? yhollw yns?nit?ru+ Shut^ ^ht sroglodyt^t did ronsid^c gh?nginc’ tub g?vinh ynlo 1iscov^r^1 ^qu?rs sh^^lw’ govinm s?w ? 2?th^2 l?infu% sroc^s%+

Changed first letter with the last, except in one or two word where it was impossible, using ' as , and + as . Same symbol or numer (like%,^ or 1) means the same letter.

×
[%y343cvbnm2qwkvbnmc9hd3bnmcv709hnmcvbqmcvbn58j3kcvbnmqvbnmc0oqd3bnmcv2y343nmcvb
549to9e653wmcvbno8f3ecvbnm8hvbnmc03qd3lbnmcv*5nmcvb2qwmcvbne8456kcvbnm
r8o5y6kvbnmcqhebnmcv2y9oo6nmcvb7hwqh85q46lmcvbn%y7wkcvbnm5y3vbnmc
549to9e653wbnmcve8enmcvbd9hw8e34mcvbndyqht8htkcvbnmg75vbnmcyqf8htbnmcv
9ho6nmcvbe8wd9f343emcvbnw17q43cvbnm2y33owkvbnmcj9f8htbnmcv2qwnmcvbqmcvbn
4q5y34cvbnm0q8hr7ovbnmc049d3wwl[


This is a simple keyboard shift encoding. Every keystroke is shifted one space higher on the keyboard. So 'a' maps to 'q'. The space bar is a special case, since it has five keys above it 'cvbnm'. Since the keys aren't used for anything else, any ordering suffices. In the above coding, I simply rotated it, so the first space was 'cvbnm', the next was 'vbnmc' and so on.

Some may choose to complain that this encoding doesn't permit encoding of numerals...it's true, but hopefully nobody will ever try to use this for anything, so I'm calling it moot.

×railwpsa spsigli ngnaragtnira ,aiavilr rtnhopsaby Iacmsptu.w s liht ate.nr,a
re Tsr reuesrarhh oanec dlil audg wohayiepspvsilta pwelsespai,roisTeu plnhlin
tdm,hr e oowangtyye eecnhc rf h,t,ocaiw eiuoe e nl drpln fsapddias lti endul
pyrllva qar oti ssrodgh,e icilytdpesoyesscdrlsoea.vrsip




The railwpsa method consist of writing the text in a spiral starting from the center, padding the text so it makes a square with an odd side length, and then reading it in diagonals, starting from upper left. The details are as follows.

Where the text begins is the center of the spiral. First I go right from there and then continue wrap the text around clockwise. When it runs out, I pad the spiral with the word 'spiral' repeated and run together until I get to the the upper right corner. For this text, this makes for a 17 x 17 square with the initial T in the center.

Next I read the text in consecutive diagonals, starting from the upper left corner. The diagonals start from the first yet unread letter and go down and left. Thus the coordinates of the first few diagonals are as follows:

Just upper left corner: (1,1)
Next line of two chars: (2,1) to (1,2)
Next line of three chars: (3,1) to (1,3) (via (2,2))

and so on, until I finish in the bottom right like so

(17,15) to (15,17) and (17,16) to (16, 17) and lastly, (17, 17).

As a result of this, the initial letters of the plaintext is put right at the middle of the ciphertext. That is the capital 'T' in 'roisTeu' in the ciphertext here.

This gives the encrypted text, which I have broken into lines of 78 characters in a cheap attempt to confuse the cryptanalyst .

Now to decrypt it. Counting the letters and other characters carefully, we find that the message consists of 289 characters, which implies it fits into a square of 17 x 17 spots. We start filling these from the upper left corner in the same order they were read originally. Thus I first put the initial 'r' into the top left corner. Then I write 'a' to the right of it and 'i' below. The third diagonal consists of the three letters 'lwp', and so it goes until I fill the square, writing the last letter in the bottom right corner.

Then it is a matter of just reading the text starting from the center square, going right once and then following the unread letters clockwise. It should be the original text to the letter, unless I made a mistake somewhere along the line. I did double-check by noting that many letters ended up exactly where they should have.

I hope you enjoyed puzzling this one out. The spiralspiralspiral filler was meant as a little hint, because it ended up as a part of the initial string railwpsa.

×


Solution:

×
E34 2Xa iQjX 2Xh5w X0Qh X 5|j iQjX X 0o3w @34 54(toXe|5w o*fe *h 08w 0848Xe *5 2Xa e$58 iQjX rO%8 iQjX Mhe y9o8 XhwMh*5348 0848Xe EXw iQjX EX 54(toXe|5w e*e iXhw*e$ D3hu8H iQjX gX5 yMf*H 9ho8 e*wiXf$e wi234 @8oa iQjX j7f*H 2Xa X 4ME$ 03hrO 04Qw#w 0848Xe

This is really just a cryptogram, though as the astute reader might have picked up from the initials of the parenthetical remark, it's an IPA cryptogram: that is, it uses the International Phonetic Alphabet, or at least an ASCII approximation. (Note that there are standards for that, but I didn't really use them. This is just my own transcription.)

The text in IPA reads: Der w@z kAm@ w@nts @pAn @ t|m kAm@ @ ples Wer trOgl@d|ts lIvd In pis piri@d It w@z dRti kAm@ fLTi kAm@ &nd holi @ns&nIteri piri@d D@s kAm@ D@ trOgl@d|ts dId k@nsIdR CenjiN kAm@ b@t h&vIN onli dIsk@vRd skwer Wilz kAm@ muvIN w@z @ r&DR penfL prAsEs piri@d. Lowercase consonants are pronounced as you'd expect. Other correspondences are: @ = schwa (the sound in "was" or "but"), D and T = the two "th" sounds, N = "ng", R and L = "syllabic" versions, C = "ch"; e, i, o, u = the Romance language sounds of the letters, as in "bane, bean, bone, boon"...well, you get the idea, probably. Also, in order to preserve punctuation, "comma" and "period" have been spelled out.

Pronunciations are mine, so for instance "process" has an "ah" sound and not an "oh" sound. Your dialect may differ.

To encode the IPA text, I just used the next key up on an American keyboard, wrapping as needed, so that e -> 3, E -> #, @ -> X, and so on. Except for |, which I used for the "long i" in English; I left that as it was. (EDIT: I finally decoded jbluestein's and discovered that he also used the technique of moving up one space on the keyboard, and similarly preserved the shift key. Out of a sense of fairness, I won't change my encoding now; please do take into account that we hit on the technique independently.)

×
Rgzrcftiv,dgb-lfvqciisg-fil,oabjijcbjtbuxbituhalpaxsqsaiodeaiijks-jua.iRtatf-leiixf,uds-thy,aaebjkdyroocwlgdcot-ut.rKhus,fbhbituhalpaxsqrajiccdpbuajfir-ogjouio,uhct-fgvjkatinnsaccseitlo-luwgofakfehamxs,ajpucioutiv--ct-ebuxcfdleful-ptiblgr.-i

Note: the hyphens denote spaces in the code text. The line breaks mean nothing in the code.


Assign each letter a value: a=1, b=2, c=3, ... z=26. Let a space equal 0 and ignore punctuation, leaving it in place.

Convert each letter and space to base 3. The first three letters 'The' become 202, 022, 012.

Take the values three at a time and create three new values by taking the first digit of each, the second digit of each, and the third digit of each: 200 021 222

Convert the numbers back to letters to get 'Rgz'. The same process can be used to decode the message.

R G Z
T 2 0 2
H 0 2 2
E 0 1 2

×Twouatapwlip-hanp_i_lhrine-esco_m_aeov_a-r,en_e_crge_c-e____,_eeld_e-_________o__.-_________d___-_________y___-_________t___-_________e___-_________s___--Iwdfawu-taiinhn-_srldos-__tt_la-__yh_ln-__,y_yi-___,__t-______a-______r-______y-______.--Tttdccbhodswmwarpp-hhriohuaniqhoa_aar-ueodnatvlsuevs_tio-s_g_sn_iycaei__hnc-,_l_ig_n_orln__efe-__o_di_g_vesg__rus-__d_en___e_,____ls-__y_rg___r_______.-__t__,___e________-__e______d________-__s_______________


Click here to view the secret text
×each letter in the first line before the first hyphen is the first letter in the first sentence. the hyphen seperates the first and second letter sets. the underscores are representing letters of the word that it would be part of is too short. the punctuations are added to the end of the word that they go after. the double hyphens seperate sentences

×Issecorp. Flufniap Prehtar a saw Ignivom Esleehw, Perauqs derevocsid Zylno Agnivah Stub Agnignahc, Credisnoc did Esetydolgort Ceht PsuhT, Tyratinasnu. Wyllohw Edna Byhtlif, Pytrid, saw EtI Decaep. Ani devil Esetydolgort Jerehw ecalp a emit, a nopu Tecno saw, PerehT.


How to decrypt the message:

1. Remove the last dot.
2. If a word starts with a Capital Letter, remove that letter.
3. Reverse the text.
4. Move the dots and commas back to the end of the word.

This encryption is intentionally meant to be easy.

×'Tharperarpe warpas, arponcarpe arpuparpon arpa tarpimarpe, arpa plarpace wharperarpe trarpoglarpodytarpes larpived arpin parpearpacarpe. Arpit warpas darpirty, farpilthy, arpand wharpolly arpunsarpanarpitarpary. Tharpus, tharpe trarpoglarpodytarpes darpid carponsarpidarper charpangarping, barput harpavarping arponly darpiscarpovarperarped sqarpuarpararpe wharpearpels, marpovarping warpas arpa rarpatharper parpaarpinfarpul prarpocarpess,'

Does not include solution text

×
5Gynd34f3d~s2qzxw*<~9lh^#d3d~7j0:9lh^~zq~5g8kj&d3<*~qz_0:o>zqd#3d~2syn3d4fd3~5gf49ltbo>9lec6hg53dwx~>ok8f$d3ec~k8h^~0:3dqzd#d3>(~K85g~2szqxw~eck84fg5h6<*~vr8k>o5gynh6*>~zqh*ec~2syn9l>oo>h6~j7^hxwzq^hk85gzq4fh6>(~5Gnyj7wx<*~g5yn3d~5gf49lbto>9lceh6g5d3xw~cek8ec~d#9l^hwxk8ced3f4~#dnyzqh^bt8k^hbt*>~g%7j5g~ynzqf$8kh^tb~l9^h>oh6~ec8kxwd#9lf$3d4f3dce~xw1aj7zq4f3d~s2nyd33d>owx<*~&j9lf$8kh^tb~s2zqxw~zq~f4zq5gnyd3f4~�:zq8kh^rv7jo>~�:4fl9d#d3wxxw>(





Step 1: Draw a diagonal through the letters on the qwerty keyboard as shown in the attachment (which I will add when this is public).

Or as an example draw a line down through !1qaz which then wraps back on itself. Each diagonal section stands alone except the end which goes to the space bar and then back to ~.

Step 2: Each letter or symbol is made up of 2 symbols each, look along the diagonal line for the symbol or letter adjacent to it. These two symbols can be in any order you like except when you code the letter p, see step 3 below.

Examples: g is represented by either bt or tb both are accurate.

Remember the line wraps around. So the letter "x" is represented by either s@ or @s

Punctuation is just like a letter. So, period is represented by <* or *<

Step 3: Show it is a Capital letter by capitlizing one of the 2 symbols that represent it. It does not have to be the first letter. The only exception is the letter "P" which is only adjacent to symbols which do not reflect capitalzation so for p there is a special rule. If the zero is first is is lower case if the simi-colon is first then it is a capatial P.

Step 4: Seperate each word by either ~ or ~ the space falls between them.


Fixed the errors Tahnan pointed out plus a couple more, thanks Tahnan.

×
[%y343 2qwk 9hd3 709h q 58j3k q 0oqd3 2y343 549to9e653w o8f3e 8h 03qd3l *5 2qw e8456k r8o5y6k qhe 2y9oo6 7hwqh85q46l %y7wk 5y3 549to9e653w e8e d9hw8e34 dyqht8htk g75 yqf8ht 9ho6 e8wd9f343e w17q43 2y33owk j9f8ht 2qw q 4q5y34 0q8hr7o 049d3wwl[

Type as if on a qwerty keyboard, but shift the keys up by one row. To decode, place your hands down one row and retype the message.

×
WTOWW AP.PZ ,VFJY ZTNYP NPVOR RFNYM TEGSN RTMOR TNWWT PMTLR Z,TBZ OJJWZ FWLWV TVOYL LMMZI OEWPP MNMNW NMMYP YGZIW NBBFF VWBZW SMBFT LGYRB BRSSW ZTYKB WZ.NP LBNHR TNGZL ,YCTV Z,WET LOTAY MKBE, LVSMS ODLWW OGERW BKTYE NMR,B L,WBJ KOMZB YOEKK M

I just realised that I forgot the final full stop but I can't be bothered to code it all over again.
Hope it doesn't matter.
Solution:
Click here to view the secret text
×
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.

×uY,qROHhWVSDqPtqhTEroLI.gPtspMJygDfGDzdEvWTJ lOzkKFyZOLwbTxXU,mjVzWyZXUcSPIiXUxcQGBA cHsiMHGDdNqngKygOJG kZzjOEeSNLIbFzonkaEifVJxaIwWRHlaX fFCeP,rWzaOLnRrbEmW,.yWNDAhEzeOurcMxspPxmLzrSGkKHzmdArSPIpQucRQNzkcHuXUNncZzwkH eFwtfCkUzqYVHyjImbQO

Here is a not-so-brief explanation of the cipher I thought of.

Click here to view the secret text
×
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.

×

meaeticnssnarTenheiaeip tuvogc icehe etdo roby, thsdsad,rt.aivwpm dyn aiho,  aedr rea vs nw  tlg,lsr yIo wgt.ce usngldn uy.iw al  odaflioieopvfrgen  nTwosphn l eui tneirsshad, ysuiqaaha ,l cyn golot sdutpwhey ecsthc  hae,dl  olanert ererr i

This is a more "human-friendly" cipher, compared to my previous entry.

Click here to view the secret text
×
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.

×

% ^^ # $ # = @ !! @@ = ( ^^^ ### # = & ) ( ^^^ = !! = % * &&& # = !! = ) (( !! ### # = @ ^^ # $ # = % $ ( %% (( ( ## ^ % # @@ = (( * $$$ # ## = * ^^^ = ) # !! ### # = * % = @ !! @@ = ## * $ % ^ = $ * (( % ^^ ^ = !! ^^^ ## = @ ^^ ( (( (( ^ = & ^^^ @@ !! ^^^ * % !! $ ^ = % ^^ & @@ = % ^^ # = % $ ( %% (( ( ## ^ % # @@ = ## * ## = ### ( ^^^ @@ * ## # $ = ### ^^ !! ^^^ %% * ^^^ %% = %%% & % = ^^ !! $$$ * ^^^ %% = ( ^^^ (( ^ = ## * @@ ### ( $$ # $ # ## = @@ ! & !! $ # = @ ^^ # # (( @@ = &&& @ !! = @@ = $ !! % ^^ # $ = ) !! * ^^^ $$ & (( = ) $ ( ### # @@ @@

On your keyboard, look at the numbers above the letters, and look at their shift. One symbol means one case down the line, ! being Q, @ being W, and two means two down, three means three, etc. Like %% being G.

I don't expect this one to be too tough, though fun.

×

MB_VOFSJWW;?OPZM"E"A.Z’TPHTR"AIYGSPZP’M?"TPZPYCZS_P(:_L_P’LH;"G.,’"LP"MQ".PDTAX_YR"FPDZA.Z’A?DL’,TP;M"ZM,TPZT.P(:HV",AIS’ZTDZZLNKAZMILAAZM"AZEG:VH?NZ_’A?D?ASHTLM."EPR:ZT:MS;TPII’PMYQMS;AGSVNP.MLSHR_L_?A’XIZL_PP:_""’TP?GQMS;A.Z’AYALZZM"EPYYDT;I"PYLHS_’LKXMSN?IHJ(PBN

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.

×their was, onece apon atime, a place were trogodites livved in piece. ti was dirty,
fillty, and holly unsanitery. thus, teh trogodites did considerd chenging, but haveing
only discoverd square weels, moveing was a rathr painfull proces

How to decrypt the text:

Easy, just ask a proofreader That basically means fixing all the spelling mistakes, punctuation, and adding captials at the beginning of each sentence. If you don't know how to fix it, look at the original text for help.

(I can tell you that writing the text was a rather painful process.)

PS. This encryption is based on some PMs I have that were written like this and I couldn't understand it.

×
There was. once upon a time. a place where troglodytes lived in peace, It was dirty. filthy. and wholly unsanitary, Thus. the troglodytes did consider changing. but having only discovered square wheels. moving was a rather painful process,

Substitute all commas with full stops, and all full stops with commas.

×

ehert saw+ enco npou a eimt+ a elacp eherw sroglodytet divel ni eeacp? ti saw yirtd, yilthf+ dna yhollw ynsanitaru? shuT+ eht sroglodytet did ronsidec ghanginc+ tub gavinh ynlo discovered equars sheelw+ govinm saw a rather lainfup srocesp?


Changed first letter with last and used + as , and ? as .

×
Please note: The only significance in the fact that all the Ls, and no other letters, are uppercase is to make them easier to distinguish from the numeral one.

jyr1L 4pk1a4p1c9zo 1asxzkryct4fs1d9zckszhdzpa0k
zcr1Ld2c0 gzsi0 1pdv17z06pkwpzc1t0
j6k j1ct4fs1d9zckdzde1pkzd1cmxzpdnzq b1cvwhzq17ps0dzke6h1dkeryr0sL o8hzqr1k1t3j1axzpg1sat17kxk

Click here to view the secret text
×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.

×
Thereaw pyda so, tery nceu awfonda pona remb it pilde mea, fgu apl trazt ceewh ister reotr byten glodytesil yinge vedi pold nep se aceI. Ormen taw ye sid repollent rtyif, errhy lthya, gruwth ndowh perdw llyu puccha nsanitaryuTh. Aattji seth, teph otr aefyggh glodytesid carv doc blaidd nsiderach wwye ngingub, o tah sewgheng vingo art nlyid or scoveredusq eddrih areewh trmoo elsom, reg vingaw po sa gwnug ar kilpr therap yfor infulopr ightac cess.

Decode in two steps:
1 – Remove every second word and following space from the text.
2 – Switch each space, together with any directly preceding punctuation mark, with the last vowel of the previous word.

×
"@)rah% @u@, !cn! @py! * @)ym%, ! !loc! @rah( @)galdiytra! @yve% (! @)yyc%. (@) @o@ ^otr@, !athl@, &n$ @lylh@ @snutarin#. @ho@, @h* @)gylduytre! !o& #asdene! !nognah*, @a@) *iniv& !ln#) $acviroso$ !rauq! @liyh@, !inav! @e@ ( !ahte@ @iafno! !rasycs@*."

For the moment, this is going to be impossible to solve without using brute force. I will edit this tomorrow to avoid being late for the contest. Sorry if this causes any irritability.

Click here to view the secret text
×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.