Caesar cipher: Difference between revisions

 

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

I decode

key = 26 - key

V enc = caesar(msg, 11)

print(enc)

{{out}}

<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

ORG

YREGS

{{out}}

<pre>

 

=={{header|8th}}==

: modulate \ char base -- char

tuck n:- 26 n:+ 26 n:mod n:+ ;

1 caesar dup . cr

-1 caesar . cr

{{out}}

<pre>

 

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

CHAR base

 

Test("The quick brown fox jumps over the lazy dog.",23)

Test("The quick brown fox jumps over the lazy dog.",5)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Caesar_cipher.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure Caesar is

Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

 

{{out}}

<pre>> ./caesar

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

printf(($gl$, "Decrypted Ciphertext ->" + encrypt(text, -key)))

 

{{out}}

<pre>

 

=={{header|APL}}==

∇CAESAR[⎕]∇

∇

[3] A←V

∇

{{out}}

<pre>

=={{header|AppleScript}}==

 

 

on caesarDecipher(txt, |key|)

set enciphered to caesarEncipher(txt, |key|)

set deciphered to caesarDecipher(enciphered, |key|)

 

{{output}}

 

The quick brown fox jumps over the lazy dog.'

Key: 9

Cqn zdrlt kaxfw oxg sdvyb xena cqn ujih mxp.

ROMANES EUNT DOMUS!

 

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

 

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

460 IF C > 90 THEN C = C - 26

470 LET C$ = CHR$(C + L)

{{out}}

<pre>]RUN

 

=={{header|Arc}}==

(= rot (fn (L N)

(if

(string output)

))

 

{{Out}}

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

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

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program caresarcode.s */

bx lr @ return

 

 

=={{header|Arturo}}==

{{trans|11l}}

iA: to :integer `A`

lowAZ: `a`..`z`

enc: caesar msg 11

print [" Encoded :" enc]

 

{{out}}

 

=={{header|Astro}}==

if decode:

k = 26 - k

let decrypted = caesar(enc, 11, decode: true)

 

 

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

While *t

o.=Chr(Mod(*t-65+n,26)+65),t+=2

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

Loop Parse, string

{

}

 

{{out}}<pre>j k

Bc</pre>

 

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)

Return $sLetters

EndFunc ;==>Caesar

 

=={{header|AWK}}==

#!/usr/bin/awk -f

 

return s

}

 

{{out}}

=={{header|Babel}}==

 

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

dup <<

<- 0x60 cugt ->

0x7b cult

 

{{out}}

 

=={{header|BaCon}}==

CONST uc$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

 

 

PRINT "Encrypted: ", en$

{{out}}

<pre>

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

 

caesar_cipher() {

 

}

 

 

{{out}} (input: caesar_cipher -e 13 "Hello World!"):

 

=={{header|BASIC256}}==

# Caeser Cipher

# basic256 1.1.4.0

next i

{{out}}

<pre>

 

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

PRINT plaintext$

NEXT

= text$

{{out}}

<pre>Pack my box with five dozen liquor jugs

 

=={{header|Beads}}==

calc main_init

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

) : str

// we could also just shift by 26-nshift, same as going in reverse

{{out}}

<pre>Plain: The five boxing wizards (🤖) jump quickly.

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"{"\`

 

{{out}}

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

 

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

 

{{out}}

 

=={{header|BQN}}==

 

Example:

 

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

 

 

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

 

+ start the key input loop

^

<< :c ^

Usage:

Give to the program the key and the word to encrypt, each followed by a space.<br>

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;

 

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

using System.Linq;

 

}

}

{{out}}

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

 

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

#include <iostream>

#include <algorithm>

std::cout << input << std::endl ;

return 0 ;

{{out}}

<pre>Which text is to be encrypted ?

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

 

 

#include <string>

return 0 ;

}

 

{{out}}

=={{header|Clojure}}==

Readable version:

(if (Character/isLetter c)

(let [v (int c)

(print "Original text:" text "\n")

(print "Encryption:" enc "\n")

 

output:

 

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 %)))]

 

(defn decode [k s]

 

output:<pre>

=={{header|COBOL}}==

COBOL-85 ASCII or EBCIDIC

identification division.

program-id. caesar.

.

end program caesar.

{{out}}

<pre>

 

{{works with|OpenCOBOL|2.0}}

PROGRAM-ID. caesar-cipher.

 

MOVE FUNCTION encrypt(decrypt-offset, str) TO decrypted-str

.

 

{{out}}

 

=={{header|CoffeeScript}}==

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

c = $1.charCodeAt(0)

console.log cipher "Hello World", 2

{{out}}

<pre>

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

3035 cm$=cm$+mid$(ec$,c,1)

3040 next i

 

{{Output}}

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

(format t " Original: ~a ~%" original-text)

(format t "Encrypted: ~a ~%" cipher-text)

{{out}}

<pre> Original: The five boxing wizards jump quickly

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

(when (<= 65 c 90) 65))))

(if b (code-char (+ (mod (+ (- c b) k) 26) b)) h))

{{out}}

<pre>

1. Program

 

(defun caesar (txt offset)

(char +a+ (mod (+ (position c +a+) (* 2 offset)) 52))

c))

 

2. Execution

 

=={{header|Crystal}}==

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

 

encrypted = "THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG".caesar_cipher(5)

decrypted = encrypted.caesar_cipher(-5)

 

=={{header|Cubescript}}==

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

 

] ]

result $arg1

 

Usage:

> Ymj Vznhp Gwtbs Ktc Ozrux Tajw Ymj Qfed Itl.

>>> decipher "Ymj Vznhp Gwtbs Ktc Ozrux Tajw Ymj Qfed Itl." 5

 

=={{header|D}}==

 

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

writeln("Encrypted: ", txt.rot(key));

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

{{out}}

<pre>Original: The five boxing wizards jump quickly

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

Simpler in-place version (same output):

 

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

txt.inplaceRot(26 - key);

writeln("Decrypted: ", txt);

 

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

 

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

writeln("Encrypted: ", txt.rot(key));

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

 

=={{header|Dart}}==

int _key;

 

trip(".-:/\"\\!");

trip("The Quick Brown Fox Jumps Over The Lazy Dog.");

{{out}}

<pre>JK

{{trans|C#}}

 

if !this.IsLetter() {

return this

print("Encrypted: \(str)")

str = str.Decrypt(5)

 

{{out}}

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

P F [acc = 0 on entry]

DGAZA!FREQUENS!LIBYCUM!DUXIT!KARTHAGO!TRIUMPHUM.

{{out}}

<pre>

 

=={{header|Eiffel}}==

class

APPLICATION

end

end

{{out}}

<pre>

=={{header|Ela}}==

 

 

chars = "ABCDEFGHIJKLMOPQRSTUVWXYZ"

putStrLn ""

putStr "Decoded string: "

 

{{out}}

=={{header|Elena}}==

ELENA 4.x :

import system'math;

import extensions;

 

console.readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

defp set_map(map, range, key) do

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

IO.puts "Original: #{text}"

IO.puts "Encrypted: #{enc = Caesar_cipher.encode(text, key)}"

 

{{out}}

 

=={{header|Erlang}}==

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

%% Implemented by J.W. Luiten

PlainText = lists:map(fun(Char) -> rot(Char, Decode) end, CypherText).

 

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM CAESAR

 

 

END PROGRAM

{{out}}

<pre>

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

--caesar cipher for Rosetta Code wiki

--User:Lnettnay

printf(1,"%s\n",{text})

 

{{out}}

<pre>

 

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

open System

 

 

let encrypt n = cipher n

<pre>&gt; caesar.encrypt 2 "HI";;

val it : string = "JK"

{{works with|Factor|0.97}}

{{trans|F#}}

IN: rosetta-code.caesar-cipher

 

 

11 "Esp bftnv mczhy qzi ufxapo zgpc esp wlkj ozr." decrypt print

{{out}}

<pre>

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

 

class Main

{

}

}

 

Example:

=={{header|Fhidwfe}}==

only encodes letters

lowers = ['a','z']

uppers = ['A','Z']

 

//this compiles with only 6 warnings!

 

=={{header|Forth}}==

over 32 or [char] a -

dup 0 26 within if

 

3 ceasar-inverse test 2@ ceasar-string

 

=={{header|Fortran}}==

{{works with|Fortan 90 and later}}

implicit none

 

end subroutine

 

{{out}}

<pre>Original message = The five boxing wizards jump quickly

 

=={{header|FreeBASIC}}==

 

Sub Encrypt(s As String, key As Integer)

Decrypt s, 8

Print "Decrypted : "; s

 

{{out}}

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

Print sString & gb.NewLine & sCoded 'Print the result

 

Output:

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

 

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

'

' Caesar cypher

RETURN @encrypt$(text$,26-key%)

ENDFUNC

 

=={{header|Go}}==

Obvious solution with explicit testing for character ranges:

 

import (

fmt.Println(" Deciphered:", ck.decipher(ct))

}

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

 

import (

fmt.Println(" Deciphered:", ck.decipher(ct))

}

{{out}} (either version)

<pre>

=={{header|Groovy}}==

Java style:

def builder = new StringBuilder()

text.each { character ->

builder as String

}

 

Functional style:

text.chars.collect { c ->

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

}.join()

}

 

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

}

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

}

Test code:

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

def cipherKey = 12

assert plainText == decodedText

 

{{out}}

 

=={{header|Haskell}}==

 

import Data.Char

where b' = fromIntegral $ ord b

c' = fromIntegral $ ord c

 

And trying it out in GHCi:

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

 

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

 

cipher = caesar k

plain = "Curio, Cesare venne, e vide e vinse ? "

{{Out}}

<pre>Skhye, Suiqhu luddu, u lytu u lydiu ?

 

Or with proper error handling:

module Main where

 

addChar b o c = chr $ fromIntegral (b' + (c' - b' + o) `mod` 26)

where b' = fromIntegral $ ord b

 

=={{header|Hoon}}==

++ enc

|= [msg=tape key=@ud]

|= [msg=tape key=@ud]

(enc msg (sub 26 key))

 

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

"d"|"decrypt" : return map(text,(&lcase||&lcase)[k+:*&lcase],&lcase)

}

 

{{out}}

 

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

110 STRING M$*254

120 INPUT PROMPT "String: ":M$

480 NEXT

490 LET M$=T$

 

=={{header|J}}==

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

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

 

=={{header|Janet}}==

(def alphabet "abcdefghijklmnopqrstuvwxyz")

 

(print cipher)

(print str)))

 

{{out}}

=={{header|Java}}==

{{works with|Java|1.5+}}

public static void main(String[] args) {

 

return encoded.toString();

}

{{out}}

<pre>

===ES5===

 

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

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

for (var i = 0; i<26; i++) {

console.log(i+': '+caesar(text,i));

 

{{output}}

===ES6===

 

.toUpperCase()

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

.replace(/./g, a =>

 

 

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

 

 

// Int -> String -> String

return [strCipher, ' -> ', strDecode];

 

 

{{Out}}

{{works with|jq}}

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

. as $s

| explode as $xs

(encrypt(8)

| ., decrypt(8) )

{{out}}

<pre>

=={{header|Jsish}}==

From Typescript entry.

"use strict";

 

caesarCipher(caesarCipher(str, 3), -3) ==> The five boxing wizards jump quickly

=!EXPECTEND!=

 

{{out}}

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

 

# Caeser cipher

# Julia 1.5.4

text = "Magic Encryption"; key = 13

csrcipher(text, key)

{{out}}

<pre>

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]}'

caesar[s;1]

"uifsf jt b ujef jo uif bggbjst pg nfo"

 

=={{header|Kotlin}}==

 

object Caesar {

val decoded = Caesar.decrypt(encoded, 8)

println(decoded)

 

{{out}}

=={{header|Lambdatalk}}==

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

{def caesar

 

-> VENIVIDIVICI

 

 

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

}

writeln " original: ", .s

writeln "encrypted: ", .rot(.s, .key)

 

{{out}}

 

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

 

Print "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

CaesarCypher$ = (CaesarCypher$ + Chr$(rotate))

Next i

 

=={{header|LiveCode}}==

local rotPhrase, lowerLetters, upperLetters

put "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" into lowerLetters

end repeat

return rotPhrase

 

=={{header|Logo}}==

{{trans|Common Lisp}}

{{works with|UCB Logo}}

make "lower_a ascii "a

make "lower_z ascii "z

print sentence "|Encrypted:| :ciphertext

print sentence "|Recovered:| :recovered

 

{{out}}

=={{header|Lua}}==

 

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

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

print("Decrypted text: ", decrypted)

end

 

 

'''Fast version'''

 

local function make_table(k)

end

return string.char(unpack(res_t))

 

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

Print Cipher$(B$,12)

 

 

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

 

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

{{out}}

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

 

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

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

end;

function s = decipherCaesar(s, key)

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

Here is a test:

 

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

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

key = TextWindow.ReadNumber()

TextWindow.WriteLine(message)

TextWindow.WriteLine(caeser)

{{out}}

<pre>Enter a 1-25 number key (-ve number to decode): 10

 

=={{header|MiniScript}}==

chars = s.values

for i in chars.indexes

 

print caesar("Hello world!", 7)

 

{{out}}

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

;

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

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

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

{{trans|Java}}

FROM Conversions IMPORT IntToStr;

FROM Terminal IMPORT WriteString, WriteLn, ReadChar;

 

ReadChar;

 

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

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

 

 

IMPORT IO, IntSeq, Text;

Decode(buffer, message);

IO.Put(message); IO.PutChar('\n');

 

{{out}}

 

=={{header|Nanoquery}}==

uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

lowercase = "abcdefghijklmnopqrstuvwxyz"

 

return plaintext

 

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

 

method isFalse public static returns boolean

 

<pre style="height: 60ex; overflow: scroll;">

=={{header|Nim}}==

{{trans|Python}}

 

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

let enc = caesar(msg, 11)

echo enc

 

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

Works with oo2c version2

MODULE Caesar;

IMPORT

 

END Caesar.

Output:

<pre>

 

=={{header|Objeck}}==

class Caesar {

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

}

}

{{out}}

<pre>

 

=={{header|OCaml}}==

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

 

else

c

let key = 3 in

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

print_endline deciphered;

Printf.printf "equal: %b\n" (orig = deciphered)

{{out}}

<pre>$ ocaml caesar.ml

=={{header|Oforth}}==

 

c dup isLetter ifFalse: [ return ]

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

 

: cipherE(s, key) s map(#[ key ceasar ]) charsAsString ;

 

{{out}}

 

=={{header|OOC}}==

shift := args[1] toInt()

if (args length != 3) {

str println()

}

{{out}}

<pre>$ ./caesar 8 "This should be a fairly original sentence."

 

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

};

 

=={{header|Pascal}}==

 

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

writeln ('Decrypted message: ', message);

readln;

{{out}}

<pre>>: ./CaesarCipher

=={{header|Perl}}==

 

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

$key = 26 - $key if $decode;

print "msg: $msg\nenc: $enc\ndec: $dec\n";

 

{{out}}

 

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

<span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">caesar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span>

<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">caesar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">26</span><span style="color: #0000FF;">-</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">e</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">r</span>

{{out}}

<pre>

 

=={{header|PHP}}==

function caesarEncode( $message, $key ){

$plaintext = strtolower( $message );

 

echo caesarEncode( "The quick brown fox Jumped over the lazy Dog", 12 ), "\n";

{{out}}

<pre>ftq cguow ndaiz raj vgybqp ahqd ftq xmlk pas</pre>

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

 

 

function caesarEncode($message, $key) {

}

 

 

{{out}}

 

=={{header|Picat}}==

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

println(S),

M.put(Lower[I],Lower[II])

end.

 

{{out}}

 

=={{header|PicoLisp}}==

 

(de caesar (Str Key)

(pack

(mapcar '((C) (cadr (nth (member C *Letters) Key)))

Test:

<pre>: (caesar "IBM" 25)

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

string decoded = c->decrypt(msg_s11);

 

 

{{out}}

 

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

declare cypher_string character (52) static initial

((2)'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

put skip list ('Decyphered text=', text);

 

{{out}} with offset of 5:

<pre>

 

=={{header|PowerShell}}==

function Get-CaesarCipher

{

$OutText = $null

}

Usage examples:

<pre>

{{Works with|SWI-Prolog}}

{{libheader|clpfd}}

 

caesar :-

 

% compute values of V1 and V2

{{out}}

<pre> ?- caesar.

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

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre> Plain text = "The quick brown fox jumped over the lazy dogs."

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

Wend

ProcedureReturn result

 

=={{header|Python}}==

if decode: k = 26 - k

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

enc = caesar(msg, 11)

print enc

{{out}}

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

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

enc = caesar(msg, 11)

print enc

{{out}}

<pre>

Variant with memoization of translation tables

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

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

if decode: k = 26 - k

string.ascii_uppercase[k:] + string.ascii_uppercase[:k] +

string.ascii_lowercase[k:] + string.ascii_lowercase[:k])

 

A compact alternative solution

from string import ascii_uppercase as abc

 

print(caesar(msg, 11))

print(caesar(caesar(msg, 11), 11, True))

{{out}}

<pre>

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

{{trans|BASIC256}}

LET tipo$ = "cleartext "

 

END IF

NEXT i

 

=={{header|Quackery}}==

 

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

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

 

 

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket

(define (encrypt s) (caesar s 1))

(define (decrypt s) (caesar s -1))

Example:

<pre>

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

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

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

.say for $original, $en, $de;

 

{{out}}

<pre>THE FIVE BOXING WIZARDS JUMP QUICKLY

 

=={{header|Red}}==

Red ["Ceasar Cipher"]

 

encrypt: :caesar

decrypt: func spec-of :caesar [caesar src negate key]

<pre>

>> print encrypt "Ceasar Cipher" 4

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

( Example )

"THEYBROKEOURCIPHEREVERYONECANREADTHIS" 3 ceaser ( returns encrypted string )

 

=={{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.*/

return translate(s, substr(@ || @, ky, L), @) /*return the processed text.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 22 The definition of a trivial program is one that has no bugs </tt>}}

<pre>

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*/

return translate(s, substr(@ || @, ky, L), @) /*return the processed text.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 31 Batman's hood is called a "cowl" (old meaning). </tt>}}

<pre>

 

=={{header|Ring}}==

# Project : Caesar cipher

 

next

return str

Output:

<pre>

 

=={{header|Ruby}}==

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

 

encypted = "THEYBROKEOURCIPHEREVERYONECANREADTHIS".caesar_cipher(3)

decrypted = encypted.caesar_cipher(-3)

 

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

 

a$ = "Pack my box with five dozen liquor jugs"

cipher$ = cipher$;code$

next i

{{out}}

<pre>Gimme a ofset:?9

=={{header|Rust}}==

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

use std::fmt::Display;

use std::{env, process};

let _ = writeln!(&mut io::stderr(), "ERROR: {}", msg);

process::exit(code);

 

=={{header|Scala}}==

private val alphaU='A' to 'Z'

private val alphaL='a' to 'z'

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)

println("Plaintext => " + text)

val encoded=Caesar.encode(text, 3)

println("Ciphertext => " + encoded)

{{out}}

<pre>Plaintext => The five boxing wizards jump quickly

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)

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 myCaeser = new Caeser(3)

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

println("Plaintext => " + text)

println("Ciphertext => " + encoded)

 

{{out}}

=={{header|Scheme}}==

 

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

; Also current versions of Chicken, Gauche and Kawa.

(display (string-map caesar msg))

(newline)

 

{{out}}

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

 

/\n\n/! s/\n([^\n])/\1\n/

t loop

{{out}}

<pre>

 

=={{header|Seed7}}==

 

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

writeln("Encrypted: " <& rot(testText, exampleKey));

writeln("Decrypted: " <& rot(rot(testText, exampleKey), 26 - exampleKey));

{{out}}

<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>;

 

"Input: \t" ++ args[1] ++ "\n" ++

"Encrypted:\t" ++ encrypted ++ "\n" ++

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

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

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

say "msg: #{msg}";

say "enc: #{enc}";

 

{{out}}

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

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

20 INPUT T$

30 LET C$=""

100 LET C$=C$+L$

110 NEXT I

{{in}}

<pre>12

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

^ self

 

 

=={{header|SSEM}}==

 

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

00000000000001110000000000000000 16. Stop

11010000000000000000000000000000 17. 11

 

=={{header|Stata}}==

 

u = ascii(s)

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

 

caesar("layout", 20)

 

=={{header|Swift}}==

func usage(_ e:String) {

print("error: \(e)")

test()

main()

 

=={{header|Tcl}}==

 

oo::class create Caesar {

string map $decryptMap $text

}

Demonstrating:

set txt "The five boxing wizards jump quickly."

set enc [$caesar encrypt $txt]

puts "Original message = $txt"

puts "Encrypted message = $enc"

{{out}}

<pre>

 

=={{header|TUSCRIPT}}==

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

PRINT "text orginal ",text

 

DECODED = EXCHANGE (encoded,secret2abc)

{{out}}

<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]+/}

encoded: @{text :filter enc}

decoded: @{text :filter dec}

{{out}}

<pre>$ ./txr caesar.txr 12 'Hello, world!'

 

=={{header|TypeScript}}==

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

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

 

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

 

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

echo "original: $txt"

echo "encrypted: $enc"

{{out}}

<pre>

 

=={{header|Ursa}}==

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

out "encode/decode: " console

end if

end for

 

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

 

#show+ # exhaustive test

 

{{out}}

<pre style="overflow: auto; height: 6em;">

=={{header|Vala}}==

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

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

}

println(encrypt(test_case, -1));

println(decrypt(encrypt(test_case, -1), -1));

 

{{out}}

=={{header|VBA}}==

 

Option Explicit

 

Caesar_Cipher = strTemp

End Function

 

{{out}}

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

 

 

End Function

{{out}}

<pre>

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

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

 

Goto_Pos(Block_Begin)

Char(1)

}

 

{{out}} with key 13:

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

{{trans|C#}}

 

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

End Sub

 

{{out}}

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

 

=={{header|Wortel}}==

; this function only replaces letters and keeps case

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

]

!!ceasar "abc $%^ ABC" 10

Returns:

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

=={{header|Wren}}==

{{trans|Kotlin}}

static encrypt(s, key) {

var offset = key % 26

var encoded = Caesar.encrypt("Bright vixens jump; dozy fowl quack.", 8)

System.print(encoded)

 

{{out}}

{{trans|C custom implementation}}

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

 

.intel_syntax noprefix

mov eax, 0 # 0

leave

Usage:

$ ./caesar 10 abc

klm

$ ./caesar 16 klm

 

=={{header|XBasic}}==

{{trans|Modula-2}}

{{works with|Windows XBasic}}

PROGRAM "caesarcipher"

VERSION "0.0001"

END FUNCTION e$

END PROGRAM

{{out}}

<pre>

 

=={{header|XBS}}==

 

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

 

log(e);

{{out}}

<pre>

 

=={{header|XLISP}}==

(defun encode (ascii-code)

(defun rotate (character alphabet)

 

(defun caesar-decode (text key)

Test it in a REPL:

 

CAESAR-TEST

[3] (caesar-decode caesar-test 14)

 

 

=={{header|XPL0}}==

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

 

int Key, C;

[Key:= IntIn(8);

ChOut(0, C);

until C=$1A; \EOF

 

Example outfile.xxx:

 

=={{header|Yabasic}}==

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

 

 

return res$

{{out}}

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

 

=={{header|zkl}}==

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

if(not encode) n=26 - n;

ltrs:=String(letters[n,sz],letters[0,n],letters[m,sz],letters[26,n]);

str.translate(letters,ltrs)

N:=3;

code:=caesarCodec(text,N);

println("text = ",text);

println("encoded(%d) = %s".fmt(N,code));

{{out}}

<pre>

 

=={{header|zonnon}}==

module Caesar;

const

writeln(txt," -c-> ",cipher," -d-> ",decipher)

end Caesar.

{{Out}}

<pre>

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

{{trans|BBC BASIC}}

20 PRINT t$''

30 LET key=RND*25+1

1050 NEXT i

1060 RETURN

{{trans|Yabasic}}

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

30 LET CIFRA=1: LET DESCIFRA=-1

1170 LET r$=r$+p$(delta)

1180 NEXT i

{{omit from|GUISS}}