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)