* `B` [Caesar Cipher](src/algorithms/cryptography/caesar-cipher) - simple substitution cipher

In cryptography, a **Caesar cipher**, also known as **Caesar's cipher**, the **shift cipher**, **Caesar's code** or **Caesar shift**, is one of the simplest and most widely known encryption techniques. It is a type of substitution cipher in which each letter in the plaintext is replaced by a letter some fixed number of positions down the alphabet. For example, with a left shift of `3`, `D` would be replaced by `A`, `E` would become `B`, and so on. The method is named after Julius Caesar, who used it in his private correspondence.


The transformation can be represented by aligning two alphabets; the cipher alphabet is the plain alphabet rotated left or right by some number of positions. For instance, here is a Caesar cipher using a left rotation of three places, equivalent to a right shift of 23 (the shift parameter is used as the key):

When encrypting, a person looks up each letter of the message in the "plain" line and writes down the corresponding letter in the "cipher" line.

- Time: `O(|n|)`

- Space: `O(|n|)`

- [Caesar cipher on Wikipedia](https://en.wikipedia.org/wiki/Caesar_cipher)

import { caesarCipherEncrypt, caesarCipherDecrypt } from '../caesarCipher';

describe('caesarCipher', () => {

it('should not change a string with zero shift', () => {

expect(caesarCipherEncrypt('abcd', 0)).toBe('abcd');

expect(caesarCipherDecrypt('abcd', 0)).toBe('abcd');

});

it('should cipher a string with different shifts', () => {

expect(caesarCipherEncrypt('abcde', 3)).toBe('defgh');

expect(caesarCipherDecrypt('defgh', 3)).toBe('abcde');

expect(caesarCipherEncrypt('abcde', 1)).toBe('bcdef');

expect(caesarCipherDecrypt('bcdef', 1)).toBe('abcde');

expect(caesarCipherEncrypt('xyz', 1)).toBe('yza');

expect(caesarCipherDecrypt('yza', 1)).toBe('xyz');

});

it('should be case insensitive', () => {

expect(caesarCipherEncrypt('ABCDE', 3)).toBe('defgh');

});

it('should correctly handle an empty strings', () => {

expect(caesarCipherEncrypt('', 3)).toBe('');

});

it('should not cipher unknown chars', () => {

expect(caesarCipherEncrypt('ab2cde', 3)).toBe('de2fgh');

expect(caesarCipherDecrypt('de2fgh', 3)).toBe('ab2cde');

});

it('should encrypt and decrypt full phrases', () => {

expect(caesarCipherEncrypt('THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG', 23))

.toBe('qeb nrfzh yoltk clu grjmp lsbo qeb ixwv ald');

expect(caesarCipherDecrypt('qeb nrfzh yoltk clu grjmp lsbo qeb ixwv ald', 23))

.toBe('the quick brown fox jumps over the lazy dog');

});

const englishAlphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');

const getCipherMap = (alphabet, shift) => {

return alphabet

.reduce((charsMap, currentChar, charIndex) => {

const charsMapClone = { ...charsMap };

// Making the shift to be cyclic (i.e. with a shift of 1 - 'z' would be mapped to 'a').

let encryptedCharIndex = (charIndex + shift) % alphabet.length;

// Support negative shifts for creating a map for decryption

// (i.e. with shift -1 - 'a' would be mapped to 'z').

if (encryptedCharIndex < 0) {

encryptedCharIndex += alphabet.length;

}

charsMapClone[currentChar] = alphabet[encryptedCharIndex];

return charsMapClone;

}, {});

export const caesarCipherEncrypt = (str, shift, alphabet = englishAlphabet) => {

// Create a cipher map:

const cipherMap = getCipherMap(alphabet, shift);

return str

.toLowerCase()

.split('')

.map((char) => cipherMap[char] || char)

.join('');

export const caesarCipherDecrypt = (str, shift, alphabet = englishAlphabet) => {

// Create a cipher map:

const cipherMap = getCipherMap(alphabet, -shift);

return str

.toLowerCase()

.split('')

.map((char) => cipherMap[char] || char)

.join('');