Caesar Cipher

March 11, 2014

Here is our solution, which can be used for both enciphering and deciphering:

(define (caesar n str)
  (define (char-plus c)
      (if (not (char-alphabetic? c)) c
        (let ((i (- (char->integer (char-upcase c)) 65)))
          (string-ref alpha (modulo (+ i n) 26))))))
    (list->string (map char-plus (string->list str))))

Deciphering is the negative of enciphering:


You can run the program at

Pages: 1 2

9 Responses to “Caesar Cipher”

  1. ritesh bhatia said

    What should be the cipher key ?

  2. 3coma3 said

    the key is the shift distance

  3. Daniel said

    Here’s a solution in Julia. There’s also a one-liner, encipherOneLiner.

    function encipher(s, key)
        function shift(c)
            if isalpha(c)
                char(mod((int(uppercase(c)) - 65 + key), 26) + 65)
        map(shift, s)
    function decipher(s, key)
    function encipherOneLiner(s, key)
  4. Graham said

    The Caesar cipher shows up in Graham Hutton’s *great* book on Haskell.
    Here’s a version similar to @Daniel’s:

    import Data.Char (chr, isAsciiUpper, ord)

    shift :: Int -> Char -> Char
    shift n c | isAsciiUpper c = chr $ a + ((n + (ord c – a) `mod` 26))
    | otherwise = c
    a = ord ‘A’

    caesar :: Int -> String -> String
    caesar n = map $ shift n

    main :: IO ()
    main = mapM_ putStrLn [p, c, p’]
    c = caesar 3 p
    p’ = caesar (-3) c

  5. Graham said

    Apologies for the crap formatting. Apparently I’m really out of practice!

  6. JP said

    Racket / Rackjure

    (define (caesar str n)
      (define A (char->integer #\A))
      (define a (char->integer #\a))
       (for/list ([c (in-string str)])
           [(char<=? #\A c #\Z)
            (~> c char->integer (- A) (+ n) (mod 26) (+ A) integer->char)]
           [(char<=? #\a c #\z)
            (~> c char->integer (- a) (+ n) (mod 26) (+ a) integer->char)]

    Full writeup:

  7. Mike said

    python solution:

    class SubstitutionCypher:
    	def __init__(self, mapping):
    		self.encode_map = mapping
    		self.decode_map = {v:k for k,v in mapping.items()}
    	def encode(self, cleartext):
    		return cleartext.translate(self.encode_map)
    	def decode(self, cyphertext):
    		return cyphertext.translate(self.decode_map)
    class CaesarCypher(SubstitutionCypher):
    	from string import ascii_uppercase
    	def __init__(self, key, alphabet=ascii_uppercase):
    		key %= len(alphabet)
    		shifted = alphabet[key:] + alphabet[:key]
    		super().__init__(str.maketrans(alphabet, shifted))
    CaesarCypher(3).encode('PROGRAMMING PRAXIS')    # => SURJUDPPLQJ SUDALV
    CaesarCypher(-3).encode('SURJUDPPLQJ SUDALV')    # => PROGRAMMING PRAXIS

    To bring the cypher up to the current century, we can use an alphabet containing all the uppercase Unicode characters.

    import unicodedata as ud
    alphabet = ''.join(c for c in map(chr, range(0x10FFFF)) if c.isupper())
    CaesarCypher(432, alphabet=alphabet).encode('PROGRAMMING PRAXIS')    # => ՇՉՆԾՉԸՄՄՀՅԾ ՇՉԸՏՀՊ
    CaesarCypher(-432, alphabet=alphabet).encode('ՇՉՆԾՉԸՄՄՀՅԾ ՇՉԸՏՀՊ')    # => PROGRAMMING PRAXIS
  8. shlomy said

    def CeaserC(word,offset=1):
    #final=[chr(ord(i)+offset) for i in word]
    return (”.join([chr(ord(i)+offset) for i in word]))

    def Ceaserback(word,offset=1):
    #final=[chr(ord(i)-offset) for i in word]
    return (”.join([chr(ord(i)-offset) for i in word]))

    print (CeaserC(“thisisatest”,1))
    print (Ceaserback(“uijtjtbuftu”))

  9. Here’s a Java solution:

    import java.util.HashMap;
    public class CaesarCipher {
      private static final char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
      private HashMap<Character, Character> cryptTable;
      private HashMap<Character, Character> decryptTable;
      public CaesarCipher(final int shift) {
        this.cryptTable = buildTranslationTable(ALPHABET, shift);
        this.decryptTable = buildTranslationTable(ALPHABET, -shift);
      public String crypt(final String plainText) {
        return translate(this.cryptTable, plainText);
      public String decrypt(final String encryptedText) {
        return translate(this.decryptTable, encryptedText);
      private HashMap<Character, Character> buildTranslationTable(final char[] alphabet, final int shift) {
        HashMap<Character, Character> translationTable = new HashMap<>(alphabet.length);
        for (int i = 0; i < alphabet.length; i++) {
          Character plain = alphabet[i];
          Character translated = alphabet[mod((i + shift), alphabet.length)];
          translationTable.put(plain, translated);
        return translationTable;
      private String translate(final HashMap<Character, Character> translationTable, final String text) {
        StringBuilder translatedText = new StringBuilder(text.length());
        for (int i = 0; i < text.length(); i++) {
          Character plain = text.charAt(i);
          Character translated = translationTable.get(plain);
          if (translated != null) {
          } else {
        return translatedText.toString();
      private int mod(int a, int b) {
        int r = a % b;
        if (r < 0) { r += b; }
        return r;
      public static void main(String[] args) {
        CaesarCipher cipher = new CaesarCipher(3);
        System.out.println(cipher.crypt("PROGRAMMINGPRAXIS"));    // -> SURJUDPPLQJSUDALV
        System.out.println(cipher.decrypt("SURJUDPPLQJSUDALV")); // -> PROGRAMMINGPRAXIS

Leave a Reply

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

You are commenting using your 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


Get every new post delivered to your Inbox.

Join 701 other followers

%d bloggers like this: