Programming Praxis

9 Responses to “Caesar Cipher”

1. ritesh bhatia said

   March 11, 2014 at 9:59 AM

   What should be the cipher key ?
2. 3coma3 said

   March 11, 2014 at 1:15 PM

   the key is the shift distance
3. Daniel said

   March 11, 2014 at 9:00 PM

   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)
           else
               c
           end
       end
       map(shift, s)
   end
   
   function decipher(s, key)
       encipher(s,-key)
   end
   
   function encipherOneLiner(s, key)
       map(c->isalpha(c)?char(mod((int(uppercase(c))-65+key),26)+65):c,s)
   end
   
4. Graham said

   March 12, 2014 at 1:57 AM

   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
   where
   a = ord ‘A’

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

   main :: IO ()
   main = mapM_ putStrLn [p, c, p’]
   where
   p = "PROGRAMMING PRAXIS"
   c = caesar 3 p
   p’ = caesar (-3) c
5. Graham said

   March 12, 2014 at 1:57 AM

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

   March 12, 2014 at 5:20 PM

   Racket / Rackjure

   (define (caesar str n)
     (define A (char->integer #\A))
     (define a (char->integer #\a))
     (list->string
      (for/list ([c (in-string str)])
        (cond
          [(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)]
          [else
           c]))))
   

   Full writeup: jverkamp.com
7. Mike said

   March 15, 2014 at 6:52 AM

   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

   March 17, 2014 at 4:36 PM

   {code}
   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”))
   {/code}
9. Catalin Cristu (@catalin_c) said

   May 4, 2014 at 11:08 AM

   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) {
           translatedText.append(translated);
         } else {
           translatedText.append(plain);
         }
       }
       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
     }
   }