Caesars Cipher solutions

Here is my solution

``````function rot13(str) {
// Define return variable
let ans = "";

// Get length of string
let length = str.length;

// Loop through each of the characters in the string
for (let i = 0; i < length; i++) {
// If character is a letter, apply cipher
if (/[A-Z]/.test(str[i])) {
ans += cipher(str[i]);
}
// If character is not a letter, retain
else {
ans += str[i];
}
}

// Return encoded string
return ans;
}

// Define function that applies the cipher to a character
const cipher = (char) => {
// Convert character to ASCII and add 13
let ascii = char.charCodeAt() + 13;
// If ASCII exceeds 'Z', go back to 'A'
if (ascii > 90) {
ascii = 65 + (ascii - 90) - 1;
}
// Convert ASCII back to character and return it
return String.fromCharCode(ascii);
}
``````

you are welcome
yeah I like the idea of using %
still wonder why it doesn’t work while we were live streaming

Hey guys. Find my simple solution here:

``````function rot13(str) {

let alphabets = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M'];
let result = '';
for (let i = 0; i < str.length; i++){
if (str[i] === '?'| str[i] ==='.'| str[i] ==='!'| str[i] === ' '){
result = result.concat('', str[i]);
}
for(let j = 0; j < 26; j++){
if(str[i] === alphabets[j]){
result = result.concat((alphabets[(13 + alphabets.indexOf(alphabets[j]))]));

}
}
}
return result;

}

console.log(rot13("SERR PBQR PNZC"));
console.log(rot13("SERR YBIR?"));
console.log(rot13("SERR CVMMN!"));
``````

interesting solution Omar, I’m in awe!

This solution is the closest to everyday English I have seen for this particular algorithm. I’ll copy it, thanks.

Hello guys,

Here’s my not so elegant solution

(almost no brain cells were harmed in the making of this solution)

Solution #1

``````const CIPHER = {
A:'N', B:'O', C:'P', D:'Q', E:'R', F:'S', G:'T', H:'U', I: 'V',
J:'W', K:'X', L:'Y', M:'Z', N:'A', O:'B', P:'C', Q:'D', R:'E',
S:'F', T:'G', U:'H', V:'I', W:'J', X:'K', Y:'L', Z:'M'
};

function rot13(str) {
let decoded = "";

for(let i = 0; i < str.length; i++){
if(CIPHER.hasOwnProperty(str[i]) === true){
decoded += (CIPHER[str[i]]);
}
else if(CIPHER.hasOwnProperty(str[i]) === false){
decoded += (str[i]);
}
}
return decoded;
}
console.log(rot13("SERR. PBQR. PNZC?!"));
``````

(Edit: Brushed up my original solution a bit after watching the video )

After watching, I realized that my solution is not dynamic/flexible as it only works exclusively for ROT13. So I tried doing the project again. This time I can set the amount of shifting or rotation from 1 to 13.

(RIP brain cells)

Solution #2

``````const ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // alphabet - 26 letters

function rot13(str){
let decoded = ""; // storage for decoded string
let newLetter = ""; // storage for the new/decoded letter based from its new index
let newIndex; // storage for the new index based on the number of shifts
let shift = 13; // the number of shift (applicable only from 1-13)
let maxShift = shift*2; // maximum index value a new/decoded letter can have

for(let i = 0; i < str.length; i++){ // for loop to access every letter in the given string
if(ALPHA.includes(str[i]) === true){ // if a letter in the given string is present at ALPHA (line 2)
newIndex = ALPHA.indexOf(str[i]) + shift; // then the letter should move *shift* places
if(newIndex < maxShift){ // if the new index of the new letter (line 13) is < maxShift (line 9)
newLetter = ALPHA[newIndex]; // then store the new letter in the variable newLetter
decoded += newLetter; // and then store newLetter to decoded variable
}
else if(newIndex >= maxShift){ // but if new index of the new letter (line 13) is >= maxShift (line 9)
newIndex -= maxShift; // then subtract the new index of the new letter by maxShift (line 9)
newLetter = ALPHA[newIndex]; // and then store the new/decoded letter based on its new index in the variable newLetter
decoded += newLetter; // and then store newLetter to decoded variable
}
}
else if(ALPHA.includes(str[i]) === false){ // if a letter in the given string is not present at ALPHA (line 2)
decoded += str[i]; // then just store it to decoded variable
}
}
return decoded; // after looping, return the value of decoded variable out of the function
};
console.log(rot13("SERR. PBQR. PNZC?!"));

``````

Since I have the luxury of time and wanted to be extra, I tried to enable the number of rotations from 14 to 26 too like the one on this website

I realized after doing this I could have used charCodeAt() But whatever. I like beating myself up with math problems anyway

(yep, I just love math)

Solution #3

``````const ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

function rot13(str){
let upperStr = str.toUpperCase();
let decoded = "";
let newLetter = "";
let newIndex;
let rot = 13;
let maxIndex = 25 - rot;

for(let i = 0; i < upperStr.length; i++){
if(ALPHA.includes(upperStr[i]) === true){
if(ALPHA.indexOf(upperStr[i]) <= maxIndex){
newIndex = ALPHA.indexOf(upperStr[i]) + rot;
newLetter = ALPHA[newIndex];
decoded += newLetter;
}
else if(ALPHA.indexOf(upperStr[i]) > maxIndex){
newIndex = ALPHA.indexOf(upperStr[i]) - maxIndex - 1;
newLetter = ALPHA[newIndex];
decoded += newLetter;
}
}
else if(ALPHA.includes(upperStr[i]) === false){
decoded += upperStr[i];
}
}
return decoded;
};
console.log(rot13("abcdefghijklmnopqrstuvwxyz !?"))
``````
1 Like