Bonfire: Caesar’s Cipher – Best Solution

Best Solution

function rot13(str) {
    var decoded="";
    for (var i in str) {
        if (str.charCodeAt(i) < 65 || str.charCodeAt(i) > 91) { // check if char is outside A-Z range
            decoded += str[i];
            continue;
        }
        // chars A-M will loop back over Z, so you need to add 13(26-13)
        if (str.charCodeAt(i) < 78) {
            decoded += String.fromCharCode(str.charCodeAt(i) + 13);
        }
        // all remaining chars - N-Z
        else {
            decoded += String.fromCharCode(str.charCodeAt(i) - 13);
        }
    }
    return decoded;
}

// Change the inputs below to test
rot13("GUR DHVPX OEBJA QBT WHZCRQ BIRE GUR YNML SBK.");

Code Breakdown

From Mozilla: The charCodeAt() method returns the numeric Unicode value of the character at the given index. The static String.fromCharCode() method returns a string created by using the specified sequence of Unicode values.

First we create an empty variable called decoded. This will allow us later to populate one decoded character at a time until we reach the solution.

Next we create a for loop. In this case, I used the shorthand notation of for(var i in str) which is the equivalent of for(i = 0; i < str.length; i++). This will iterate through the whole encrypted input string.

Our first check is to see whether the character in the string is non-“A to Z,” such as a period or space. A had a charCode of 65 and Z of 90, so we check if our current character is outside the range of 65 – 90. If it is, we add it directly to our decoded string without any manipulation and continue running the loop.

Then we check if a character is A – M. The reason we have to do this is because we can’t just shift left 13 (subtract 13) for characters with values 65 – 77. For example let’s take the letter E. It has a charCode value of 69. If we subtract 13, that will be 56, which is the number 8. Obviously that doesn’t work. The solution is to loop back around from the end of the alphabet.

We could do this by trying to find the remainder once we shift left as much as possible. The math goes like this 90 – (13 – (69 – 65)). However, it’s easier just to loop the other way in the alphabet, by shifting right. So instead we would do 69 + 26 (letters of the alphabet) – 13 (left shift) or 69 + 13 (26-13).

Finally, we can shift left all the characters greater than charCode 77 by 13.

Each new character gets added to the decoded string with decoded+=. In the end, we return our decoded string.

Alternative Solution (as suggested by Aman in the comments)

This solution uses the array.push() method instead of concatenating strings. It’s approximately 30% slower when running benchmarks.

function rot13(str) {
  var answer = [];
  for (var i in str) {
    if (str.charCodeAt(i) < 65 || str.charCodeAt(i) > 91) {
      answer.push(str[i]);
      continue;
    } else {
      if (str.charCodeAt(i) < 78) {
        answer.push(String.fromCharCode(str.charCodeAt(i) + 13));
        continue;
      } else {
        answer.push(String.fromCharCode(str.charCodeAt(i) - 13));
        continue;
      }
    }
  }
  return answer.join("");
}

Alternative Solution (as suggested by Jonnie in the comments)

This solution uses character mapping and it’s completely different from all the other solutions. To see an explanation of how this solution check out Jonnie’s comment below.

rot13 = m => m.split('')
    .map(b => {
    x = b.charCodeAt();
    return x > 96 && x < 123 ? String.fromCharcode((x - 84) % 26 + 97) : x > 64 && x < 91 ? String.fromCharCode((x - 52) % 26 + 65) : b
    })
    .join('');

Discussion

I would love to hear others’ solutions and discover better and cooler ways to solve these challenges. Please comment with your questions, suggestions, or anything you would like.

If you found my solution useful or learned something new from this blog post, please feel free add kudos inside the main chat of Free Code Camp: Thanks @allurewebsolutions