Caesar cipher

From Rosetta Code
Jump to: navigation, search
Task
Caesar cipher
You are encouraged to solve this task according to the task description, using any language you may know.

Implement a Caesar cipher, both encoding and decoding.
The key is an integer from 1 to 25.

This cipher rotates (either towards left or right) the letters of the alphabet (A to Z).

The encoding replaces each letter with the 1st to 25th next letter in the alphabet (wrapping Z to A). So key 2 encrypts "HI" to "JK", but key 20 encrypts "HI" to "BC".

This simple "monoalphabetic substitution cipher" provides almost no security, because an attacker who has the encoded message can either use frequency analysis to guess the key, or just try all 25 keys.

Caesar cipher is identical to Vigenère cipher with a key of length 1.
Also, Rot-13 is identical to Caesar cipher with key 13.

Contents

[edit] Ada

with Ada.Text_IO;
 
procedure Caesar is
 
type M26 is mod 26;
 
function To_M26(C: Character; Offset: Character) return M26 is
begin
return M26(Character'Pos(C)-Character'Pos(Offset));
end To_M26;
 
function To_Character(Value: in M26; Offset: Character)
return Character is
begin
return Character'Val(Integer(Value)+Character'Pos(Offset));
end To_Character;
 
function Encrypt (Plain: String; Key: M26) return String is
Ciph: String(Plain'Range);
 
begin
for I in Plain'Range loop
case Plain(I) is
when 'A' .. 'Z' =>
Ciph(I) := To_Character(To_M26(Plain(I), 'A')+Key, 'A');
when 'a' .. 'z' =>
Ciph(I) := To_Character(To_M26(Plain(I), 'a')+Key, 'a');
when others =>
Ciph(I) := Plain(I);
end case;
end loop;
return Ciph;
end Encrypt;
 
Text: String := Ada.Text_IO.Get_Line;
Key: M26 := 3; -- Default key from "Commentarii de Bello Gallico"
 
begin -- Caesar main program
 
Ada.Text_IO.Put_Line("Plaintext ------------>" & Text);
Text := Encrypt(Text, Key);
Ada.Text_IO.Put_Line("Ciphertext ----------->" & Text);
Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & Encrypt(Text, -Key));
 
end Caesar;
Output:
> ./caesar 
The five boxing wizards jump quickly
Plaintext ------------>The five boxing wizards jump quickly
Ciphertext ----------->Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted Ciphertext ->The five boxing wizards jump quickly

[edit] ALGOL 68

Translation of: Ada
Note: This specimen retains the original Ada coding style.
Works with: ALGOL 68 version Revision 1 - no extensions to language used.
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny.
#!/usr/local/bin/a68g --script #
 
program caesar: BEGIN
 
MODE MODXXVI = SHORT SHORT INT; # MOD26 #
 
PROC to m26 = (CHAR c, offset)MODXXVI:
BEGIN
ABS c - ABS offset
END #to m26#;
 
PROC to char = (MODXXVI value, CHAR offset)CHAR:
BEGIN
REPR ( ABS offset + value MOD 26 )
END #to char#;
 
PROC encrypt = (STRING plain, MODXXVI key)STRING:
BEGIN
[UPB plain]CHAR ciph;
FOR i TO UPB plain DO
CHAR c = plain[i];
ciph[i]:=
IF "A" <= c AND c <= "Z" THEN
to char(to m26(c, "A")+key, "A")
ELIF "a" <= c AND c <= "z" THEN
to char(to m26(c, "a")+key, "a")
ELSE
c
FI
OD;
ciph
END #encrypt#;
 
# caesar main program #
STRING text := "The five boxing wizards jump quickly" # OR read string #;
MODXXVI key := 3; # Default key from "Bello Gallico" #
 
printf(($gl$, "Plaintext ------------>" + text));
text := encrypt(text, key);
printf(($gl$, "Ciphertext ----------->" + text));
printf(($gl$, "Decrypted Ciphertext ->" + encrypt(text, -key)))
 
END #caesar#
Output:
Plaintext ------------>The five boxing wizards jump quickly
Ciphertext ----------->Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted Ciphertext ->The five boxing wizards jump quickly

[edit] AutoHotkey

This ungodly solution is an attempt at code-golf. It requires input to be all-caps alphabetic, only works on AutoHotkey_L Unicode, and might not run on x64

n=2
s=HI
t:=&s
While *t
o.=Chr(Mod(*t-65+n,26)+65),t+=2
MsgBox % o

This next one is much more sane and handles input very well, including case.

Caesar(string, n){
Loop Parse, string
{
If (Asc(A_LoopField) >= Asc("A") and Asc(A_LoopField) <= Asc("Z"))
out .= Chr(Mod(Asc(A_LoopField)-Asc("A")+n,26)+Asc("A"))
Else If (Asc(A_LoopField) >= Asc("a") and Asc(A_LoopField) <= Asc("z"))
out .= Chr(Mod(Asc(A_LoopField)-Asc("a")+n,26)+Asc("a"))
Else out .= A_LoopField
}
return out
}
 
MsgBox % Caesar("h i", 2) "`n" Caesar("Hi", 20)
Output:
j k

Bc

[edit] AutoIt

The Ceasar Funktion can enrcypt and decrypt, standart is Encryption, to Decrypt set third parameter to False

 
$Caesar = Caesar("Hi", 2, True)
MsgBox(0, "Caesar", $Caesar)
Func Caesar($String, $int, $encrypt = True)
If Not IsNumber($int) Or Not StringIsDigit($int) Then Return SetError(1, 0, 0)
If $int < 1 Or $int > 25 Then Return SetError(2, 0, 0)
Local $sLetters, $x
$String = StringUpper($String)
$split = StringSplit($String, "")
For $i = 1 To $split[0]
If Asc($split[$i]) - 64 > 26 Or Asc($split[$i]) - 64 < 1 Then
$sLetters &= $split[$i]
ContinueLoop
EndIf
If $encrypt = True Then
$move = Asc($split[$i]) - 64 + $int
Else
$move = Asc($split[$i]) - 64 - $int
EndIf
If $move > 26 Then
$move -= 26
ElseIf $move < 1 Then
$move += 26
EndIf
While $move
$x = Mod($move, 26)
If $x = 0 Then $x = 26
$sLetters &= Chr($x + 64)
$move = ($move - $x) / 26
WEnd
Next
Return $sLetters
EndFunc ;==>Caesar
 

[edit] AWK

 
#!/usr/bin/awk -f
 
BEGIN {
message = "My hovercraft is full of eels."
key = 1
 
cypher = caesarEncode(key, message)
clear = caesarDecode(key, cypher)
 
print "message: " message
print " cypher: " cypher
print " clear: " clear
exit
}
 
function caesarEncode(key, message) {
return caesarXlat(key, message, "encode")
}
 
function caesarDecode(key, message) {
return caesarXlat(key, message, "decode")
}
 
function caesarXlat(key, message, dir, plain, cypher, i, num, s) {
plain = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
cypher = substr(plain, key+1) substr(plain, 1, key)
 
if (toupper(substr(dir, 1, 1)) == "D") {
s = plain
plain = cypher
cypher = s
}
 
s = ""
message = toupper(message)
for (i = 1; i <= length(message); i++) {
num = index(plain, substr(message, i, 1))
if (num) s = s substr(cypher, num, 1)
else s = s substr(message, i, 1)
}
return s
}
 
Output:
message: My hovercraft is full of eels.
 cypher: NZ IPWFSDSBGU JT GVMM PG FFMT.
  clear: MY HOVERCRAFT IS FULL OF EELS.

[edit] Babel

((main
{"The quick brown fox jumps over the lazy dog.\n"
dup <<
 
17 caesar_enc !
dup <<
 
17 caesar_dec !
<<})
 
(caesar_enc
{ 2 take
{ caesar_enc_loop ! }
nest })
 
(caesar_enc_loop {
give
<- str2ar
{({ dup is_upper ! }
{ 0x40 -
-> dup <-
encrypt !
0x40 + }
{ dup is_lower ! }
{ 0x60 -
-> dup <-
encrypt !
0x60 + }
{ 1 }
{fnord})
cond}
eachar
collect !
ls2lf ar2str})
 
(collect { -1 take })
 
(encrypt { + 1 - 26 % 1 + })
 
(caesar_dec { <- 26 -> - caesar_enc ! })
 
(is_upper
{ dup
<- 0x40 cugt ->
0x5b cult
cand })
 
(is_lower
{ dup
<- 0x60 cugt ->
0x7b cult
cand }))
Output:
The quick brown fox jumps over the lazy dog.
Kyv hlztb sifne wfo aldgj fmvi kyv crqp ufx.
The quick brown fox jumps over the lazy dog.

[edit] BBC BASIC

      plaintext$ = "Pack my box with five dozen liquor jugs"
PRINT plaintext$
 
key% = RND(25)
cyphertext$ = FNcaesar(plaintext$, key%)
PRINT cyphertext$
 
decyphered$ = FNcaesar(cyphertext$, 26-key%)
PRINT decyphered$
 
END
 
DEF FNcaesar(text$, key%)
LOCAL I%, C%
FOR I% = 1 TO LEN(text$)
C% = ASC(MID$(text$,I%))
IF (C% AND &1F) >= 1 AND (C% AND &1F) <= 26 THEN
C% = (C% AND &E0) OR (((C% AND &1F) + key% - 1) MOD 26 + 1)
MID$(text$, I%, 1) = CHR$(C%)
ENDIF
NEXT
= text$
 
Output:
Pack my box with five dozen liquor jugs
Zkmu wi lyh gsdr psfo nyjox vsaeyb teqc
Pack my box with five dozen liquor jugs

[edit] C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define caesar(x) rot(13, x)
#define decaesar(x) rot(13, x)
#define decrypt_rot(x, y) rot((26-x), y)
 
void rot(int c, char *str)
{
int l = strlen(str);
const char *alpha[2] = { "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
 
int i;
for (i = 0; i < l; i++)
{
if (!isalpha(str[i]))
continue;
 
str[i] = alpha[isupper(str[i])][((int)(tolower(str[i])-'a')+c)%26];
}
}
 
 
int main()
{
char str[] = "This is a top secret text message!";
 
printf("Original: %s\n", str);
caesar(str);
printf("Encrypted: %s\n", str);
decaesar(str);
printf("Decrypted: %s\n", str);
 
return 0;
}

[edit] C++

#include <string>
#include <iostream>
#include <algorithm>
#include <cctype>
 
class MyTransform {
private :
int shift ;
public :
MyTransform( int s ) : shift( s ) { }
 
char operator( )( char c ) {
if ( isspace( c ) )
return ' ' ;
else {
static std::string letters( "abcdefghijklmnopqrstuvwxyz" ) ;
std::string::size_type found = letters.find(tolower( c )) ;
int shiftedpos = ( static_cast<int>( found ) + shift ) % 26 ;
if ( shiftedpos < 0 ) //in case of decryption possibly
shiftedpos = 26 + shiftedpos ;
char shifted = letters[shiftedpos] ;
return shifted ;
}
}
} ;
 
int main( ) {
std::string input ;
std::cout << "Which text is to be encrypted ?\n" ;
getline( std::cin , input ) ;
std::cout << "shift ?\n" ;
int myshift = 0 ;
std::cin >> myshift ;
std::cout << "Before encryption:\n" << input << std::endl ;
std::transform ( input.begin( ) , input.end( ) , input.begin( ) ,
MyTransform( myshift ) ) ;
std::cout << "encrypted:\n" ;
std::cout << input << std::endl ;
myshift *= -1 ; //decrypting again
std::transform ( input.begin( ) , input.end( ) , input.begin( ) ,
MyTransform( myshift ) ) ;
std::cout << "Decrypted again:\n" ;
std::cout << input << std::endl ;
return 0 ;
}
Output:
Which text is to be encrypted ?
this is an interesting text
shift ?
3
Before encryption:
this is an interesting text
encrypted:
wklv lv dq lqwhuhvwlqj whaw
Decrypted again:
this is an interesting text

[edit] C#

using System;
using System.Linq;
 
namespace CaesarCypher
{
class Program
{
static char Encrypt(char ch, int code)
{
if (!char.IsLetter(ch))
{
return ch;
}
char offset = char.IsUpper(ch) ? 'A' : 'a';
return (char)(((ch + code - offset) % 26) + offset);
}
 
static string Encrypt(string input, int code)
{
return new string(input.ToCharArray().Select(ch => Encrypt(ch, code)).ToArray());
}
 
static string Decrypt(string input, int code)
{
return Encrypt(input, 26 - code);
}
 
const string TestCase = "Pack my box with five dozen liquor jugs.";
 
static void Main()
{
string str = TestCase;
 
Console.WriteLine(str);
str = Encrypt(str, 5);
Console.WriteLine("Encrypted: {0}", str);
str = Decrypt(str, 5);
Console.WriteLine("Decrypted: {0}", str);
Console.ReadKey();
}
}
}
Output:
Pack my box with five dozen liquor jugs.
Encrypted: Ufhp rd gtc bnym knaj itejs qnvztw ozlx.
Decrypted: Pack my box with five dozen liquor jugs.

[edit] Clojure

(defn encrypt-character [offset c]
(if (Character/isLetter c)
(let [v (int c)
base (if (>= v (int \a))
(int \a)
(int \A))
offset (mod offset 26)] ;works with negative offsets too!
(char (+ (mod (+ (- v base) offset) 26)
base)))
c))
 
(defn encrypt [offset text]
(apply str (map #(encrypt-character offset %) text)))
 
(defn decrypt [offset text]
(encrypt (- 26 offset) text))
 
 
(let [text "The Quick Brown Fox Jumps Over The Lazy Dog."
enc (encrypt -1 text)]
(print "Original text:" text "\n")
(print "Encryption:" enc "\n")
(print "Decryption:" (decrypt -1 enc) "\n"))
Output:
Original text: The Quick Brown Fox Jumps Over The Lazy Dog. 
Encryption: Sgd Pthbj Aqnvm Enw Itlor Nudq Sgd Kzyx Cnf. 
Decryption: The Quick Brown Fox Jumps Over The Lazy Dog.

[edit] COBOL

Works with: OpenCOBOL version 2.0
       >>SOURCE FORMAT IS FREE
PROGRAM-ID. caesar-cipher.
 
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
REPOSITORY.
FUNCTION encrypt
FUNCTION decrypt
.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 plaintext PIC X(50).
01 offset PIC 99.
 
01 encrypted-str PIC X(50).
 
PROCEDURE DIVISION.
DISPLAY "Enter a message to encrypt: " NO ADVANCING
ACCEPT plaintext
DISPLAY "Enter the amount to shift by: " NO ADVANCING
ACCEPT offset
 
MOVE FUNCTION encrypt(offset, plaintext) TO encrypted-str
DISPLAY "Encrypted: " encrypted-str
DISPLAY "Decrypted: " FUNCTION decrypt(offset, encrypted-str)
.
END PROGRAM caesar-cipher.
 
 
FUNCTION-ID. encrypt.
 
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 i PIC 9(3).
 
01 a PIC 9(3).
 
LINKAGE SECTION.
01 offset PIC 99.
01 str PIC X(50).
 
01 encrypted-str PIC X(50).
 
PROCEDURE DIVISION USING offset, str RETURNING encrypted-str.
MOVE str TO encrypted-str
PERFORM VARYING i FROM 1 BY 1 UNTIL i > FUNCTION LENGTH(str)
IF encrypted-str (i:1) IS NOT ALPHABETIC OR encrypted-str (i:1) = SPACE
EXIT PERFORM CYCLE
END-IF
 
IF encrypted-str (i:1) IS ALPHABETIC-UPPER
MOVE FUNCTION ORD("A") TO a
ELSE
MOVE FUNCTION ORD("a") TO a
END-IF
 
MOVE FUNCTION CHAR(FUNCTION MOD(FUNCTION ORD(encrypted-str (i:1))
- a + offset, 26) + a)
TO encrypted-str (i:1)
END-PERFORM
.
END FUNCTION encrypt.
 
 
FUNCTION-ID. decrypt.
 
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
REPOSITORY.
FUNCTION encrypt
.
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 decrypt-offset PIC 99.
 
LINKAGE SECTION.
01 offset PIC 99.
01 str PIC X(50).
 
01 decrypted-str PIC X(50).
 
PROCEDURE DIVISION USING offset, str RETURNING decrypted-str.
SUBTRACT 26 FROM offset GIVING decrypt-offset
MOVE FUNCTION encrypt(decrypt-offset, str) TO decrypted-str
.
END FUNCTION decrypt.
Output:
Enter a message to encrypt: The quick brown fox jumps over the lazy dog.
Enter the amount to shift by: 7
Encrypted: Aol xbpjr iyvdu mve qbtwz vcly aol shgf kvn.      
Decrypted: The quick brown fox jumps over the lazy dog.     

[edit] CoffeeScript

cipher = (msg, rot) ->
msg.replace /([a-z|A-Z])/g, ($1) ->
c = $1.charCodeAt(0)
String.fromCharCode \
if c >= 97
then (c + rot + 26 - 97) % 26 + 97
else (c + rot + 26 - 65) % 26 + 65
 
console.log cipher "Hello World", 2
console.log cipher "azAz %^&*()", 3
Output:
> coffee foo.coffee 
Jgnnq Yqtnf
dcDc %^&*()

[edit] Common Lisp

(defun encipher-char (ch key)
(let*
((c (char-code ch))
(la (char-code #\a)) (lz (char-code #\z))
(ua (char-code #\A)) (uz (char-code #\Z))
(base (cond
((and (>= c la) (<= c lz)) la)
((and (>= c ua) (<= c uz)) ua)
(t nil))))
(if base (code-char (+ (mod (+ (- c base) key) 26) base)) ch)))
 
(defun caesar-cipher (str key)
(map 'string #'(lambda (c) (encipher-char c key)) str))
 
(defun caesar-decipher (str key) (caesar-cipher str (- key)))
 
(let* ((original-text "The five boxing wizards jump quickly")
(key 3)
(cipher-text (caesar-cipher original-text key))
(recovered-text (caesar-decipher cipher-text key)))
(format t " Original: ~a ~%" original-text)
(format t "Encrypted: ~a ~%" cipher-text)
(format t "Decrypted: ~a ~%" recovered-text))
Output:
 Original: The five boxing wizards jump quickly 
Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob 
Decrypted: The five boxing wizards jump quickly

[edit] Cubescript

alias modn [ mod (+ (mod $arg1 $arg2) $arg2) $arg2 ]
//Cubescript's built-in mod will fail on negative numbers
 
alias cipher [
push alpha [
"A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
"a b c d e f g h i j k l m n o p q r s t u v w x y z"
] [ push chars [] [
loop i (strlen $arg1) [
looplist n $alpha [
if (! (listlen $chars)) [
alias chars (? (> (listindex $n (substr $arg1 $i 1)) -1) $n [])
]
]
alias arg1 (
concatword (substr $arg1 0 $i) (
? (> (listindex $chars (substr $arg1 $i 1)) -1) (
at $chars (
modn (+ (
listindex $chars (substr $arg1 $i 1)
) $arg2) (listlen $chars)
)
) (substr $arg1 $i 1)
) (substr $arg1 (+ $i 1) (strlen $arg1))
)
alias chars []
]
] ]
result $arg1
]
 
alias decipher [
push alpha [
"A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
"a b c d e f g h i j k l m n o p q r s t u v w x y z"
] [ push chars [] [
loop i (strlen $arg1) [
looplist n $alpha [
if (! (listlen $chars)) [
alias chars (? (> (listindex $n (substr $arg1 $i 1)) -1) $n [])
]
]
alias arg1 (
concatword (substr $arg1 0 $i) (
? (> (listindex $chars (substr $arg1 $i 1)) -1) (
at $chars (
modn (- (
listindex $chars (substr $arg1 $i 1)
) $arg2 ) (listlen $chars)
)
) (substr $arg1 $i 1)
) (substr $arg1 (+ $i 1) (strlen $arg1))
)
alias chars []
]
] ]
result $arg1
]

Usage:

>>> cipher "The Quick Brown Fox Jumps Over The Lazy Dog." 5
> Ymj Vznhp Gwtbs Ktc Ozrux Tajw Ymj Qfed Itl.
>>> decipher "Ymj Vznhp Gwtbs Ktc Ozrux Tajw Ymj Qfed Itl." 5
> The Quick Brown Fox Jumps Over The Lazy Dog.

[edit] D

import std.stdio, std.traits;
 
S rot(S)(in S s, in int key) pure nothrow
if (isSomeString!S) {
auto res = s.dup;
 
foreach (immutable i, ref c; res) {
if ('a' <= c && c <= 'z')
c = ((c - 'a' + key) % 26 + 'a');
else if ('A' <= c && c <= 'Z')
c = ((c - 'A' + key) % 26 + 'A');
}
return res;
}
 
void main() {
enum key = 3;
immutable txt = "The five boxing wizards jump quickly";
writeln("Original: ", txt);
writeln("Encrypted: ", txt.rot(key));
writeln("Decrypted: ", txt.rot(key).rot(26 - key));
}
Output:
Original:  The five boxing wizards jump quickly
Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted: The five boxing wizards jump quickly

Simpler in-place version (same output):

import std.stdio, std.ascii;
 
void inplaceRot(char[] txt, in int key) pure nothrow {
foreach (ref c; txt) {
if (isLower(c))
c = (c - 'a' + key) % 26 + 'a';
else if (isUpper(c))
c = (c - 'A' + key) % 26 + 'A';
}
}
 
void main() {
enum key = 3;
auto txt = "The five boxing wizards jump quickly".dup;
writeln("Original: ", txt);
txt.inplaceRot(key);
writeln("Encrypted: ", txt);
txt.inplaceRot(26 - key);
writeln("Decrypted: ", txt);
}

A version that uses the standard library (same output):

import std.stdio, std.ascii, std.string, std.algorithm;
 
string rot(in string s, in int key) pure nothrow @safe {
auto uppr = uppercase.dup.representation;
bringToFront(uppr[0 .. key], uppr[key .. $]);
auto lowr = lowercase.dup.representation;
bringToFront(lowr[0 .. key], lowr[key .. $]);
return s.translate(makeTrans(letters, assumeUTF(uppr ~ lowr)));
}
 
void main() {
enum key = 3;
immutable txt = "The five boxing wizards jump quickly";
writeln("Original: ", txt);
writeln("Encrypted: ", txt.rot(key));
writeln("Decrypted: ", txt.rot(key).rot(26 - key));
}

[edit] Dart

class Caesar {
int _key;
 
Caesar(this._key);
 
int _toCharCode(String s) {
return s.charCodeAt(0);
}
 
String _fromCharCode(int ch) {
return new String.fromCharCodes([ch]);
}
 
String _process(String msg, int offset) {
StringBuffer sb=new StringBuffer();
for(int i=0;i<msg.length;i++) {
int ch=msg.charCodeAt(i);
if(ch>=_toCharCode('A')&&ch<=_toCharCode('Z')) {
sb.add(_fromCharCode(_toCharCode("A")+(ch-_toCharCode("A")+offset)%26));
}
else if(ch>=_toCharCode('a')&&ch<=_toCharCode('z')) {
sb.add(_fromCharCode(_toCharCode("a")+(ch-_toCharCode("a")+offset)%26));
} else {
sb.add(msg[i]);
}
}
return sb.toString();
}
 
String encrypt(String msg) {
return _process(msg, _key);
}
 
String decrypt(String msg) {
return _process(msg, 26-_key);
}
}
 
void trip(String msg) {
Caesar cipher=new Caesar(10);
 
String enc=cipher.encrypt(msg);
String dec=cipher.decrypt(enc);
print("\"$msg\" encrypts to:");
print("\"$enc\" decrypts to:");
print("\"$dec\"");
Expect.equals(msg,dec);
}
 
main() {
Caesar c2=new Caesar(2);
print(c2.encrypt("HI"));
Caesar c20=new Caesar(20);
print(c20.encrypt("HI"));
 
// try a few roundtrips
 
trip("");
trip("A");
trip("z");
trip("Caesar cipher");
trip(".-:/\"\\!");
trip("The Quick Brown Fox Jumps Over The Lazy Dog.");
}
Output:
JK
BC
"" encrypts to:
"" decrypts to:
""
"A" encrypts to:
"K" decrypts to:
"A"
"z" encrypts to:
"j" decrypts to:
"z"
"Caesar cipher" encrypts to:
"Mkockb mszrob" decrypts to:
"Caesar cipher"
".-:/"\!" encrypts to:
".-:/"\!" decrypts to:
".-:/"\!"
"The Quick Brown Fox Jumps Over The Lazy Dog." encrypts to:
"Dro Aesmu Lbygx Pyh Tewzc Yfob Dro Vkji Nyq." decrypts to:
"The Quick Brown Fox Jumps Over The Lazy Dog."


[edit] Eiffel

 
class
APPLICATION
 
inherit
ARGUMENTS
 
create
make
 
feature {NONE} -- Initialization
 
make
-- Run application.
local
s: STRING_32
do
s := "The tiny tiger totally taunted the tall Till."
print ("%NString to encode: " + s)
print ("%NEncoded string: " + encode (s, 12))
print ("%NDecoded string (after encoding and decoding): " + decode (encode (s, 12), 12))
end
 
feature -- Basic operations
 
decode (to_be_decoded: STRING_32; offset: INTEGER): STRING_32
-- Decode `to be decoded' according to `offset'.
do
Result := encode (to_be_decoded, 26 - offset)
end
 
encode (to_be_encoded: STRING_32; offset: INTEGER): STRING_32
-- Encode `to be encoded' according to `offset'.
local
l_offset: INTEGER
l_char_code: INTEGER
do
create Result.make_empty
l_offset := (offset \\ 26) + 26
across to_be_encoded as tbe loop
if tbe.item.is_alpha then
if tbe.item.is_upper then
l_char_code := ('A').code + (tbe.item.code - ('A').code + l_offset) \\ 26
Result.append_character (l_char_code.to_character_32)
else
l_char_code := ('a').code + (tbe.item.code - ('a').code + l_offset) \\ 26
Result.append_character (l_char_code.to_character_32)
end
else
Result.append_character (tbe.item)
end
end
end
end
 
Output:
String to encode: The tiny tiger totally taunted the tall Till.
Encoded string: Ftq fuzk fusqd fafmxxk fmgzfqp ftq fmxx Fuxx.
Decoded string (after encoding and decoding): The tiny tiger totally taunted the tall Till.

[edit] Elena

#define system.
#define system'routines.
#define extensions.
#define system'math.
 
// --- Constants ---
 
#symbol Letters = "abcdefghijklmnopqrstuvwxyz".
#symbol BigLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
#symbol TestText = "Pack my box with five dozen liquor jugs.".
#symbol Key = 12.
 
// --- Encrypt / Decript ---
 
#class Encrypting
{
#field theKey.
#field theExtendee.
 
#constructor new : aKey &extending:anObject
[
theKey := aKey.
theExtendee := anObject.
]
 
#method eval : aChar
[
#var anIndex := Letters indexOf &index:0 &char:aChar.
 
(-1 < anIndex)
 ? [
theExtendee eval:(Letters @ ((theKey+anIndex) int mod:26))
]
 ! [
anIndex := BigLetters indexOf &index:0 &char:aChar.
(-1 < anIndex)
 ? [
theExtendee eval:(BigLetters @ ((theKey+anIndex) int mod:26))
]
 ! [
theExtendee eval:aChar.
].
].
]
 
#method => theExtendee.
}
 
// --- Functions ---
 
#symbol encrypt = (:aText:aKey)
[ Encrypting new:aKey &extending:(Summing new:(String new)) foreach:aText literal ].
 
#symbol decrypt = (:aText:aKey)
[ Encrypting new:(26 - aKey) &extending:(Summing new:(String new)) foreach:aText literal ].
 
// --- Program ---
 
#symbol program =
[
#var anS := TestText.
 
consoleEx writeLine:"Original text :" :anS.
 
anS := encrypt:anS:Key.
 
consoleEx writeLine:"Encrypted text:" :anS.
 
anS := decrypt:anS:Key.
 
consoleEx writeLine:"Decrypted text:" :anS.
 
consoleEx readChar.
].

[edit] Erlang

 
%% Ceasar cypher in Erlang for the rosetta code wiki.
%% Implemented by J.W. Luiten
 
-module(ceasar).
-export([main/2]).
 
%% rot: rotate Char by Key places
rot(Char,Key) when (Char >= $A) and (Char =< $Z) or
(Char >= $a) and (Char =< $z) ->
Offset = $A + Char band 32,
N = Char - Offset,
Offset + (N + Key) rem 26;
rot(Char, _Key) ->
Char.
 
%% key: normalize key.
key(Key) when Key < 0 ->
26 + Key rem 26;
key(Key) when Key > 25 ->
Key rem 26;
key(Key) ->
Key.
 
main(PlainText, Key) ->
Encode = key(Key),
Decode = key(-Key),
 
io:format("Plaintext ----> ~s~n", [PlainText]),
 
CypherText = lists:map(fun(Char) -> rot(Char, Encode) end, PlainText),
io:format("Cyphertext ---> ~s~n", [CypherText]),
 
PlainText = lists:map(fun(Char) -> rot(Char, Decode) end, CypherText).
 
 
Command:
ceasar:main("The five boxing wizards jump quickly", 3).
Output:
Plaintext ----> The five boxing wizards jump quickly
Cyphertext ---> Wkh ilyh eralqj zlcdugv mxps txlfnob
"The five boxing wizards jump quickly"

[edit] Euphoria

Works with: Euphoria version 4.0.0
 
--caesar cipher for Rosetta Code wiki
--User:Lnettnay
 
--usage eui caesar ->default text, key and encode flag
--usage eui caesar 'Text with spaces and punctuation!' 5 D
--If text has imbedded spaces must use apostophes instead of quotes so all punctuation works
--key = integer from 1 to 25, defaults to 13
--flag = E (Encode) or D (Decode), defaults to E
--no error checking is done on key or flag
 
include std/get.e
include std/types.e
 
 
sequence cmd = command_line()
sequence val
-- default text for encryption
sequence text = "The Quick Brown Fox Jumps Over The Lazy Dog."
atom key = 13 -- default to Rot-13
sequence flag = "E" -- default to Encrypt
atom offset
atom num_letters = 26 -- number of characters in alphabet
 
--get text
if length(cmd) >= 3 then
text = cmd[3]
end if
 
--get key value
if length(cmd) >= 4 then
val = value(cmd[4])
key = val[2]
end if
 
--get Encrypt/Decrypt flag
if length(cmd) = 5 then
flag = cmd[5]
if compare(flag, "D") = 0 then
key = 26 - key
end if
end if
 
for i = 1 to length(text) do
if t_alpha(text[i]) then
if t_lower(text[i]) then
offset = 'a'
else
offset = 'A'
end if
text[i] = remainder(text[i] - offset + key, num_letters) + offset
end if
end for
 
printf(1,"%s\n",{text})
 
 
Output:
"The Quick Brown Fox Jumps Over The Lazy Dog." encrypts to:
"Gur Dhvpx Oebja Sbk Whzcf Bire Gur Ynml Qbt." decrypts to:
"The Quick Brown Fox Jumps Over The Lazy Dog." 

[edit] F#

module caesar =
open System
 
let private cipher n s =
let shift c =
if Char.IsLetter c then
let a = (if Char.IsLower c then 'a' else 'A') |> int
(int c - a + n) % 26 + a |> char
else c
String.map shift s
 
let encrypt n = cipher n
let decrypt n = cipher (26 - n)
> caesar.encrypt 2 "HI";;
val it : string = "JK"
> caesar.encrypt 20 "HI";;
val it : string = "BC"
> let c = caesar.encrypt 13 "The quick brown fox jumps over the lazy dog.";;
val c : string = "Gur dhvpx oebja sbk whzcf bire gur ynml qbt."
> caesar.decrypt 13 c;;
val it : string = "The quick brown fox jumps over the lazy dog."

[edit] Fantom

Shifts upper/lower case letters, leaves other characters as they are.

 
class Main
{
static Int shift (Int char, Int key)
{
newChar := char + key
if (char >= 'a' && char <= 'z')
{
if (newChar - 'a' < 0) { newChar += 26 }
if (newChar - 'a' >= 26) { newChar -= 26 }
}
else if (char >= 'A' && char <= 'Z')
{
if (newChar - 'A' < 0) { newChar += 26 }
if (newChar - 'A' >= 26) { newChar -= 26 }
}
else // not alphabetic, so keep as is
{
newChar = char
}
return newChar
}
 
static Str shiftStr (Str msg, Int key)
{
res := StrBuf()
msg.each { res.addChar (shift(it, key)) }
return res.toStr
}
 
static Str encode (Str msg, Int key)
{
return shiftStr (msg, key)
}
 
static Str decode (Str msg, Int key)
{
return shiftStr (msg, -key)
}
 
static Void main (Str[] args)
{
if (args.size == 2)
{
msg := args[0]
key := Int(args[1])
 
echo ("$msg with key $key")
echo ("Encode: ${encode(msg, key)}")
echo ("Decode: ${decode(encode(msg, key), key)}")
}
}
}
 

Example:

$ fan caesar.fan "Encrypt - With ! Case," 1
Encrypt - With ! Case, with key 1
Encode: Fodszqu - Xjui ! Dbtf,
Decode: Encrypt - With ! Case,

$ fan caesar.fan "Encrypt - With ! Case," 5
Encrypt - With ! Case, with key 5
Encode: Jshwduy - Bnym ! Hfxj,
Decode: Encrypt - With ! Case,

$ fan caesar.fan "Encrypt - With ! Case," 10
Encrypt - With ! Case, with key 10
Encode: Oxmbizd - Gsdr ! Mkco,
Decode: Encrypt - With ! Case,

[edit] Forth

: ceasar ( c n -- c )
over 32 or [char] a -
dup 0 26 within if
over + 25 > if 26 - then +
else 2drop then ;
 
: ceasar-string ( n str len -- )
over + swap do i c@ over ceasar i c! loop drop ;
 
: ceasar-inverse ( n -- 'n ) 26 swap - 26 mod ;
 
2variable test
s" The five boxing wizards jump quickly!" test 2!
 
3 test 2@ ceasar-string
test 2@ cr type
 
3 ceasar-inverse test 2@ ceasar-string
test 2@ cr type

[edit] Fortran

program Caesar_Cipher
implicit none
 
integer, parameter :: key = 3
character(43) :: message = "The five boxing wizards jump quickly"
 
write(*, "(2a)") "Original message = ", message
call encrypt(message)
write(*, "(2a)") "Encrypted message = ", message
call decrypt(message)
write(*, "(2a)") "Decrypted message = ", message
 
contains
 
subroutine encrypt(text)
character(*), intent(inout) :: text
integer :: i
 
do i = 1, len(text)
select case(text(i:i))
case ('A':'Z')
text(i:i) = achar(modulo(iachar(text(i:i)) - 65 + key, 26) + 65)
case ('a':'z')
text(i:i) = achar(modulo(iachar(text(i:i)) - 97 + key, 26) + 97)
end select
end do
end subroutine
 
subroutine decrypt(text)
character(*), intent(inout) :: text
integer :: i
 
do i = 1, len(text)
select case(text(i:i))
case ('A':'Z')
text(i:i) = achar(modulo(iachar(text(i:i)) - 65 - key, 26) + 65)
case ('a':'z')
text(i:i) = achar(modulo(iachar(text(i:i)) - 97 - key, 26) + 97)
end select
end do
end subroutine
 
end program Caesar_Cipher
Output:
Original message  = The five boxing wizards jump quickly
Encrypted message = Wkh ilyh eralgj zlcdugv mxps txlfnob
Decrypted message = The five boxing wizards jump quickly

[edit] GAP

CaesarCipher := function(s, n)
local r, c, i, lower, upper;
lower := "abcdefghijklmnopqrstuvwxyz";
upper := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
r := "";
for c in s do
i := Position(lower, c);
if i <> fail then
Add(r, lower[RemInt(i + n - 1, 26) + 1]);
else
i := Position(upper, c);
if i <> fail then
Add(r, upper[RemInt(i + n - 1, 26) + 1]);
else
Add(r, c);
fi;
fi;
od;
return r;
end;
 
CaesarCipher("IBM", 25);
# "HAL"
 
CaesarCipher("Vgg cphvi wzdibn vmz wjmi amzz viy zlpvg di ydbidot viy mdbcon.", 5);
# "All human beings are born free and equal in dignity and rights."

[edit] Go

Obvious solution with explicit testing for character ranges:

package main
 
import (
"fmt"
"strings"
)
 
type ckey struct {
enc, dec func(rune) rune
}
 
func newCaesar(k int) (*ckey, bool) {
if k < 1 || k > 25 {
return nil, false
}
rk := rune(k)
return &ckey{
enc: func(c rune) rune {
if c >= 'a' && c <= 'z'-rk || c >= 'A' && c <= 'Z'-rk {
return c + rk
} else if c > 'z'-rk && c <= 'z' || c > 'Z'-rk && c <= 'Z' {
return c + rk - 26
}
return c
},
dec: func(c rune) rune {
if c >= 'a'+rk && c <= 'z' || c >= 'A'+rk && c <= 'Z' {
return c - rk
} else if c >= 'a' && c < 'a'+rk || c >= 'A' && c < 'A'+rk {
return c - rk + 26
}
return c
},
}, true
}
 
func (ck ckey) encipher(pt string) string {
return strings.Map(ck.enc, pt)
}
 
func (ck ckey) decipher(ct string) string {
return strings.Map(ck.dec, ct)
}
 
func main() {
pt := "The five boxing wizards jump quickly"
fmt.Println("Plaintext:", pt)
for _, key := range []int{0, 1, 7, 25, 26} {
ck, ok := newCaesar(key)
if !ok {
fmt.Println("Key", key, "invalid")
continue
}
ct := ck.encipher(pt)
fmt.Println("Key", key)
fmt.Println(" Enciphered:", ct)
fmt.Println(" Deciphered:", ck.decipher(ct))
}
}

Data driven version using functions designed for case conversion. (And for method using % operator, see Vigenère_cipher#Go.)

package main
 
import (
"fmt"
"strings"
"unicode"
)
 
type ckey struct {
enc, dec unicode.SpecialCase
}
 
func newCaesar(k int) (*ckey, bool) {
if k < 1 || k > 25 {
return nil, false
}
i := uint32(k)
r := rune(k)
return &ckey{
unicode.SpecialCase{
{'A', 'Z' - i, [3]rune{r}},
{'Z' - i + 1, 'Z', [3]rune{r - 26}},
{'a', 'z' - i, [3]rune{r}},
{'z' - i + 1, 'z', [3]rune{r - 26}},
},
unicode.SpecialCase{
{'A', 'A' + i - 1, [3]rune{26 - r}},
{'A' + i, 'Z', [3]rune{-r}},
{'a', 'a' + i - 1, [3]rune{26 - r}},
{'a' + i, 'z', [3]rune{-r}},
},
}, true
}
 
func (ck ckey) encipher(pt string) string {
return strings.ToUpperSpecial(ck.enc, pt)
}
 
func (ck ckey) decipher(ct string) string {
return strings.ToUpperSpecial(ck.dec, ct)
}
 
func main() {
pt := "The five boxing wizards jump quickly"
fmt.Println("Plaintext:", pt)
for _, key := range []int{0, 1, 7, 25, 26} {
ck, ok := newCaesar(key)
if !ok {
fmt.Println("Key", key, "invalid")
continue
}
ct := ck.encipher(pt)
fmt.Println("Key", key)
fmt.Println(" Enciphered:", ct)
fmt.Println(" Deciphered:", ck.decipher(ct))
}
}
Output:
(either version)
Plaintext: The five boxing wizards jump quickly
Key 0 invalid
Key 1
  Enciphered: Uif gjwf cpyjoh xjabset kvnq rvjdlmz
  Deciphered: The five boxing wizards jump quickly
Key 7
  Enciphered: Aol mpcl ivepun dpghykz qbtw xbpjrsf
  Deciphered: The five boxing wizards jump quickly
Key 25
  Enciphered: Sgd ehud anwhmf vhyzqcr itlo pthbjkx
  Deciphered: The five boxing wizards jump quickly
Key 26 invalid

[edit] Groovy

Java style:

def caesarEncode(​cipherKey, text) {
def builder = new StringBuilder()
text.each { character ->
int ch = character[0] as char
switch(ch) {
case 'a'..'z': ch = ((ch - 97 + cipherKey) % 26 + 97); break
case 'A'..'Z': ch = ((ch - 65 + cipherKey) % 26 + 65); break
}
builder << (ch as char)
}
builder as String
}
def caesarDecode(cipherKey, text) { caesarEncode(26 - cipherKey, text) }

Functional style:

def caesarEncode(cipherKey, text) {            
text.chars.collect { c ->
int off = c.isUpperCase() ? 'A' : 'a'
c.isLetter() ? (((c as int) - off + cipherKey) % 26 + off) as char : c
}.join()
}
def caesarDecode(cipherKey, text) { caesarEncode(26 - cipherKey, text) }

Ninja style:

def caesarEncode(k, text) { 
(text as int[]).collect { it==' ' ? ' ' : (((it & 0x1f) + k - 1) % 26 + 1 | it & 0xe0) as char }.join()
}
def caesarDecode(k, text) { caesarEncode(26 - k, text) }

Using built in 'tr' function and a replacement alphabet:

def caesarEncode(k, text) {
text.tr('a-zA-Z', ((('a'..'z')*2)[k..(k+25)] + (('A'..'Z')*2)[k..(k+25)]).join())
}
def caesarDecode(cipherKey, text) { caesarEncode(26 - cipherKey, text) }

and the same with closures for somewhat better readability:

def caesarEncode(k, text) {
def c = { (it*2)[k..(k+25)].join() }
text.tr('a-zA-Z', c('a'..'z') + c('A'..'Z'))
}
def caesarDecode(cipherKey, text) { caesarEncode(26 - cipherKey, text) }

Test code:

 
def plainText = "The Quick Brown Fox jumped over the lazy dog"
def cipherKey = 12
def cipherText = caesarEncode(cipherKey, plainText)
def decodedText = caesarDecode(cipherKey, cipherText)
 
println "plainText: $plainText"
println "cypherText($cipherKey): $cipherText"
println "decodedText($cipherKey): $decodedText"
 
assert plainText == decodedText
 
Output:
plainText: The Quick Brown Fox jumped over the lazy dog
cypherText(12): Ftq Cguow Ndaiz Raj vgybqp ahqd ftq xmlk pas
decodedText(12): The Quick Brown Fox jumped over the lazy dog

[edit] Haskell

import Data.Char (ord, chr)
import Data.Ix (inRange)
 
caesar :: Int -> String -> String
caesar k = map f
where
f c
| inRange ('a','z') c = tr 'a' k c
| inRange ('A','Z') c = tr 'A' k c
| otherwise = c
 
unCaesar :: Int -> String -> String
unCaesar k = caesar (-k)
 
-- char addition
tr :: Char -> Int -> Char -> Char
tr base offset char = chr $ ord base + (ord char - ord base + offset) `mod` 26

And trying it out in GHCi:

*Main> caesar 1 "hal"
"ibm"
*Main> unCaesar 1 "ibm"
"hal"

[edit] Icon and Unicon

Strictly speaking a Ceasar Cipher is a shift of 3 (the default in this case).

procedure main()
ctext := caesar(ptext := map("The quick brown fox jumped over the lazy dog"))
dtext := caesar(ctext,,"decrypt")
write("Plain text = ",image(ptext))
write("Encphered text = ",image(ctext))
write("Decphered text = ",image(dtext))
end
 
procedure caesar(text,k,mode) #: mono-alphabetic shift cipher
/k := 3
k := (((k % *&lcase) + *&lcase) % *&lcase) + 1
case mode of {
&null|"e"|"encrypt": return map(text,&lcase,(&lcase||&lcase)[k+:*&lcase])
"d"|"decrypt" : return map(text,(&lcase||&lcase)[k+:*&lcase],&lcase)
}
end
Output:
Plain text  = "the quick brown fox jumped over the lazy dog"
Encphered text = "wkh txlfn eurzq ira mxpshg ryhu wkh odcb grj"
Decphered text = "the quick brown fox jumped over the lazy dog"

[edit] J

If we assume that the task also requires us to leave non-alphabetic characters alone:

cndx=: [: , 65 97 +/ 26 | (i.26)&+
caesar=: (cndx 0)}&a.@u:@cndx@[ {~ a.i.]
Example use:
   2 caesar 'This simple "monoalphabetic substitution cipher" provides almost no security, ...'
Vjku ukorng "oqpqcnrjcdgvke uwduvkvwvkqp ekrjgt" rtqxkfgu cnoquv pq ugewtkva, ...

If we instead assume the task only requires we treat upper case characters:

CAESAR=:1 :'(26|m&+)&.((26{.64}.a.)&i.)'
Example use:
  20 CAESAR 'HI'
BC

[edit] Java

Works with: Java version 1.5+
public class Cipher {
public static void main(String[] args) {
 
String str = "The quick brown fox Jumped over the lazy Dog";
 
System.out.println( Cipher.encode( str, 12 ));
System.out.println( Cipher.decode( Cipher.encode( str, 12), 12 ));
}
 
public static String decode(String enc, int offset) {
return encode(enc, 26-offset);
}
 
public static String encode(String enc, int offset) {
offset = offset % 26 + 26;
StringBuilder encoded = new StringBuilder();
for (char i : enc.toCharArray()) {
if (Character.isLetter(i)) {
if (Character.isUpperCase(i)) {
encoded.append((char) ('A' + (i - 'A' + offset) % 26 ));
} else {
encoded.append((char) ('a' + (i - 'a' + offset) % 26 ));
}
} else {
encoded.append(i);
}
}
return encoded.toString();
}
}
Output:
Ftq cguow ndaiz raj Vgybqp ahqd ftq xmlk Pas
The quick brown fox Jumped over the lazy Dog

[edit] JavaScript

<html><head><title>Caesar</title></head>
<body><pre id='x'></pre>
<script type="application/javascript">
function disp(x) {
var e = document.createTextNode(x + '\n');
document.getElementById('x').appendChild(e);
}
 
function trans(msg, rot) {
return msg.replace(/([a-z])/ig,
function($1) {
var c = $1.charCodeAt(0);
return String.fromCharCode(
c >= 97 ? (c + rot + 26 - 97) % 26 + 97
: (c + rot + 26 - 65) % 26 + 65);
});
}
 
var msg = "The quick brown f0x Jumped over the lazy Dog 123";
var enc = trans(msg, 3);
var dec = trans(enc, -3);
 
disp("Original:" + msg + "\nEncoded: " + enc + "\nDecoded: " + dec);
</script></body></html>

[edit] Julia

 
function rot(s::String, key::Integer)
map(s) do c
if 'a' <= c <= 'z'
char( mod(c - 'a' + key, 26) + 'a')
elseif 'A' <= c <= 'Z'
char( mod(c - 'A' + key, 26) + 'A')
else
c
end
end
end
 
key = 3
txt = "The five boxing wizards jump quickly"
 
println("Original: ", txt);
println("Encrypted: ", rot(txt, key))
println("Decrypted: ", rot(rot(txt, key), 26 - key))
 

Based on the D code.

[edit] LabVIEW

For readability, input is in all caps.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LabVIEW Caesar cipher.png

[edit] Liberty BASIC

key = 7
 
Print "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 
'Encrypt the text
Print CaesarCypher$("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", key)
 
'Decrypt the text by changing the key to (26 - key)
Print CaesarCypher$(CaesarCypher$("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", key), (26 - key))
 
Function CaesarCypher$(string$, key)
If (key < 0) Or (key > 25) Then _
CaesarCypher$ = "Key is Ouside of Bounds" : Exit Function
For i = 1 To Len(string$)
rotate = Asc(Mid$(string$, i, 1))
rotate = (rotate + key)
If Asc(Mid$(string$, i, 1)) > Asc("Z") Then
If rotate > Asc("z") Then rotate = (Asc("a") + (rotate - Asc("z")) - 1)
Else
If rotate > Asc("Z") Then rotate = (Asc("A") + (rotate - Asc("Z")) - 1)
End If
CaesarCypher$ = (CaesarCypher$ + Chr$(rotate))
Next i
End Function

[edit]

Translation of: Common Lisp
Works with: UCB Logo
; some useful constants
make "lower_a ascii "a
make "lower_z ascii "z
make "upper_a ascii "A
make "upper_z ascii "Z
 
; encipher a single character
to encipher_char :char :key
local "code make "code ascii :char
local "base make "base 0
ifelse [and (:code >= :lower_a) (:code <= :lower_z)] [make "base :lower_a] [
if [and (:code >= :upper_a) (:code <= :upper_z)] [make "base :upper_a] ]
ifelse [:base > 0] [
output char (:base + (modulo ( :code - :base + :key ) 26 ))
] [
output :char
]
end
 
; encipher a whole string
to caesar_cipher :string :key
output map [encipher_char ? :key] :string
end
 
; Demo
make "plaintext "|The five boxing wizards jump quickly|
make "key 3
make "ciphertext caesar_cipher :plaintext :key
make "recovered caesar_cipher :ciphertext -:key
 
print sentence "| Original:| :plaintext
print sentence "|Encrypted:| :ciphertext
print sentence "|Recovered:| :recovered
bye
Output:
 Original: The five boxing wizards jump quickly
Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob
Recovered: The five boxing wizards jump quickly

[edit] Lua

local function encrypt(text, key)
return text:gsub("%a", function(t)
local base = (t:lower() == t and string.byte('a') or string.byte('A'))
 
local r = t:byte() - base
r = r + key
r = r%26 -- works correctly even if r is negative
r = r + base
return string.char(r)
end)
end
 
local function decrypt(text, key)
return encrypt(text, -key)
end
 
caesar = {
encrypt = encrypt,
decrypt = decrypt,
}
 
-- test
do
local text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz"
local encrypted = caesar.encrypt(text, 7)
local decrypted = caesar.decrypt(encrypted, 7)
print("Original text: ", text)
print("Encrypted text: ", encrypted)
print("Decrypted text: ", decrypted)
end
 

[edit] Maple

 
> StringTools:-Encode( "The five boxing wizards jump quickly", encoding = alpharot[3] );
"Wkh ilyh eralqj zlcdugv mxps txlfnob"
 
> StringTools:-Encode( %, encoding = alpharot[ 23 ] );
"The five boxing wizards jump quickly"
 

(The symbol % refers the the last (non-NULL) value computed.)

[edit] Mathematica

cypher[mesg_String,n_Integer]:=StringReplace[mesg,Flatten[Thread[Rule[#,RotateLeft[#,3]]]&/@CharacterRange@@@{{"a","z"},{"A","Z"}}]]
Output:
cypher["The five boxing wizards jump quickly",3]
-> Wkh ilyh eralqj zlcdugv mxps txlfnob

[edit] MATLAB / Octave

   function s = cipherCaesar(s, key) 
s = char( mod(s - 'A' + key, 25 ) + 'A');
end;
function s = decipherCaesar(s, key)
s = char( mod(s - 'A' - key, 25 ) + 'A');
end;

Here is a test:

   decipherCaesar(cipherCaesar('ABC',4),4) 
ans = ABC

[edit] ML

[edit] mLite

In this implementation, the offset can be positive or negative and is wrapped around if greater than 25 or less than -25.

fun readfile () = readfile []
| x = let val ln = readln ()
in if eof ln then
rev x
else
readfile ` ln :: x
end
 
local
val lower_a = ord #"a";
val lower_z = ord #"z";
val upper_a = ord #"A";
val upper_z = ord #"Z";
 
fun which
(c_upper c) = (upper_a, upper_z)
| _ = (lower_a, lower_z)
;
 
fun scale
(c, az) where (c > #1 az) = scale( (#0 az + (c - #1 az - 1)), az)
| (c, az) = c
 
in
fun encipher
([], offset, t) = implode ` rev t
| (x :: xs, offset, t) where (c_alphabetic x) = encipher (xs, offset, (chr ` scale (ord x + offset, which x)) :: t)
| (x :: xs, offset, t) = encipher (xs, offset, x :: t)
| (s, offset) = if (offset < 0) then
encipher (explode s, 26 + (offset rem 26), [])
else
encipher (explode s, offset rem 26, [])
end
 
fun default
(false, y) = y
| (x, _) = x
 
;
map println ` map (fn s = encipher (s,ston ` default (argv 0, "1"))) ` readfile ();
 

The string for encoding is supplied as an input stream, and the offset supplied on the command line (defaults to 1). For example

echo The cat sat on the mat | mlite -f caecip.m ~5

Output:

Ocz xvo nvo ji ocz hvo

[edit] NetRexx

The cipher code in this sample is also used in the Rot-13 – NetRexx task.

/* NetRexx */
 
options replace format comments java crossref savelog symbols nobinary
 
messages = [ -
'The five boxing wizards jump quickly', -
'Attack at dawn!', -
'HI']
keys = [1, 2, 20, 25, 13]
 
loop m_ = 0 to messages.length - 1
in = messages[m_]
loop k_ = 0 to keys.length - 1
say 'Caesar cipher, key:' keys[k_].right(3)
ec = caesar_encipher(in, keys[k_])
dc = caesar_decipher(ec, keys[k_])
say in
say ec
say dc
say
end k_
say 'Rot-13:'
ec = rot13(in)
dc = rot13(ec)
say in
say ec
say dc
say
end m_
 
return
 
method rot13(input) public static signals IllegalArgumentException
 
return caesar(input, 13, isFalse)
 
method caesar(input = Rexx, idx = int, caps = boolean) public static signals IllegalArgumentException
 
if idx < 1 | idx > 25 then signal IllegalArgumentException()
 
-- 12345678901234567890123456
itab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
shift = itab.length - idx
parse itab tl +(shift) tr
otab = tr || tl
 
if caps then input = input.upper
 
cipher = input.translate(itab || itab.lower, otab || otab.lower)
 
return cipher
 
method caesar_encipher(input = Rexx, idx = int, caps = boolean) public static signals IllegalArgumentException
 
return caesar(input, idx, caps)
 
method caesar_decipher(input = Rexx, idx = int, caps = boolean) public static signals IllegalArgumentException
 
return caesar(input, int(26) - idx, isFalse)
 
method caesar_encipher(input = Rexx, idx = int) public static signals IllegalArgumentException
 
return caesar(input, idx, isFalse)
 
method caesar_decipher(input = Rexx, idx = int) public static signals IllegalArgumentException
 
return caesar(input, int(26) - idx, isFalse)
 
method caesar_encipher(input = Rexx, idx = int, opt = Rexx) public static signals IllegalArgumentException
 
return caesar(input, idx, opt)
 
method caesar_decipher(input = Rexx, idx = int, opt = Rexx) public static signals IllegalArgumentException
 
return caesar(input, int(26) - idx, opt)
 
method caesar(input = Rexx, idx = int, opt = Rexx) public static signals IllegalArgumentException
 
if opt.upper.abbrev('U') >= 1 then caps = isTrue
else caps = isFalse
 
return caesar(input, idx, caps)
 
method caesar(input = Rexx, idx = int) public static signals IllegalArgumentException
 
return caesar(input, idx, isFalse)
 
method isTrue public static returns boolean
return (1 == 1)
 
method isFalse public static returns boolean
return \isTrue
Caesar cipher, key:   1
The five boxing wizards jump quickly
Uif gjwf cpyjoh xjabset kvnq rvjdlmz
The five boxing wizards jump quickly

Caesar cipher, key:   2
The five boxing wizards jump quickly
Vjg hkxg dqzkpi ykbctfu lwor swkemna
The five boxing wizards jump quickly

Caesar cipher, key:  20
The five boxing wizards jump quickly
Nby zcpy vircha qctulxm dogj kocwefs
The five boxing wizards jump quickly

Caesar cipher, key:  25
The five boxing wizards jump quickly
Sgd ehud anwhmf vhyzqcr itlo pthbjkx
The five boxing wizards jump quickly

Caesar cipher, key:  13
The five boxing wizards jump quickly
Gur svir obkvat jvmneqf whzc dhvpxyl
The five boxing wizards jump quickly

Rot-13:
The five boxing wizards jump quickly
Gur svir obkvat jvmneqf whzc dhvpxyl
The five boxing wizards jump quickly

Caesar cipher, key:   1
Attack at dawn!
Buubdl bu ebxo!
Attack at dawn!

Caesar cipher, key:   2
Attack at dawn!
Cvvcem cv fcyp!
Attack at dawn!

Caesar cipher, key:  20
Attack at dawn!
Unnuwe un xuqh!
Attack at dawn!

Caesar cipher, key:  25
Attack at dawn!
Zsszbj zs czvm!
Attack at dawn!

Caesar cipher, key:  13
Attack at dawn!
Nggnpx ng qnja!
Attack at dawn!

Rot-13:
Attack at dawn!
Nggnpx ng qnja!
Attack at dawn!

Caesar cipher, key:   1
HI
IJ
HI

Caesar cipher, key:   2
HI
JK
HI

Caesar cipher, key:  20
HI
BC
HI

Caesar cipher, key:  25
HI
GH
HI

Caesar cipher, key:  13
HI
UV
HI

Rot-13:
HI
UV
HI

[edit] Nimrod

Translation of: Python
import strutils
 
proc caesar(s: string, k: int, decode = false): string =
var k = if decode: 26 - k else: k
result = ""
for i in toUpper(s):
if ord(i) >= 65 and ord(i) <= 90:
result.add(chr((ord(i) - 65 + k) mod 26 + 65))
 
let msg = "The quick brown fox jumped over the lazy dogs"
echo msg
let enc = caesar(msg, 11)
echo enc
echo caesar(enc, 11, decode = true)

[edit] Objeck

 
class Caesar {
function : native : Encode(enc : String, offset : Int) ~ String {
offset := offset % 26 + 26;
encoded := "";
enc := enc->ToLower();
each(i : enc) {
c := enc->Get(i);
if(c->IsChar()) {
j := (c - 'a' + offset) % 26;
encoded->Append(j + 'a');
}
else {
encoded->Append(c);
};
};
 
return encoded;
}
 
function : Decode(enc : String, offset : Int) ~ String {
return Encode(enc, offset * -1);
}
 
function : Main(args : String[]) ~ Nil {
enc := Encode("The quick brown fox Jumped over the lazy Dog", 12);
enc->PrintLine();
Decode(enc, 12)->PrintLine();
}
}
 
Output:
ftq cguow ndaiz raj vgybqp ahqd ftq xmlk pas
the quick brown fox jumped over the lazy dog

[edit] OCaml

let islower c =
c >= 'a' && c <= 'z'
 
let isupper c =
c >= 'A' && c <= 'Z'
 
let rot x str =
let upchars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
and lowchars = "abcdefghijklmnopqrstuvwxyz" in
let rec decal x =
if x < 0 then decal (x + 26) else x
in
let x = (decal x) mod 26 in
let decal_up = x - (int_of_char 'A')
and decal_low = x - (int_of_char 'a') in
let len = String.length str in
let res = String.create len in
for i = 0 to pred len do
let c = str.[i] in
if islower c then
let j = ((int_of_char c) + decal_low) mod 26 in
res.[i] <- lowchars.[j]
else if isupper c then
let j = ((int_of_char c) + decal_up) mod 26 in
res.[i] <- upchars.[j]
else
res.[i] <- c
done;
(res)
 
(* or in OCaml 4.00+:
let rot x =
let upchars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
and lowchars = "abcdefghijklmnopqrstuvwxyz" in
let rec decal x =
if x < 0 then decal (x + 26) else x
in
let x = (decal x) mod 26 in
let decal_up = x - (int_of_char 'A')
and decal_low = x - (int_of_char 'a') in
String.map (fun c ->
if islower c then
let j = ((int_of_char c) + decal_low) mod 26 in
lowchars.[j]
else if isupper c then
let j = ((int_of_char c) + decal_up) mod 26 in
upchars.[j]
else
c
)
*)
let () =
let key = 3 in
let orig = "The five boxing wizards jump quickly" in
let enciphered = rot key orig in
print_endline enciphered;
let deciphered = rot (- key) enciphered in
print_endline deciphered;
Printf.printf "equal: %b\n" (orig = deciphered)
;;
Output:
$ ocaml caesar.ml 
Wkh ilyh eralqj zlcdugv mxps txlfnob
The five boxing wizards jump quickly
equal: true

[edit] PARI/GP

enc(s,n)={
Strchr(Vecsmall(apply(k->if(k>96&&k<123,(k+n-97)%26+97, if(k>64&&k<91, (k+n-65)%26+65, k)),
Vec(Vecsmall(s)))))
};
dec(s,n)=enc(s,-n);

[edit] Pascal

Program CaesarCipher(output);
 
procedure encrypt(var message: string; key: integer);
var
i: integer;
begin
for i := 1 to length(message) do
case message[i] of
'A'..'Z': message[i] := chr(ord('A') + (ord(message[i]) - ord('A') + key) mod 26);
'a'..'z': message[i] := chr(ord('a') + (ord(message[i]) - ord('a') + key) mod 26);
end;
end;
 
procedure decrypt(var message: string; key: integer);
var
i: integer;
begin
for i := 1 to length(message) do
case message[i] of
'A'..'Z': message[i] := chr(ord('A') + (ord(message[i]) - ord('A') - key + 26) mod 26);
'a'..'z': message[i] := chr(ord('a') + (ord(message[i]) - ord('a') - key + 26) mod 26);
end;
end;
 
var
key: integer;
message: string;
 
begin
key := 3;
message := 'The five boxing wizards jump quickly';
writeln ('Original message: ', message);
encrypt(message, key);
writeln ('Encrypted message: ', message);
decrypt(message, key);
writeln ('Decrypted message: ', message);
end.
Output:
>: ./CaesarCipher
Original message: The five boxing wizards jump quickly
Encrypted message: Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted message: The five boxing wizards jump quickly
>: 

[edit] Perl

sub caesar {
my ($message, $key, $decode) = @_;
$key = 26 - $key if $decode;
$message =~ s/([A-Z])/chr(((ord(uc $1) - 65 + $key) % 26) + 65)/geir;
}
 
my $msg = 'THE FIVE BOXING WIZARDS JUMP QUICKLY';
my $enc = caesar($msg, 10);
my $dec = caesar($enc, 10, 'decode');
 
print "msg: $msg\nenc: $enc\ndec: $dec\n";
 
Output:
msg: THE FIVE BOXING WIZARDS JUMP QUICKLY
enc: DRO PSFO LYHSXQ GSJKBNC TEWZ AESMUVI
dec: THE FIVE BOXING WIZARDS JUMP QUICKLY

[edit] Perl 6

my @alpha = 'A' .. 'Z';
sub encrypt ( $key where 1..25, $plaintext ) {
$plaintext.trans( @alpha Z=> @alpha.rotate($key) );
}
sub decrypt ( $key where 1..25, $cyphertext ) {
$cyphertext.trans( @alpha.rotate($key) Z=> @alpha );
}
 
my $original = 'THE FIVE BOXING WIZARDS JUMP QUICKLY';
my $en = encrypt( 13, $original );
my $de = decrypt( 13, $en );
 
.say for $original, $en, $de;
 
say 'OK' if $original eq all( map { .&decrypt(.&encrypt($original)) }, 1..25 );
Output:
THE FIVE BOXING WIZARDS JUMP QUICKLY
GUR SVIR OBKVAT JVMNEQF WHZC DHVPXYL
THE FIVE BOXING WIZARDS JUMP QUICKLY
OK

[edit] PHP

<?php
function caesarEncode( $message, $key ){
$plaintext = strtolower( $message );
$ciphertext = "";
$ascii_a = ord( 'a' );
$ascii_z = ord( 'z' );
while( strlen( $plaintext ) ){
$char = ord( $plaintext );
if( $char >= $ascii_a && $char <= $ascii_z ){
$char = ( ( $key + $char - $ascii_a ) % 26 ) + $ascii_a;
}
$plaintext = substr( $plaintext, 1 );
$ciphertext .= chr( $char );
}
return $ciphertext;
}
 
echo caesarEncode( "The quick brown fox Jumped over the lazy Dog", 12 ), "\n";
?>
Output:
ftq cguow ndaiz raj vgybqp ahqd ftq xmlk pas

[edit] PicoLisp

(setq *Letters (apply circ (mapcar char (range 65 90))))
 
(de caesar (Str Key)
(pack
(mapcar '((C) (cadr (nth (member C *Letters) Key)))
(chop (uppc Str)) ) ) )

Test:

: (caesar "IBM" 25)
-> "HAL"
: (caesar @ 1)
-> "IBM"

: (caesar "The quick brown fox jumped over the lazy dog's back" 7)
-> "AOLXBPJRIYVDUMVEQBTWLKVCLYAOLSHGFKVNZIHJR"
: (caesar @ (- 26 7))
-> "THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGSBACK"

[edit] PL/I

caesar: procedure options (main);
declare cypher_string character (52) static initial
((2)'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
declare (text, encyphered_text) character (100) varying,
offset fixed binary;
 
get edit (text) (L); /* Read in one line of text */
get list (offset);
if offset < 1 | offset > 25 then signal error;
put skip list ('Plain text=', text);
 
encyphered_text = translate(text, substr(cypher_string, offset+1, 26),
'ABCDEFGHIJKLMNOPQRSTUVWXYZ' );
put skip list ('Encyphered text=', encyphered_text);
 
text = translate(encyphered_text, substr(cypher_string, 27-offset, 26),
'ABCDEFGHIJKLMNOPQRSTUVWXYZ' );
put skip list ('Decyphered text=', text);
 
end caesar;
Output:
with offset of 5:
Plain text=             THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG 
Encyphered text=        YMJVZNHPGWTBSKTCOZRUXTAJWYMJQFEDITL 
Decyphered text=        THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG

[edit] PowerShell

# Author: M. McNabb
function Get-CaesarCipher
{
Param
(
[Parameter(
Mandatory=$true,ValueFromPipeline=$true)]
[string]
$Text,
 
[ValidateRange(1,25)]
[int]
$Key = 1,
 
[switch]
$Decode
)
 
begin
{
$LowerAlpha = [char]'a'..[char]'z'
$UpperAlpha = [char]'A'..[char]'Z'
}
 
process
{
$Chars = $Text.ToCharArray()
 
function encode
{
param
(
$Char,
$Alpha = [char]'a'..[char]'z'
)
$Index = $Alpha.IndexOf([int]$Char)
$NewIndex = ($Index + $Key) - $Alpha.Length
$Alpha[$NewIndex]
}
 
function decode
{
param
(
$Char,
$Alpha = [char]'a'..[char]'z'
)
$Index = $Alpha.IndexOf([int]$Char)
$int = $Index - $Key
if ($int -lt 0) {$NewIndex = $int + $Alpha.Length}
else {$NewIndex = $int}
$Alpha[$NewIndex]
}
 
foreach ($Char in $Chars)
{
if ([int]$Char -in $LowerAlpha)
{
if ($Decode) {$Char = decode $Char}
else {$Char = encode $Char}
}
elseif ([int]$Char -in $UpperAlpha)
{
if ($Decode) {$Char = decode $Char $UpperAlpha}
else {$Char = encode $Char $UpperAlpha}
}
 
$Char = [char]$Char
[string]$OutText += $Char
}
 
$OutText
$OutText = $null
}
}

Usage examples:

Encode:
PS C:\> 'Pack my box with five dozen liquor jugs.' | Get-CaesarCipher -key 3
Sdfn pb era zlwk ilyh grchq oltxru mxjv.

Decode:
PS C:\> 'Sdfn pb era zlwk ilyh grchq oltxru mxjv.' | Get-CaesarCipher -key 3 -Decode
Pack my box with five dozen liquor jugs.

Encode lines of text from a file:
PS C:\> Get-Content C:\Text.txt | Get-CaesarCipher -key 10
Vsxo yxo.
Vsxo dgy!
Vsxo drboo;

[edit] Prolog

Works with: SWI-Prolog
Library: clpfd
:- use_module(library(clpfd)).
 
caesar :-
L1 = "The five boxing wizards jump quickly",
writef("Original : %s\n", [L1]),
 
% encryption of the sentence
encoding(3, L1, L2) ,
writef("Encoding : %s\n", [L2]),
 
% deciphering on the encoded sentence
encoding(3, L3, L2),
writef("Decoding : %s\n", [L3]).
 
% encoding/decoding of a sentence
encoding(Key, L1, L2) :-
maplist(caesar_cipher(Key), L1, L2).
 
caesar_cipher(_, 32, 32) :- !.
 
caesar_cipher(Key, V1, V2) :-
V #= Key + V1,
 
% we verify that we are in the limits of A-Z and a-z.
((V1 #=< 0'Z #/\ V #> 0'Z) #\/ (V1 #=< 0'z #/\ V #> 0'z)
#\/
(V1 #< 0'A #/\ V2 #>= 0'A)#\/ (V1 #< 0'a #/\ V2 #>= 0'a)) #==> A,
 
% if we are not in these limits A is 1, otherwise 0.
V2 #= V - A * 26,
 
% compute values of V1 and V2
label([A, V1, V2]).
Output:
 ?- caesar.
Original : The five boxing wizards jump quickly
Encoding : Wkh ilyh eralqj zlcdugv mxps txlfnob
Decoding : The five boxing wizards jump quickly
true .

[edit] PureBasic

The case is maintained for alphabetic characters (uppercase/lowercase input = uppercase/lowercase output) while non-alphabetic characters, if present are included and left unchanged in the result.

Procedure.s CC_encrypt(plainText.s, key, reverse = 0)
;if reverse <> 0 then reverse the encryption (decrypt)
If reverse: reverse = 26: key = 26 - key: EndIf
 
Static alphabet$ = "ABCEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
 
Protected result.s, i, length = Len(plainText), letter.s, legal
If key < 1 Or key > 25: ProcedureReturn: EndIf ;keep key in range
 
For i = 1 To length
letter = Mid(plainText, i, 1)
legal = FindString(alphabet$, letter, 1 + reverse)
If legal
result + Mid(alphabet$, legal + key, 1)
Else
result + letter
EndIf
Next
ProcedureReturn result
EndProcedure
 
Procedure.s CC_decrypt(cypherText.s, key)
ProcedureReturn CC_encrypt(cypherText, key, 1)
EndProcedure
 
If OpenConsole()
Define key, plainText.s, encryptedText.s, decryptedText.s
 
key = Random(24) + 1 ;get a random key in the range 1 -> 25
 
plainText = "The quick brown fox jumped over the lazy dogs.": PrintN(RSet("Plain text = ", 17) + #DQUOTE$ + plainText + #DQUOTE$)
encryptedText = CC_encrypt(plainText, key): PrintN(RSet("Encrypted text = ", 17) + #DQUOTE$ + encryptedText + #DQUOTE$)
decryptedText = CC_decrypt(encryptedText, key): PrintN(RSet("Decrypted text = ", 17) + #DQUOTE$ + decryptedText + #DQUOTE$)
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf
Output:
    Plain text = "The quick brown fox jumped over the lazy dogs."
Encrypted text = "Znk waoiq hxuct lud pasvkj ubkx znk rgfe jumy."
Decrypted text = "the quick brown fox jumped over the lazy dogs."

[edit] Alternate solution

Here is an alternate and more advanced form of the encrypt procedure. It improves on the simple version in terms of speed, in case Caesar is using the cipher on some very long documents. It is meant to replace the encrypt procedure in the previous code and produces identical results.

Procedure.s CC_encrypt(text.s, key, reverse = 0)
;if reverse <> 0 then reverse the encryption (decrypt)
Protected i, *letter.Character, *resultLetter.Character, result.s = Space(Len(text))
 
If reverse: key = 26 - key: EndIf
If key < 1 Or key > 25: ProcedureReturn: EndIf ;exit if key out of range
 
*letter = @text: *resultLetter = @result
While *letter\c
Select *letter\c
Case 'A' To 'Z'
*resultLetter\c = ((*letter\c - 65 + key) % 26) + 65
Case 'a' To 'z'
*resultLetter\c = ((*letter\c - 97 + key) % 26) + 97
Default
*resultLetter\c = *letter\c
EndSelect
*letter + SizeOf(Character): *resultLetter + SizeOf(Character)
Wend
ProcedureReturn result
EndProcedure

[edit] Python

def caesar(s, k, decode = False):
if decode: k = 26 - k
return "".join([chr((ord(i) - 65 + k) % 26 + 65)
for i in s.upper()
if ord(i) >= 65 and ord(i) <= 90 ])
 
msg = "The quick brown fox jumped over the lazy dogs"
print msg
enc = caesar(msg, 11)
print enc
print caesar(enc, 11, decode = True)
Output:
The quick brown fox jumped over the lazy dogs
ESPBFTNVMCZHYQZIUFXAPOZGPCESPWLKJOZRD
THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGS

Alternate solution

Works with: Python version 2.x
(for 3.x change string.maketrans to str.maketrans)
import string
def caesar(s, k, decode = False):
if decode: k = 26 - k
return s.translate(
string.maketrans(
string.ascii_uppercase + string.ascii_lowercase,
string.ascii_uppercase[k:] + string.ascii_uppercase[:k] +
string.ascii_lowercase[k:] + string.ascii_lowercase[:k]
)
)
msg = "The quick brown fox jumped over the lazy dogs"
print msg
enc = caesar(msg, 11)
print enc
print caesar(enc, 11, decode = True)
Output:
The quick brown fox jumped over the lazy dogs
Esp bftnv mczhy qzi ufxapo zgpc esp wlkj ozrd
The quick brown fox jumped over the lazy dogs

A compact alternative solution

 
from string import ascii_uppercase as abc
 
def caesar(s, k, decode = False):
trans = dict(zip(abc, abc[(k,26-k)[decode]:] + abc[:(k,26-k)[decode]]))
return ''.join(trans[L] for L in s.upper() if L in abc)
 
msg = "The quick brown fox jumped over the lazy dogs"
print(caesar(msg, 11))
print(caesar(caesar(msg, 11), 11, True))
 
Output:
ESPBFTNVMCZHYQZIUFXAPOZGPCESPWLKJOZRD
THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGS

[edit] Racket

 
#lang racket
 
(define A (char->integer #\A))
(define Z (char->integer #\Z))
(define a (char->integer #\a))
(define z (char->integer #\z))
 
(define (rotate c n)
(define cnum (char->integer c))
(define (shift base) (integer->char (+ base (modulo (+ n (- cnum base)) 26))))
(cond [(<= A cnum Z) (shift A)]
[(<= a cnum z) (shift a)]
[else c]))
 
(define (caesar s n)
(list->string (for/list ([c (in-string s)]) (rotate c n))))
 
(define (encrypt s) (caesar s 1))
(define (decrypt s) (caesar s -1))
 

Example:

> (define s (encrypt "The five boxing wizards jump quickly."))
> s
"Uif gjwf cpyjoh xjabset kvnq rvjdlmz."
> (decrypt s)
"The five boxing wizards jump quickly."

[edit] Retro

Retro provides a number of classical cyphers in the crypto' library. This implementation is from the library.

{{
variable offset
 : rotate ( cb-c ) tuck - @offset + 26 mod + ;
 : rotate? ( c-c )
dup 'a 'z within [ 'a rotate ] ifTrue
dup 'A 'Z within [ 'A rotate ] ifTrue ;
---reveal---
 : ceaser ( $n-$ )
 !offset dup [ [ @ rotate? ] sip ! ] ^types'STRING each@ ;
}}
 
( Example )
"THEYBROKEOURCIPHEREVERYONECANREADTHIS" 3 ceaser ( returns encrypted string )
23 ceaser ( returns decrypted string )

[edit] REXX

[edit] only Latin letters

This version conforms to the task's restrictions.

/*REXX pgm: Caesar cypher: Latin alphabet only, no punctuation or blanks*/
/* allowed, all lowercase Latin letters are treated as uppercase. */
arg key p /*get key and text to be cyphered*/
p=space(p,0) /*remove all blanks from text. */
say 'Caesar cypher key:' key
say ' plain text:' p
y=caesar(p, key)  ; say ' cyphered:' y
z=caesar(y,-key)  ; say ' uncyphered:' z
if z\==p then say "plain text doesn't match uncyphered cyphered text."
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────CAESAR subroutine───────────────────*/
caesar: procedure; arg s,k; @='ABCDEFGHIJKLMNOPQRSTUVWXYZ'; L=length(@)
ak=abs(k)
if ak>length(@)-1 | k==0 | k=='' then call err k 'key is invalid'
_=verify(s,@) /*any illegal char specified ? */
if _\==0 then call err 'unsupported character:' substr(s,_,1)
/*now that error checks are done:*/
if k>0 then ky=k+1 /*either cypher it, or ··· */
else ky=27-ak /* decypher it. */
return translate(s,substr(@||@,ky,L),@)
/*──────────────────────────────────ERR subroutine──────────────────────*/
err: say; say '***error!***'; say; say arg(1); say; exit 13
Output:
when using the input of:

22 The definition of a trivial program is one that has no bugs

Caesar cypher key: 22
       plain text: THEDEFINITIONOFATRIVIALPROGRAMISONETHATHASNOBUGS
         cyphered: PDAZABEJEPEKJKBWPNEREWHLNKCNWIEOKJAPDWPDWOJKXQCO
       uncyphered: THEDEFINITIONOFATRIVIALPROGRAMISONETHATHASNOBUGS

[edit] almost all characters

This version allows upper and lowercase Latin alphabet as well as all the characters on the standard (computer) keyboard including blanks.

/*REXX pgm: Caesar cypher for almost all keyboard chars including blanks*/
parse arg key p /*get key and text to be cyphered*/
say 'Caesar cypher key:' key
say ' plain text:' p
y=caesar(p, key)  ; say ' cyphered:' y
z=caesar(y,-key)  ; say ' uncyphered:' z
if z\==p then say "plain text doesn't match uncyphered cyphered text."
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────CAESAR subroutine───────────────────*/
caesar: procedure; parse arg s,k; @='abcdefghijklmnopqrstuvwxyz'
@=translate(@)@'0123456789(){}[]<>' /*add uppercase, digs, group symb*/
@=@'~!@#$%^&*_+:";?,./`-= ''' /*add other characters here. */
/*last char is doubled, REXX quoted syntax rules.*/
L=length(@)
ak=abs(k)
if ak>length(@)-1 | k==0 then call err k 'key is invalid'
_=verify(s,@) /*any illegal char specified ? */
if _\==0 then call err 'unsupported character:' substr(s,_,1)
if k>0 then ky=k+1
else ky=L+1-ak
return translate(s,substr(@||@,ky,L),@)
/*──────────────────────────────────ERR subroutine──────────────────────*/
Output:
when using the input of:

31 Batman's hood is called a "cowl" (old meaning).

Caesar cypher key: 31
       plain text: Batman's hood is called a "cowl" (old meaning).
         cyphered: g5^>5~e%d{!!8d}%d75<<98d5dU7!_<UdA!<8d>95~}~)BY
       uncyphered: Batman's hood is called a "cowl" (old meaning).

[edit] Ruby

Translation of: Perl 6
Works with: Ruby version 1.9.2+
(use of rotate)
module CaesarCipher
AtoZ = (0..25).each_with_object({}) do |key,h|
str = [*"A".."Z"].rotate(key).join
h[key] = str + str.downcase
end
 
def encrypt(key, plaintext)
(1..25) === key or raise ArgumentError, "key not in 1..25"
plaintext.tr(AtoZ[0], AtoZ[key])
end
 
def decrypt(key, ciphertext)
(1..25) === key or raise ArgumentError, "key not in 1..25"
ciphertext.tr(AtoZ[key], AtoZ[0])
end
end
 
include CaesarCipher
 
original = "THEYBROKEOURCIPHEREVERYONECANREADTHIS"
en = encrypt(3, original)
de = decrypt(3, en)
 
[original, en, de].each {|e| puts e}
 
puts 'OK' if
(1..25).all? {|k| original == decrypt(k, encrypt(k, original))}

The Ruby translation saves the rotations in an AtoZ hash. (The Perl 6 code called rotate() during each encrypt or decrypt.)

  • AtoZ[0] becomes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  • AtoZ[3] becomes "DEFGHIJKLMNOPQRSTUVWXYZABCdefghijklmnopqrstuvwxyzabc",
  • and so on.

When the key is 3, encryption uses String#tr(AtoZ[0], AtoZ[3]) to substitute characters. Decryption uses String#tr(AtoZ[3], AtoZ[0]).

To make a rotation, Ruby is worse than Perl 6. Ruby needs two extra conversions: the code [*"A".."Z"].rotate(key).join uses to_a to convert a Range to an Array, to access the Array#rotate method. Then join converts the rotated Array to a String, because String#tr needs a String, not an Array.

[edit] Run BASIC

input "Gimme a ofset:";ofst       ' set any offset you like
 
a$ = "Pack my box with five dozen liquor jugs"
print " Original: ";a$
a$ = cipher$(a$,ofst)
print "Encrypted: ";a$
print "Decrypted: ";cipher$(a$,ofst+6)
 
FUNCTION cipher$(a$,ofst)
for i = 1 to len(a$)
aa$ = mid$(a$,i,1)
code$ = " "
if aa$ <> " " then
ua$ = upper$(aa$)
a = asc(ua$) - 64
code$ = chr$((((a mod 26) + ofst) mod 26) + 65)
if ua$ <> aa$ then code$ = lower$(code$)
end if
cipher$ = cipher$;code$
next i
END FUNCTION
Output:
Gimme a ofset:?9
 Original: Pack my box with five dozen liquor jugs
Encrypted: Zkmu wi lyh gsdr psfo nyjox vsaeyb teqc
Decrypted: Pack my box with five dozen liquor jugs

[edit] Scala

object Caesar {
private val alphaU='A' to 'Z'
private val alphaL='a' to 'z'
 
def encode(text:String, key:Int)=text.map{
case c if alphaU.contains(c) => rot(alphaU, c, key)
case c if alphaL.contains(c) => rot(alphaL, c, key)
case c => c
}
def decode(text:String, key:Int)=encode(text,-key)
private def rot(a:IndexedSeq[Char], c:Char, key:Int)=a((c-a.head+key+a.size)%a.size)
}
val text="The five boxing wizards jump quickly"
println("Plaintext => " + text)
val encoded=Caesar.encode(text, 3)
println("Ciphertext => " + encoded)
println("Decrypted => " + Caesar.decode(encoded, 3))
Output:
Plaintext  => The five boxing wizards jump quickly
Ciphertext => Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted  => The five boxing wizards jump quickly

[edit] Alternate version

This version first creates non shifted and shifted character sequences and then encodes and decodes by indexing between those sequences.

class Caeser(val key: Int) {
@annotation.tailrec
private def rotate(p: Int, s: IndexedSeq[Char]): IndexedSeq[Char] = if (p < 0) rotate(s.length + p, s) else s.drop(p) ++ s.take(p)
 
val uc = 'A' to 'Z'
val lc = 'a' to 'z'
val as = uc ++ lc
val bs = rotate(key, uc) ++ rotate(key, lc)
 
def encode(c: Char) = if (as.contains(c)) bs(as.indexOf(c)) else c
def decode(c: Char) = if (bs.contains(c)) as(bs.indexOf(c)) else c
}
val text = "The five boxing wizards jump quickly"
val myCaeser = new Caeser(3)
val encoded = text.map(c => myCaeser.encode(c))
println("Plaintext => " + text)
println("Ciphertext => " + encoded)
println("Decrypted => " + encoded.map(c => myCaeser.decode(c)))
Output:
Plaintext => The five boxing wizards jump quickly
Ciphertext => Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted => The five boxing wizards jump quickly

[edit] Scheme

;
; Works with R7RS-compatible Schemes (e.g. Chibi).
; Also current versions of Chicken, Gauche and Kawa.
;
(cond-expand
(chicken (use srfi-13))
(gauche (use srfi-13))
(kawa (import (srfi :13)))
(else (import (scheme base) (scheme write)))) ; R7RS
 
 
(define msg "The quick brown fox jumps over the lazy dog.")
(define key 13)
 
(define (caesar char)
(define A (char->integer #\A))
(define Z (char->integer #\Z))
(define a (char->integer #\a))
(define z (char->integer #\z))
(define c (char->integer char))
(integer->char
(cond ((<= A c Z) (+ A (modulo (+ key (- c A)) 26)))
((<= a c z) (+ a (modulo (+ key (- c a)) 26)))
(else c)))) ; Return other characters verbatim.
 
(display (string-map caesar msg))
(newline)
 
Output:
Gur dhvpx oebja sbk whzcf bire gur ynml qbt.

[edit] sed

This code is roughly equivalent to the rot-13 cypher sed implementation, except that the conversion table is parameterized by a number and that the conversion done manually, instead of using `y///' command.

#!/bin/sed -rf
# Input: <number 0..25>\ntext to encode
 
/^[0-9]+$/ {
# validate a number and translate it to analog form
s/$/;9876543210dddddddddd/
s/([0-9]);.*\1.{10}(.?)/\2/
s/2/11/
s/1/dddddddddd/g
/[3-9]|d{25}d+/ {
s/.*/Error: Key must be <= 25/
q
}
# append from-table
s/$/\nabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/
# .. and to-table
s/$/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/
# rotate to-table, lower and uppercase independently, removing one `d' at a time
: rotate
s/^d(.*\n[^Z]+Z)(.)(.{25})(.)(.{25})/\1\3\2\5\4/
t rotate
s/\n//
h
d
}
 
# use \n to mark character to convert
s/^/\n/
# append conversion table to pattern space
G
: loop
# look up converted character and place it instead of old one
s/\n(.)(.*\n.*\1.{51}(.))/\n\3\2/
# advance \n even if prev. command fails, thus skip non-alphabetical characters
/\n\n/! s/\n([^\n])/\1\n/
t loop
s/\n\n.*//
Output:
$ ./caesar.sed 
3
The five boxing wizards jump quickly
Wkh ilyh eralqj zlcdugv mxps txlfnob
23
Wkh ilyh eralqj zlcdugv mxps txlfnob
The five boxing wizards jump quickly
26
Error: Key must be <= 25

[edit] Seed7

$ include "seed7_05.s7i";
 
const func string: rot (in string: stri, in integer: encodingKey) is func
result
var string: encodedStri is "";
local
var char: ch is ' ';
var integer: index is 0;
begin
encodedStri := stri;
for ch key index range stri do
if ch >= 'a' and ch <= 'z' then
ch := chr((ord(ch) - ord('a') + encodingKey) rem 26 + ord('a'));
elsif ch >= 'A' and ch <= 'Z' then
ch := chr((ord(ch) - ord('A') + encodingKey) rem 26 + ord('A'));
end if;
encodedStri @:= [index] ch;
end for;
end func;
 
const proc: main is func
local
const integer: exampleKey is 3;
const string: testText is "The five boxing wizards jump quickly";
begin
writeln("Original: " <& testText);
writeln("Encrypted: " <& rot(testText, exampleKey));
writeln("Decrypted: " <& rot(rot(testText, exampleKey), 26 - exampleKey));
end func;
Output:
Original:  The five boxing wizards jump quickly
Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob
Decrypted: The five boxing wizards jump quickly

[edit] Smalltalk

Works with: Smalltalk/X

well, I'm lucky: the standard library already contains a rot:n method!

'THE QUICK BROWN FOX' rot:3 -> 'WKH TXLFN EURZQ IRA' 

but if it wasn't, here is an implementation for other smalltalks:

 
!CharacterArray methodsFor:'encoding'!
rot:n
^ self class
streamContents:[:aStream |
self do:[:char |
aStream nextPut:(char rot:n) ]]
 
 
!Character methodsFor:'encoding'!
rot:n
(self isLetter) ifTrue:[
self isLowercase ifTrue:[
^ 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz' at:(self-$a+1+n)
] ifFalse:[
^ 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ' at:(self-$A+1+n)
]
].
^ self
 
 

[edit] Tcl

package require Tcl 8.6;    # Or TclOO package for 8.5
 
oo::class create Caesar {
variable encryptMap decryptMap
constructor shift {
for {set i 0} {$i < 26} {incr i} {
# Play fast and loose with string/list duality for shorter code
append encryptMap [format "%c %c %c %c " \
[expr {$i+65}] [expr {($i+$shift)%26+65}] \
[expr {$i+97}] [expr {($i+$shift)%26+97}]]
append decryptMap [format "%c %c %c %c " \
[expr {$i+65}] [expr {($i-$shift)%26+65}] \
[expr {$i+97}] [expr {($i-$shift)%26+97}]]
}
}
 
method encrypt text {
string map $encryptMap $text
}
method decrypt text {
string map $decryptMap $text
}
}

Demonstrating:

set caesar [Caesar new 3]
set txt "The five boxing wizards jump quickly."
set enc [$caesar encrypt $txt]
set dec [$caesar decrypt $enc]
puts "Original message = $txt"
puts "Encrypted message = $enc"
puts "Decrypted message = $dec"
Output:
Original message  = The five boxing wizards jump quickly.
Encrypted message = Wkh ilyh eralqj zlcdugv mxps txlfnob.
Decrypted message = The five boxing wizards jump quickly.

[edit] TUSCRIPT

$$ MODE TUSCRIPT
text="THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"
PRINT "text orginal ",text
 
abc="ABCDEFGHIJKLMNOPQRSTUVWXYZ",key=3,caesarskey=key+1
secretbeg=EXTRACT (abc,#caesarskey,0)
secretend=EXTRACT (abc,0,#caesarskey)
secretabc=CONCAT (secretbeg,secretend)
 
abc=STRINGS (abc,":</:"),secretabc=STRINGS (secretabc,":</:")
abc=SPLIT (abc), secretabc=SPLIT (secretabc)
abc2secret=JOIN(abc," ",secretabc),secret2abc=JOIN(secretabc," ",abc)
 
BUILD X_TABLE abc2secret=*
DATA {abc2secret}
 
BUILD X_TABLE secret2abc=*
DATA {secret2abc}
 
ENCODED = EXCHANGE (text,abc2secret)
PRINT "text encoded ",encoded
 
DECODED = EXCHANGE (encoded,secret2abc)
PRINT "encoded decoded ",decoded
Output:
text orginal    THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
text encoded    WKH TXLFN EURZQ IRA MXPSV RYHU WKH ODCB GRJ
encoded decoded THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 

[edit] TXR

The strategy here, one of many possible ones, is to build, at run time,the arguments to be passed to deffilter to construct a pair of filters enc and dec for encoding and decoding. Filters are specified as tuples of strings.

@(next :args)
@(cases)
@{key /[0-9]+/}
@text
@(or)
@ (throw error "specify <key-num> <text>")
@(end)
@(do
(defvar k (int-str key 10)))
@(bind enc-dec
@(collect-each ((i (range 0 25)))
(let* ((p (tostringp (+ #\a i)))
(e (tostringp (+ #\a (mod (+ i k) 26))))
(P (upcase-str p))
(E (upcase-str e)))
^(((,p ,e) (,P ,E))
((,e ,p) (,E ,P))))))
@(deffilter enc . @(mappend (fun first) enc-dec))
@(deffilter dec . @(mappend (fun second) enc-dec))
@(output)
encoded: @{text :filter enc}
decoded: @{text :filter dec}
@(end)
Output:
$ ./txr caesar.txr 12 'Hello, world!'
encoded: Tqxxa, iadxp!
decoded: Vszzc, kcfzr!
$ ./txr caesar.txr 12 'Vszzc, kcfzr!'
encoded: Hello, world!
decoded: Jgnnq, yqtnf!

[edit] UNIX Shell

Works with: bash

I added a tr function to make this "pure" bash. In practice, you'd remove that function and use the external tr utility.

caesar() {
local OPTIND
local encrypt n=0
while getopts :edn: option; do
case $option in
e) encrypt=true ;;
d) encrypt=false ;;
n) n=$OPTARG ;;
 :) echo "error: missing argument for -$OPTARG" >&2
return 1 ;;
 ?) echo "error: unknown option -$OPTARG" >&2
return 1 ;;
esac
done
shift $((OPTIND-1))
if [[ -z $encrypt ]]; then
echo "error: specify one of -e or -d" >&2
return 1
fi
 
local upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
local lower=abcdefghijklmnopqrstuvwxyz
if $encrypt; then
tr "$upper$lower" "${upper:n}${upper:0:n}${lower:n}${lower:0:n}" <<< "$1"
else
tr "${upper:n}${upper:0:n}${lower:n}${lower:0:n}" "$upper$lower" <<< "$1"
fi
}
 
tr() {
local -A charmap
local i trans line char
for ((i=0; i<${#1}; i++)); do
charmap[${1:i:1}]=${2:i:1}
done
while IFS= read -r line; do
trans=""
for ((i=0; i<${#line}; i++)); do
char=${line:i:1}
if [[ -n ${charmap[$char]} ]]; then
trans+=${charmap[$char]}
else
trans+=$char
fi
done
echo "$trans"
done
}
 
txt="The five boxing wizards jump quickly."
enc=$(caesar -e -n 5 "$txt")
dec=$(caesar -d -n 5 "$enc")
 
echo "original: $txt"
echo "encrypted: $enc"
echo "decrypted: $dec"
Output:
original:  The five boxing wizards jump quickly.
encrypted: Ymj knaj gtcnsl bnefwix ozru vznhpqd.
decrypted: The five boxing wizards jump quickly.

[edit] Ursala

The reification operator (-:) generates efficient code for applications like this given a table of inputs and outputs, which is obtained in this case by zipping the alphabet with itself rolled the right number of times, done separately for the upper and lower case letters and then combined.

#import std
#import nat
 
enc "n" = * -:~&@T ^p(rep"n" ~&zyC,~&)~~K30K31X letters # encryption function
dec "n" = * -:~&@T ^p(~&,rep"n" ~&zyC)~~K30K31X letters # decryption function
 
plaintext = 'the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY'
 
#show+ # exhaustive test
 
test = ("n". <.enc"n",dec"n"+ enc"n"> plaintext)*= nrange/1 25
Output:
uif gjwf cpyjoh xjabset kvnq rvjdlmz UIF GJWF CPYJOH XJABSET KVNQ RVJDLMZ
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
vjg hkxg dqzkpi ykbctfu lwor swkemna VJG HKXG DQZKPI YKBCTFU LWOR SWKEMNA
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
wkh ilyh eralqj zlcdugv mxps txlfnob WKH ILYH ERALQJ ZLCDUGV MXPS TXLFNOB
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
xli jmzi fsbmrk amdevhw nyqt uymgopc XLI JMZI FSBMRK AMDEVHW NYQT UYMGOPC
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
ymj knaj gtcnsl bnefwix ozru vznhpqd YMJ KNAJ GTCNSL BNEFWIX OZRU VZNHPQD
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
znk lobk hudotm cofgxjy pasv waoiqre ZNK LOBK HUDOTM COFGXJY PASV WAOIQRE
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
aol mpcl ivepun dpghykz qbtw xbpjrsf AOL MPCL IVEPUN DPGHYKZ QBTW XBPJRSF
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
bpm nqdm jwfqvo eqhizla rcux ycqkstg BPM NQDM JWFQVO EQHIZLA RCUX YCQKSTG
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
cqn oren kxgrwp frijamb sdvy zdrltuh CQN OREN KXGRWP FRIJAMB SDVY ZDRLTUH
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
dro psfo lyhsxq gsjkbnc tewz aesmuvi DRO PSFO LYHSXQ GSJKBNC TEWZ AESMUVI
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
esp qtgp mzityr htklcod ufxa bftnvwj ESP QTGP MZITYR HTKLCOD UFXA BFTNVWJ
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
ftq ruhq najuzs iulmdpe vgyb cguowxk FTQ RUHQ NAJUZS IULMDPE VGYB CGUOWXK
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
gur svir obkvat jvmneqf whzc dhvpxyl GUR SVIR OBKVAT JVMNEQF WHZC DHVPXYL
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
hvs twjs pclwbu kwnofrg xiad eiwqyzm HVS TWJS PCLWBU KWNOFRG XIAD EIWQYZM
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
iwt uxkt qdmxcv lxopgsh yjbe fjxrzan IWT UXKT QDMXCV LXOPGSH YJBE FJXRZAN
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
jxu vylu renydw mypqhti zkcf gkysabo JXU VYLU RENYDW MYPQHTI ZKCF GKYSABO
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
kyv wzmv sfozex nzqriuj aldg hlztbcp KYV WZMV SFOZEX NZQRIUJ ALDG HLZTBCP
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
lzw xanw tgpafy oarsjvk bmeh imaucdq LZW XANW TGPAFY OARSJVK BMEH IMAUCDQ
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
max ybox uhqbgz pbstkwl cnfi jnbvder MAX YBOX UHQBGZ PBSTKWL CNFI JNBVDER
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
nby zcpy vircha qctulxm dogj kocwefs NBY ZCPY VIRCHA QCTULXM DOGJ KOCWEFS
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
ocz adqz wjsdib rduvmyn ephk lpdxfgt OCZ ADQZ WJSDIB RDUVMYN EPHK LPDXFGT
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
pda bera xktejc sevwnzo fqil mqeyghu PDA BERA XKTEJC SEVWNZO FQIL MQEYGHU
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
qeb cfsb ylufkd tfwxoap grjm nrfzhiv QEB CFSB YLUFKD TFWXOAP GRJM NRFZHIV
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
rfc dgtc zmvgle ugxypbq hskn osgaijw RFC DGTC ZMVGLE UGXYPBQ HSKN OSGAIJW
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY
sgd ehud anwhmf vhyzqcr itlo pthbjkx SGD EHUD ANWHMF VHYZQCR ITLO PTHBJKX
the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY

[edit] Vedit macro language

This implementation ciphers/deciphers a highlighted block of text in-place in current edit buffer.

#10 = Get_Num("Enter the key: positive to cipher, negative to de-cipher: ", STATLINE)
 
Goto_Pos(Block_Begin)
while(Cur_Pos < Block_End) {
#11 = Cur_Char & 0x60 + 1
if (Cur_Char >= 'A') {
Ins_Char((Cur_Char - #11 + 26 + #10) % 26 + #11, OVERWRITE)
} else {
Char(1)
}
}
Output:
with key 13:
Original text:    Quick brown Fox jumps over the lazy Dog.
Encrypted text:   Dhvpx oebja Sbk whzcf bire gur ynml Qbt.
Decrypted text:   Quick brown Fox jumps over the lazy Dog.

[edit] Wortel

@let {
 ; this function only replaces letters and keeps case
ceasar &[s n] !!s.replace &"[a-z]"gi &[x] [
@vars {
t x.charCodeAt.
l ?{
&& > t 96 < t 123 97
&& > t 64 < t 91 65
0
}
}
 !String.fromCharCode ?{
l +l ~% 26 -+ n t l
t
}
]
 !!ceasar "abc $%^ ABC" 10
}

Returns:

"klm $%^ KLM"

[edit] XPL0

To decrypt a message use the negative value of the encrypting key. Usage: caesar key <infile.txt >outfile.xxx

code ChIn=7, ChOut=8, IntIn=10;
int Key, C;
[Key:= IntIn(8);
repeat C:= ChIn(1);
if C>=^a & C<=^z then C:= C-$20;
if C>=^A & C<=^Z then
[C:= C+Key;
if C>^Z then C:= C-26
else if C<^A then C:= C+26;
];
ChOut(0, C);
until C=$1A; \EOF
]

Example outfile.xxx:

SDFN PB ERA ZLWK ILYH GRCHQ OLTXRU MXJV.

[edit] zkl

var [const] letters=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
fcn caesarCodec(str,n,encode=True){
if(not encode) n=26-n;
m:=n+26; sz:=26-n;
ltrs:=String(letters[n,sz],letters[0,n],letters[m,sz],letters[26,n]);
str.apply('wrap(c){ try{ ltrs[letters.index(c)] } catch{ c } });
}
text:="The five boxing wizards jump quickly";
N:=3;
code:=caesarCodec(text,N);
println("text = ",text);
println("encoded(%d) = %s".fmt(N,code));
println("decoded = ",caesarCodec(code,N,False));
Output:
text = The five boxing wizards jump quickly
encoded(3) = Wkh ilyh eralqj zlcdugv mxps txlfnob
decoded = The five boxing wizards jump quickly
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox