Caesar cipher: Difference between revisions

[[Category:String manipulation]]

* [[Vigenère Cipher/Cryptanalysis]]

<br><br>

=={{header|11l}}==

I decode

key = 26 - key

The quick brown fox jumped over the lazy dogs

</pre>

=={{header|360 Assembly}}==

A good example of the use of TR instruction to translate a character.

CAESARO PROLOG

XPRNT PHRASE,L'PHRASE print phrase

THE FIVE BOXING WIZARDS JUMP QUICKLY

</pre>

=={{header|Action!}}==

CHAR base

The quick brown fox jumps over the lazy dog.

</pre>

=={{header|Ada}}==

procedure Caesar is

Ciphertext ----------->Wkh ilyh eralqj zlcdugv mxps txlfnob

Decrypted Ciphertext ->The five boxing wizards jump quickly</pre>

=={{header|ALGOL 68}}==

{{trans|Ada|Note: This specimen retains the original [[#Ada|Ada]] coding style.}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

program caesar: BEGIN

Decrypted Ciphertext ->The five boxing wizards jump quickly

</pre>

=={{header|APL}}==

∇CAESAR[⎕]∇

∇

Esl dyar: dpyargmlyj icwq qugraf dpmk TOODQ BZRD rm jmucp ayqc.

</pre>

=={{header|AppleScript}}==

on caesarDecipher(txt, |key|)

{{output}}

The quick brown fox jumps over the lazy dog.'

Key: 9

ROMANES EUNT DOMUS!

The quick brown fox jumps over the lazy dog."</syntaxhighlight>

=={{header|Applesoft BASIC}}==

110 LET K% = RND(1) * 25 + 1

DECODED WITH CAESAR 25

PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS</pre>

=={{header|Arc}}==

(= rot (fn (L N)

(if

{{Out}}

(caesar "The quick brown fox jumps over the lazy dog.")

"Gur dhvpx oebja sbk whzcf bire gur ynml qbt."

</syntaxhighlight>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program caresarcode.s */

</syntaxhighlight>

=={{header|Arturo}}==

{{trans|11l}}

iA: to :integer `A`

lowAZ: `a`..`z`

Encoded : Esp bftnv mczhy qzi ufxapo zgpc esp wlkj ozrd

Decoded : The quick brown fox jumped over the lazy dogs</pre>

=={{header|Astro}}==

if decode:

k = 26 - k

print(message, encrypted, decrypted, sep: '\n')</syntaxhighlight>

=={{header|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

s=HI

t:=&s

MsgBox % o</syntaxhighlight>

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

Loop Parse, string

{

{{out}}<pre>j k

Bc</pre>

=={{header|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)

EndFunc ;==>Caesar

</syntaxhighlight>

=={{header|AWK}}==

#!/usr/bin/awk -f

clear: MY HOVERCRAFT IS FULL OF EELS.

</pre>

=={{header|Babel}}==

{"The quick brown fox jumps over the lazy dog.\n"

dup <<

Kyv hlztb sifne wfo aldgj fmvi kyv crqp ufx.

The quick brown fox jumps over the lazy dog.</pre>

=={{header|BaCon}}==

CONST uc$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Decrypted: The quick brown fox jumps over the lazy dog.

</pre>

=={{header|bash}}==

Caesar cipher bash implementation

{{works with|GNU bash, version 4}}

caesar_cipher() {

Hello World!

</pre>

=={{header|BASIC256}}==

# Caeser Cipher

# basic256 1.1.4.0

MY HOVERCRAFT IS FULL OF EELS.

</pre>

=={{header|BBC BASIC}}==

PRINT plaintext$

Zkmu wi lyh gsdr psfo nyjox vsaeyb teqc

Pack my box with five dozen liquor jugs</pre>

=={{header|Beads}}==

calc main_init

var str = "The five boxing wizards (🤖) jump quickly."

Decrypted: The five boxing wizards (🤖) jump quickly.

</pre>

=={{header|Befunge}}==

Almost direct copy of the [[Vigenère cipher#Befunge|Vigenère cipher]], although the code has been reversed and the first line eliminated because of the simpler key initialisation.

The text to encrypt is read from stdin, and the key is the first integer on the stack - 11 (<tt>65+</tt>) in the example below.

"`"::_@#!`\*84:<~<$<^+"A"%*2+9<v"{"\`

**-"A"-::0\`\55*`+#^_\0g+"4"+4^>\`*48</syntaxhighlight>

The decrypter is essentially identical, except for a change of sign on the last line.

"`"::_@#!`\*84:<~<$<^+"A"%*2+9<v"{"\`

**-"A"-::0\`\55*`+#^_\0g-"4"+4^>\`*48</syntaxhighlight>

<pre>ESPBFTNVMCZHYQZIUFXAPOZGPCESPWLKJOZRD

THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGS</pre>

=={{header|BQN}}==

Rot ← {i←⊑"A[a{"⍋𝕩 ⋄ i⊑o+p|(𝕨×m)+𝕩-o}⎉0</syntaxhighlight>

Example:

<pre>"Zh'uh qr vwudqjhuv wr oryh // Brx nqrz wkh uxohv dqg vr gr L"</pre>

([https://mlochbaum.github.io/BQN/try.html#code=byDihpAgQOKAvydBJ+KAv0DigL8nYSfigL9AIOKLhCBtIOKGkCA14qWK4oaVMiDii4QgcCDihpAgbeKKj+KInuKAvzI2ClJvdCDihpAge2nihpDiipEiQVtheyLijYvwnZWpIOKLhCBp4oqRbytwfCjwnZWow5dtKSvwnZWpLW994o6JMAoKMyBSb3QgIldlJ3JlIG5vIHN0cmFuZ2VycyB0byBsb3ZlIC8vIFlvdSBrbm93IHRoZSBydWxlcyBhbmQgc28gZG8gSSIK online REPL])

=={{header|Brainf***}}==

+ start the key input loop

Input:

<!-- Using whitespace syntax highlighting to show the spaces, used by the program to separate arguments -->

Output:

<pre>klm</pre>

Input:

Output:

<pre>abc</pre>

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

return 0;

}</syntaxhighlight>

=={{header|C sharp|C#}}==

using System.Linq;

Encrypted: Ufhp rd gtc bnym knaj itejs qnvztw ozlx.

Decrypted: Pack my box with five dozen liquor jugs.</pre>

=={{header|C++}}==

#include <iostream>

#include <algorithm>

===={{works with|C++-11}}====

#include <string>

Decrypted: This is a line of plain text, 50 characters long.

</pre>

=={{header|Clojure}}==

Readable version:

(if (Character/isLetter c)

(let [v (int c)

Terser version using replace:

(let [f #(take 26 (drop %3 (cycle (range (int %1) (inc (int %2))))))

a #(map char (concat (f \a \z %) (f \A \Z %)))]

=> "The Quick Brown Fox jumped over the lazy dog"

</pre>

=={{header|COBOL}}==

COBOL-85 ASCII or EBCIDIC

identification division.

program-id. caesar.

{{works with|OpenCOBOL|2.0}}

PROGRAM-ID. caesar-cipher.

Decrypted: The quick brown fox jumps over the lazy dog.

</pre>

=={{header|CoffeeScript}}==

msg.replace /([a-z|A-Z])/g, ($1) ->

c = $1.charCodeAt(0)

dcDc %^&*()

</pre>

=={{header|Commodore BASIC}}==

Very generic implementation. Please note that in Commodore BASIC, SHIFT-typed letters (to generate either graphic symbols in upper-case mode, or capital letters in lower-case mode) do '''not''' translate to PETSCII characters 97 through 122, but instead to characters 193 through 218.

2 rem rosetta code

10 print chr$(147);chr$(14);

&#9608;

</pre>

=={{header|Common Lisp}}==

====Main version====

(let* ((c (char-code ch)) (la (char-code #\a)) (ua (char-code #\A))

(base (cond ((<= la c (char-code #\z)) la)

Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob

Decrypted: The five boxing wizards jump quickly</pre>

(defun caesar-encipher (s k)

(map 'string #'(lambda (c) (z c k)) s))

1. Program

(defun caesar (txt offset)

(caesar "Nir Pnrfne zbevghev gr fnyhgnag" -13)

Ave Caesar morituri te salutant</pre>

=={{header|Crystal}}==

ALPHABET = ("A".."Z").to_a

decrypted = encrypted.caesar_cipher(-5)

</syntaxhighlight>

=={{header|Cubescript}}==

//Cubescript's built-in mod will fail on negative numbers

Usage:

> 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.</syntaxhighlight>

=={{header|D}}==

S rot(S)(in S s, in int key) pure nothrow @safe

Decrypted: The five boxing wizards jump quickly</pre>

Simpler in-place version (same output):

void inplaceRot(char[] txt, in int key) pure nothrow {

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

string rot(in string s, in int key) pure nothrow @safe {

writeln("Decrypted: ", txt.rot(key).rot(26 - key));

}</syntaxhighlight>

=={{header|Dart}}==

int _key;

"Dro Aesmu Lbygx Pyh Tewzc Yfob Dro Vkji Nyq." decrypts to:

"The Quick Brown Fox Jumps Over The Lazy Dog."</pre>

=={{header|Delphi}}==

See [[#Pascal]].

=={{header|Dyalect}}==

{{trans|C#}}

if !this.IsLetter() {

return this

Encrypted: Ufhp rd gtc bnym knaj itejs qnvztw ozlx.

Decrypted: Pack my box with five dozen liquor jugs.</pre>

=={{header|EDSAC order code}}==

The EDSAC had only upper-case letters, which were represented by 5-bit codes.

If the program is running in the EdsacPC simulator, the user can enter a message by storing it in a text file, making that file the active file, and clicking Reset.

The message must be terminated by a blank row of tape (represented by '.' in EdsacPC).

[Caesar cipher for Rosetta Code.

EDSAC program, Initial Orders 2.]

ENTER MESSAGE

</pre>

=={{header|Eiffel}}==

class

APPLICATION

Decoded string (after encoding and decoding): The tiny tiger totally taunted the tall Till.

</pre>

=={{header|Ela}}==

chars = "ABCDEFGHIJKLMOPQRSTUVWXYZ"

Encoded string: "JGOOQ! VJKU KU C UGETGV PGUUCIG!"

Decoded string: "HELLO! THIS IS A SECRET MESSAGE!"</pre>

=={{header|Elena}}==

ELENA 4.x :

import system'math;

import extensions;

Decrypted text:Pack my box with five dozen liquor jugs.

</pre>

=={{header|Elixir}}==

defp set_map(map, range, key) do

org = Enum.map(range, &List.to_string [&1])

Decrypted: The five boxing wizards jump quickly

</pre>

=={{header|Erlang}}==

%% Ceasar cypher in Erlang for the rosetta code wiki.

%% Implemented by J.W. Luiten

</syntaxhighlight>

{{out}}

<pre>

"The five boxing wizards jump quickly"

</pre>

=={{header|ERRE}}==

PROGRAM CAESAR

Pack my box with five dozen liquor jugs

</pre>

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

--caesar cipher for Rosetta Code wiki

--User:Lnettnay

"The Quick Brown Fox Jumps Over The Lazy Dog."

</pre>

=={{header|F_Sharp|F#}}==

open System

val it : string = "The quick brown fox jumps over the lazy dog."

</pre>

=={{header|Factor}}==

{{works with|Factor|0.97}}

{{trans|F#}}

IN: rosetta-code.caesar-cipher

Esp bftnv mczhy qzi ufxapo zgpc esp wlkj ozr.

</pre>

=={{header|Fantom}}==

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

class Main

{

Decode: Encrypt - With ! Case,

</pre>

=={{header|Fhidwfe}}==

only encodes letters

lowers = ['a','z']

uppers = ['A','Z']

//this compiles with only 6 warnings!

</syntaxhighlight>

=={{header|Forth}}==

over 32 or [char] a -

dup 0 26 within if

3 ceasar-inverse test 2@ ceasar-string

test 2@ cr type</syntaxhighlight>

=={{header|Fortran}}==

{{works with|Fortan 90 and later}}

implicit none

Encrypted message = Wkh ilyh eralgj zlcdugv mxps txlfnob

Decrypted message = The five boxing wizards jump quickly</pre>

=={{header|FreeBASIC}}==

Sub Encrypt(s As String, key As Integer)

Decrypted : Bright vixens jump; dozy fowl quack.

</pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=cb96008082bc0d8278224cd2a5ec74d3 Click this link to run this code]'''

Dim byKey As Byte = 3 'The key (Enter 26 to get the same output as input)

Dim byCount As Byte 'Counter

Wkh ilyh eralqj zlcdugv mxps txlfnob

</pre>

=={{header|GAP}}==

local r, c, i, lower, upper;

lower := "abcdefghijklmnopqrstuvwxyz";

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."</syntaxhighlight>

=={{header|GFA Basic}}==

'

' Caesar cypher

ENDFUNC

</syntaxhighlight>

=={{header|Go}}==

Obvious solution with explicit testing for character ranges:

import (

}</syntaxhighlight>

Data driven version using functions designed for case conversion. (And for method using % operator, see [[Vigen%C3%A8re_cipher#Go]].)

import (

Key 26 invalid

</pre>

=={{header|Groovy}}==

Java style:

def builder = new StringBuilder()

text.each { character ->

Functional style:

text.chars.collect { c ->

int off = c.isUpperCase() ? 'A' : 'a'

Ninja style:

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

}

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

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) }</syntaxhighlight>

and the same with closures for somewhat better readability:

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) }</syntaxhighlight>

Test code:

def plainText = "The Quick Brown Fox jumped over the lazy dog"

def cipherKey = 12

cypherText(12): Ftq Cguow Ndaiz Raj vgybqp ahqd ftq xmlk pas

decodedText(12): The Quick Brown Fox jumped over the lazy dog</pre>

=={{header|Haskell}}==

import Data.Char

Similarly, but allowing for negative cipher keys, and using isAlpha, isUpper, negate:

import Data.Char (chr, isAlpha, isUpper, ord)

Or with proper error handling:

module Main where

where b' = fromIntegral $ ord b

c' = fromIntegral $ ord c</syntaxhighlight>

=={{header|Hoon}}==

++ enc

|= [msg=tape key=@ud]

(enc msg (sub 26 key))

--</syntaxhighlight>

=={{header|Icon}} and {{header|Unicon}}==

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

ctext := caesar(ptext := map("The quick brown fox jumped over the lazy dog"))

dtext := caesar(ctext,,"decrypt")

Encphered text = "wkh txlfn eurzq ira mxpshg ryhu wkh odcb grj"

Decphered text = "the quick brown fox jumped over the lazy dog"</pre>

=={{header|IS-BASIC}}==

110 STRING M$*254

120 INPUT PROMPT "String: ":M$

490 LET M$=T$

500 END DEF</syntaxhighlight>

=={{header|J}}==

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

caesar=: (cndx 0)}&a.@u:@cndx@[ {~ a.i.]</syntaxhighlight>

Vjku ukorng "oqpqcnrjcdgvke uwduvkvwvkqp ekrjgt" rtqxkfgu cnoquv pq ugewtkva, ...</syntaxhighlight>

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

BC</syntaxhighlight>

=={{header|Janet}}==

(def alphabet "abcdefghijklmnopqrstuvwxyz")

"thequickbrownfoxjumpsoverthelazydog"

</pre>

=={{header|Java}}==

{{works with|Java|1.5+}}

public static void main(String[] args) {

The quick brown fox Jumped over the lazy Dog

</pre>

=={{header|JavaScript}}==

===ES5===

return text.toUpperCase().replace(/[^A-Z]/g,'').replace(/./g, function(a) {

return String.fromCharCode(65+(a.charCodeAt(0)-65+shift)%26);

===ES6===

.toUpperCase()

.replace(/[^A-Z]/g, '')

Or, allowing encoding and decoding of both lower and upper case:

// Int -> String -> String

{{Out}}

<pre>Mebsy, Mockbo foxxo, o fsno o fsxco ? , -> , Curio, Cesare venne, e vide e vinse ?</pre>

=={{header|jq}}==

{{trans|Wren}}

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

. as $s

| explode as $xs

Bright vixens jump; dozy fowl quack.

</pre>

=={{header|Jsish}}==

From Typescript entry.

"use strict";

<pre>prompt$ jsish -u caesarCipher.jsi

[PASS] caesarCipher.jsi</pre>

=={{header|Julia}}==

===updated version for Julia 1.x | Rename isalpha to isletter #27077 | https://github.com/JuliaLang/julia/pull/27077===

# Caeser cipher

# Julia 1.5.4

"Zntvp Rapelcgvba"

</pre>

=={{header|K}}==

Assumes lowercase letters, and no punctuation.

s:"there is a tide in the affairs of men"

caesar:{ :[" "=x; x; {x!_ci 97+!26}[y]@_ic[x]-97]}'

"uifsf jt b ujef jo uif bggbjst pg nfo"

</syntaxhighlight>

=={{header|Kotlin}}==

object Caesar {

Bright vixens jump; dozy fowl quack.

</pre>

=={{header|LabVIEW}}==

For readability, input is in all caps.<br/>{{VI snippet}}<br/>[[File:LabVIEW_Caesar_cipher.png]]

=={{header|Lambdatalk}}==

The caesar function encodes and decodes texts containing exclusively the set [ABCDEFGHIJKLMNOPQRSTUVWXZ].

{def caesar

</syntaxhighlight>

=={{header|langur}}==

Using the built-in rotate() function on a number over a range, a number outside of the range will pass through unaltered.

cp2s map(f(.c) rotate(rotate(.c, .key, 'a'..'z'), .key, 'A'..'Z'), s2cp .s)

}

encrypted: X nrfzh yoltk clu grjmba lsbo pljbqefkd.

decrypted: A quick brown fox jumped over something.</pre>

=={{header|Liberty BASIC}}==

Print "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

Next i

End Function</syntaxhighlight>

=={{header|LiveCode}}==

local rotPhrase, lowerLetters, upperLetters

put "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" into lowerLetters

return rotPhrase

end caesarCipher</syntaxhighlight>

=={{header|Logo}}==

{{trans|Common Lisp}}

{{works with|UCB Logo}}

make "lower_a ascii "a

make "lower_z ascii "z

Encrypted: Wkh ilyh eralqj zlcdugv mxps txlfnob

Recovered: The five boxing wizards jump quickly</pre>

=={{header|Lua}}==

return text:gsub("%a", function(t)

local base = (t:lower() == t and string.byte('a') or string.byte('A'))

'''Fast version'''

local function make_table(k)

return string.char(unpack(res_t))

end</syntaxhighlight>

=={{header|M2000 Interpreter}}==

We use a Buffer object (is a pointer type to a block of memory), to store string, to have access using unsigned integers.

a$="THIS IS MY TEXT TO ENCODE WITH CAESAR CIPHER"

Function Cipher$(a$, N) {

</syntaxhighlight>

=={{header|Maple}}==

> StringTools:-Encode( "The five boxing wizards jump quickly", encoding = alpharot[3] );

"Wkh ilyh eralqj zlcdugv mxps txlfnob"

</syntaxhighlight>

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

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

<pre>cypher["The five boxing wizards jump quickly",3]

-> Wkh ilyh eralqj zlcdugv mxps txlfnob</pre>

=={{header|MATLAB}} / {{header|Octave}}==

s = char( mod(s - 'A' + key, 25 ) + 'A');

end;

end; </syntaxhighlight>

Here is a test:

ans = ABC </syntaxhighlight>

=={{header|Microsoft Small Basic}}==

TextWindow.Write("Enter a 1-25 number key (-ve number to decode): ")

key = TextWindow.ReadNumber()

Press any key to continue...

</pre>

=={{header|MiniScript}}==

chars = s.values

for i in chars.indexes

<pre>Olssv dvysk!

Hello world!</pre>

=={{header|ML}}==

==={{header|mLite}}===

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

| x = let val ln = readln ()

in if eof ln then

Output:

<pre>Ocz xvo nvo ji ocz hvo</pre>

=={{header|Modula-2}}==

{{trans|Java}}

FROM Conversions IMPORT IntToStr;

FROM Terminal IMPORT WriteString, WriteLn, ReadChar;

ReadChar;

END CaesarCipher.</syntaxhighlight>

=={{header|Modula-3}}==

This implementation distinguishes between "encoding" and "encryption."

It also illustrates the use of exceptions in Modula-3.

IMPORT IO, IntSeq, Text;

whencaesarsetofftogaul

</pre>

=={{header|Nanoquery}}==

uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

lowercase = "abcdefghijklmnopqrstuvwxyz"

return plaintext

end</syntaxhighlight>

=={{header|NetRexx}}==

The cipher code in this sample is also used in the [[Rot-13#NetRexx|Rot-13&nbsp;&ndash;&nbsp;NetRexx]] task.

options replace format comments java crossref savelog symbols nobinary

HI

</pre>

=={{header|Nim}}==

{{trans|Python}}

proc caesar(s: string, k: int, decode = false): string =

echo enc

echo caesar(enc, 11, decode = true)</syntaxhighlight>

=={{header|Oberon-2}}==

Works with oo2c version2

MODULE Caesar;

IMPORT

The five boxing wizards jump quickly =e=> Wkh ilyh eralqj zlcdugv mxps txlfnob =d=> The five boxing wizards jump quickly

</pre>

=={{header|Objeck}}==

class Caesar {

function : native : Encode(enc : String, offset : Int) ~ String {

the quick brown fox jumped over the lazy dog

</pre>

=={{header|OCaml}}==

c >= 'a' && c <= 'z'

c

) str</syntaxhighlight>

let key = 3 in

let orig = "The five boxing wizards jump quickly" in

The five boxing wizards jump quickly

equal: true</pre>

=={{header|Oforth}}==

c dup isLetter ifFalse: [ return ]

isUpper ifTrue: [ 'A' ] else: [ 'a' ] c key + over - 26 mod + ;

Pack my box with five dozen liquor jugs.

</pre>

=={{header|OOC}}==

shift := args[1] toInt()

if (args length != 3) {

$ ./caesar -9 "Yet another, fairly original sentence!"

Pvk refkyvi, wrzicp fizxzerc jvekvetv!</pre>

=={{header|PARI/GP}}==

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);</syntaxhighlight>

=={{header|Pascal}}==

procedure encrypt(var message: string; key: integer);

Decrypted message: The five boxing wizards jump quickly

>: </pre>

=={{header|Perl}}==

my ($message, $key, $decode) = @_;

$key = 26 - $key if $decode;

enc: DRO PSFO LYHSXQ GSJKBNC TEWZ AESMUVI

dec: THE FIVE BOXING WIZARDS JUMP QUICKLY</pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">alpha_b</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">255</span><span style="color: #0000FF;">)</span>

Back to back they faced each other, drew their swords and shot each other. %^&*()[

</pre>

=={{header|PHP}}==

function caesarEncode( $message, $key ){

$plaintext = strtolower( $message );

Or, using PHP's '''strtr()''' built-in function

function caesarEncode($message, $key) {

{{out}}

<pre>FTQ CGUOW NDAIZ RAJ VGYBQP AHQD FTQ XMLK PAS</pre>

=={{header|Picat}}==

S = "All human beings are born free and equal in dignity and rights.",

println(S),

Fqq mzrfs gjnslx fwj gtws kwjj fsi jvzfq ns inlsnyd fsi wnlmyx.

All human beings are born free and equal in dignity and rights.</pre>

=={{header|PicoLisp}}==

(de caesar (Str Key)

: (caesar @ (- 26 7))

-> "THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGSBACK"</pre>

=={{header|Pike}}==

Pike has built in support for substitution cryptos in the Crypto module. It's possible to set the desired alphabet, but the default a-z matches the Caesar range.

string msg = "The quick brown fox jumped over the lazy dogs";

string msg_s2 = c->encrypt(msg);

The quick brown fox jumped over the lazy dogs

</pre>

=={{header|PL/I}}==

declare cypher_string character (52) static initial

((2)'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

Decyphered text= THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG

</pre>

=={{header|PowerShell}}==

function Get-CaesarCipher

{

Vsxo drboo;

</pre>

=={{header|Prolog}}==

{{Works with|SWI-Prolog}}

{{libheader|clpfd}}

caesar :-

true .

</pre>

=={{header|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.

;if reverse <> 0 then reverse the encryption (decrypt)

If reverse: reverse = 26: key = 26 - key: EndIf

===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.

;if reverse <> 0 then reverse the encryption (decrypt)

Protected i, *letter.Character, *resultLetter.Character, result.s = Space(Len(text))

ProcedureReturn result

EndProcedure</syntaxhighlight>

=={{header|Python}}==

if decode: k = 26 - k

return "".join([chr((ord(i) - 65 + k) % 26 + 65)

Alternate solution

{{works with|Python|2.x}} (for 3.x change <code>string.maketrans</code> to <code>str.maketrans</code>)

def caesar(s, k, decode = False):

if decode: k = 26 - k

Variant with memoization of translation tables

{{works with|Python|3.x}}

def caesar(s, k = 13, decode = False, *, memo={}):

if decode: k = 26 - k

A compact alternative solution

from string import ascii_uppercase as abc

THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGS

</pre>

=={{header|QBasic}}==

{{works with|QBasic}}

{{works with|True BASIC}} Note that TrueBasic uses '!' for comments

{{trans|BASIC256}}

LET tipo$ = "cleartext "

NEXT i

END</syntaxhighlight>

=={{header|Quackery}}==

[ dup lower != ] is upper? ( c --> b )

Cbob ifybkqbo eljfkbp fa nrla slirkq zobarkq.

Fere libenter homines id quod volunt credunt.</pre>

=={{header|R}}==

This is a generalization of the Rot-13 solution for R at: http://rosettacode.org/wiki/Rot-13#R .