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 .

# based on Rot-13 solution: http://rosettacode.org/wiki/Rot-13#R

ceasar <- function(x, key)

[1] "Decrypted Text: The five boxing wizards jump quickly."

</pre>

=={{header|Racket}}==

#lang racket

"The five boxing wizards jump quickly."

</pre>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

sub encrypt ( $key where 1..25, $plaintext ) {

$plaintext.trans( @alpha Z=> @alpha.rotate($key) );

THE FIVE BOXING WIZARDS JUMP QUICKLY

OK</pre>

=={{header|Red}}==

Red ["Ceasar Cipher"]

 

>>

</pre>

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

"THEYBROKEOURCIPHEREVERYONECANREADTHIS" 3 ceaser ( returns encrypted string )

23 ceaser ( returns decrypted string )</syntaxhighlight>

=={{header|REXX}}==

===only Latin letters===

This version conforms to the task's restrictions.

/*──────────── or blanks allowed, all lowercase Latin letters are treated as uppercase.*/

parse arg key .; arg . p /*get key & uppercased text to be used.*/

This version allows upper and lowercase Latin alphabet as well as all the

characters on the standard (computer) keyboard including blanks.

parse arg key p /*get key and the text to be cyphered. */

say 'Caesar cypher key:' key /*echo the Caesar cypher key to console*/

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

</pre>

=={{header|Ring}}==

# Project : Caesar cipher

 

pack my box with five dozen liquor jugs

</pre>

=={{header|Ruby}}==

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

 

decrypted = encypted.caesar_cipher(-3)

</syntaxhighlight>

=={{header|Run BASIC}}==

 

a$ = "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</pre>

=={{header|Rust}}==

This example shows proper error handling. It skips non-ASCII characters.

use std::fmt::Display;

use std::{env, process};

process::exit(code);

}</syntaxhighlight>

=={{header|Scala}}==

private val alphaU='A' to 'Z'

private val alphaL='a' to 'z'

private def rot(a:IndexedSeq[Char], c:Char, key:Int)=a((c-a.head+key+a.size)%a.size)

}</syntaxhighlight>

println("Plaintext => " + text)

val encoded=Caesar.encode(text, 3)

This version first creates non shifted and shifted character sequences

and then encodes and decodes by indexing between those sequences.

@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)

}</syntaxhighlight>

 

val myCaeser = new Caeser(3)

val encoded = text.map(c => myCaeser.encode(c))

Ciphertext => Wkh ilyh eralqj zlcdugv mxps txlfnob

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

=={{header|Scheme}}==

 

; Works with R7RS-compatible Schemes (e.g. Chibi).

; Also current versions of Chicken, Gauche and Kawa.

Gur dhvpx oebja sbk whzcf bire gur ynml qbt.

</pre>

=={{header|sed}}==

This code is roughly equivalent to the [[Rot-13#sed|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.

# Input: <number 0..25>\ntext to encode

 

Error: Key must be <= 25

</pre>

=={{header|Seed7}}==

 

const func string: rot (in string: stri, in integer: encodingKey) is func

Decrypted: The five boxing wizards jump quickly

</pre>

=={{header|SequenceL}}==

You only have to write an encrypt and decrypt function for characters. The semantics of Normalize Transpose allow those functions to be applied to strings.

import <Utilities/Conversion.sl>;

 

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

</pre>

=={{header|Sidef}}==

{{trans|Perl}}

decode && (key = (26 - key));

msg.gsub(/([A-Z])/i, {|c| ((c.uc.ord - 65 + key) % 26) + 65 -> chr});

dec: THE FIVE BOXING WIZARDS JUMP QUICKLY

</pre>

=={{header|Sinclair ZX81 BASIC}}==

Works with 1k of RAM. A negative key decodes.

20 INPUT T$

30 LET C$=""

{{out}}

<pre>GALLIA EST OMNIS DIVISA IN PARTES TRES</pre>

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

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

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

!CharacterArray methodsFor:'encoding'!

rot:n

 

</syntaxhighlight>

=={{header|SSEM}}==

ASCII didn't exit in 1948, and the task specification explicitly says we only need to convert Roman capitals; so we adopt a simpler encoding, representing the letters of the alphabet from <tt>A</tt>=0 to <tt>Z</tt>=25.

 

This is in fact a general solution that will work equally well with alphabets of more or fewer than 26 characters: simply replace the constant 26 in storage address 18 with 22 for Hebrew, 24 for Greek, 28 for Arabic, 33 for Russian, etc.

11001000000000010000000000000000 1. Sub. 19

10101000000001100000000000000000 2. c to 21

11010000000000000000000000000000 17. 11

01011000000000000000000000000000 18. 26</syntaxhighlight>

=={{header|Stata}}==

 

u = ascii(s)

i = selectindex(u:>=65 :& u:<=90)

caesar("layout", 20)

fusion</syntaxhighlight>

=={{header|Swift}}==

func usage(_ e:String) {

print("error: \(e)")

main()

</syntaxhighlight>

=={{header|Tcl}}==

 

oo::class create Caesar {

}</syntaxhighlight>

Demonstrating:

set txt "The five boxing wizards jump quickly."

set enc [$caesar encrypt $txt]

Decrypted message = The five boxing wizards jump quickly.

</pre>

=={{header|TUSCRIPT}}==

text="THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"

PRINT "text orginal ",text

encoded decoded THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG

</pre>

=={{header|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 <code>enc</code> and <code>dec</code> for encoding and decoding. Filters are specified as tuples of strings.

@(cases)

@{key /[0-9]+/}

decoded: Jgnnq, yqtnf!

</pre>

=={{header|TypeScript}}==

return input.replace(/([a-z])/g,

($1) => String.fromCharCode(($1.charCodeAt(0) + key + 26 - 97) % 26 + 97)

console.log('Enciphered: ' + encoded);

console.log('Deciphered: ' + decoded);</syntaxhighlight>

=={{header|UNIX Shell}}==

{{works with|bash}}

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

local OPTIND

local encrypt n=0

encrypted: Ymj knaj gtcnsl bnefwix ozru vznhpqd.

decrypted: The five boxing wizards jump quickly.</pre>

=={{header|Ursa}}==

while (not (or (= mode "encode") (= mode "decode")))

out "encode/decode: " console

end for

out endl console</syntaxhighlight>

=={{header|Ursala}}==

The reification operator (<code>-:</code>) 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 nat

 

sgd ehud anwhmf vhyzqcr itlo pthbjkx SGD EHUD ANWHMF VHYZQCR ITLO PTHBJKX

the five boxing wizards jump quickly THE FIVE BOXING WIZARDS JUMP QUICKLY</pre>

=={{header|Vala}}==

This is a port of the C# code present in this page.

stdout.printf("%s\r\n", str);

}

The quick brown fox jumped over the lwzy dog

</pre>

=={{header|VBA}}==

 

Option Explicit

 

<pre>QOSGOF: Kvc wg wh wb hvs dfsgg hvoh qozzg cb as? W vsof o hcbuis, gvfwzzsf hvob ozz hvs aigwq, Qfm 'Qosgof!' Gdsoy; Qosgof wg hifb'r hc vsof.

CAESAR: Who is it in the press that calls on me? I hear a tongue, shriller than all the music, Cry 'Caesar!' Speak; Caesar is turn'd to hear.</pre>

=={{header|VBScript}}==

Note that a left rotation has an equivalent right rotation so all rotations are converted to the equivalent right rotation prior to translation.

str = "IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES."

 

IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES.

</pre>

=={{header|Vedit macro language}}==

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

 

Goto_Pos(Block_Begin)

Decrypted text: Quick brown Fox jumps over the lazy Dog.

</pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function Encrypt(ch As Char, code As Integer) As Char

Encrypted: Ufhp rd gtc bnym knaj itejs qnvztw ozlx.

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

=={{header|Wortel}}==

; this function only replaces letters and keeps case

ceasar &[s n] !!s.replace &"[a-z]"gi &[x] [

Returns:

<pre>"klm $%^ KLM"</pre>

=={{header|Wren}}==

{{trans|Kotlin}}

static encrypt(s, key) {

var offset = key % 26

Bright vixens jump; dozy fowl quack.

</pre>

=={{header|X86 Assembly}}==

{{trans|C custom implementation}}

{{works with|GCC|7.3.0 - Ubuntu 18.04 64-bit}}

 

.intel_syntax noprefix

ret # return 0</syntaxhighlight>

Usage:

$ ./caesar 10 abc

klm

$ ./caesar 16 klm

abc</syntaxhighlight>

=={{header|XBasic}}==

{{trans|Modula-2}}

{{works with|Windows XBasic}}

PROGRAM "caesarcipher"

VERSION "0.0001"

Decrypted: The five boxing wizards jump quickly

</pre>

=={{header|XBS}}==

 

func caesar(text,shift:number=1){

Hi

</pre>

=={{header|XLISP}}==

(defun encode (ascii-code)

(defun rotate (character alphabet)

(caesar-encode text (- 26 key)))</syntaxhighlight>

Test it in a REPL:

 

CAESAR-TEST

 

"CAESAR: Who is it in the press that calls on me? I hear a tongue, shriller than all the music, Cry 'Caesar!' Speak; Caesar is turn'd to hear."</syntaxhighlight>

=={{header|XPL0}}==

To decrypt a message use the negative value of the encrypting key.

Usage: caesar key <infile.txt >outfile.xxx

 

int Key, C;

[Key:= IntIn(8);

SDFN PB ERA ZLWK ILYH GRCHQ OLTXRU MXJV.

</pre>

=={{header|Yabasic}}==

REM *** By changing the key and pattern, an encryption system that is difficult to break can be achieved. ***

 

 

You are encouraged to solve this task according to the task description, using any language you may know.</pre>

=={{header|zkl}}==

var [const] letters=["a".."z"].chain(["A".."Z"]).pump(String); // static

if(not encode) n=26 - n;

str.translate(letters,ltrs)

}</syntaxhighlight>

N:=3;

code:=caesarCodec(text,N);

decoded = The five boxing wizards jump quickly

</pre>

=={{header|zonnon}}==

module Caesar;

const

The five boxing wizards jump quickly -c-> RFC DGTC ZMVGLE UGXYPBQ HSKN OSGAIJW -d-> THE FIVE BOXING WIZARDS JUMP QUICKLY

</pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC BASIC}}

20 PRINT t$''

30 LET key=RND*25+1

</syntaxhighlight>

{{trans|Yabasic}}

20 LET c$="a":REM more characters, more difficult for decript

30 LET CIFRA=1: LET DESCIFRA=-1