A simple cryptography method is to rotate letters. Write a function to decode a sentence with the following pattern:

f -> i
h -> k
x -> a

Don't worry about upper case.

Provide the decoded message in "wkh udlq lq vsdlq vwdbv pdlqob lq wkh sodlq".

Can you do it in one line? Is this the most time-efficient way? Is your method easily reversible (that is, how much different is an encoder from the decoder)?

Answers and discussion next Monday.

---

Answers and Discussion

Here we wanted to transform a string into another through mapping. As is usual in programming we can trade time for space. In this case the space is very small, so that's probably the best solution, but let's look at a non-mapping version first:

def code(st): return ''.join([x is ' ' and x or chr(((ord(x)+3)-97) % 26+97) for x in st])

This version takes advantage of the mapping of ASCII characters to numbers, and uses the 'mod' operator for rounding the corner at the end of the alphabet. The math could be collapsed a little, but is displayed full for clarity. The magic number 97 is the ASCII number for 'a', as can be seen with

>>> ord('a')
97

There's the ternary operator in there too, since we're not mapping spaces and need to have a special case. This is nicely reversible, too, just by changing one plus sign to minus.

def decode(st): return ''.join([x is ' ' and x or chr(((ord(x)-3)-97) % 26+97) for x in st])

Now, chr and ord are probably pretty cheap operations, seeing as how the character is actually represented by that number. But we do have a little math and some boolean stuff.

Python has a great mapping type, the dictionary, so if we can stand that in memory, it has constant time access for each character.

import string
rotated = dict(zip(string.ascii_lowercase[3:]+string.ascii_lowercase[:3], string.ascii_lowercase))
rotated[' '] = ' '

Then we just have to apply the mapping. We've seen a couple ways to do this before. One simple one is::

def code(st): return ''.join([rotated[c] for c in st])

But we have a nice built-in function we can take advantage of. Kyle provided a solution with 'translate'. It looks like::

def code(st): return st.translate(string.maketrans(string.lowercase[3:]+string.lowercase[:3], string.lowercase)

The 'maketrans' method is a shortcut for how I built 'rotated' above. The string method 'translate' leaves unmapped characters untouched, so we don't have to deal with spaces. The simple translate above could be made to do this.

Creation of a reverse-lookup dictionary isn't hard, and it can apply special cases like spaces and other characters we want to preserve much more easily. If we were to add capital letters, this way would handle it very simply, but the solution above would get complex.

Jenn supplied a solution similar to my first above, but cleverly splits on words instead of special-casing the space. Here the round-the-bend problem was solved with a special test instead of 'mod'. Here's the code::

   encoded='wkh udlq lq vsdlq vwdbv pdlqob lq wkh sodlq'
   decoded=[]

   # Spaces aren't encoded, so handle each word separately
   for w in encoded.split():
     localword=''
     for l in w:
       # Handle a and b, which need to "wrap"; "a" is ASCII 97, and our offset is 3
       # If the letter's not a or b, find the ordinal
       #   that's three less and convert back to a letter
       if ord(l)-3>=97:
         localword=localword+chr(ord(l)-3)
       # If the letter three positions back is less than "a", go forward instead
       else:
         localword=localword+chr(ord(l)+23)
     # Make a list of the decoded words
     decoded.append(localword)

   # Reconstitute a string
   print ' '.join(decoded)

The one-line version is:

   ' '.join([''.join([(ord(l)-3)>96 and chr(ord(l)-3) or chr(ord(l)+23) for l in w]) for w in encoded.split()])

She also has a more general version.

Chuck also has a variant of the first way::

 ''.join(map(lambda i: (i < 99) and chr(i+23) or chr(i-3), map(lambda c: (c == ' ') and 9 or ord(c), s1)))

One other popular way to solve this is to use a list of the alphabet and increase its index instead of using ord and chr. For instance, via Chuck::

abc = 'abcdefghijklmnopqrstuvwxyz '
print ''.join(map(lambda i: i > 25 and abc[i] or (i < 3 and abc[i+23] or abc[i-3]), map(lambda c: abc.find(c), s1)))

This might be made to use 'mod' as well.