Introduction:

ROT13 is a simple form of encryption that is used to obfuscate text messages. It is a Caesar cipher where each letter of the message is shifted by 13 characters. To decode a ROT13 encoded string, we simply apply the ROT13 cipher twice to the original text. The ROT13 encryption is commonly used to hide spoilers, easter eggs, and other types of hidden messages in software applications, websites, and other digital content. In this blog, we will explore how to convert ROT13 decoded strings to normal strings in C#.

Method 1: Using the String class

The simplest way to convert a ROT13 decoded string to a normal string in C# is to use the built-in String class. The String class provides a ToCharArray() method that returns a character array representation of the string. We can use this method to iterate over each character in the string and apply the ROT13 cipher to it.

Here's the C# code to convert a ROT13 decoded string to a normal string using the String class:

string rot13String = "uryyb jbeyq";
char[] charArray = rot13String.ToCharArray();
for (int i = 0; i < charArray.Length; i++)
{
    if (char.IsLetter(charArray[i]))
    {
        charArray[i] = (char)(charArray[i] + 13);
        if (!char.IsLetter(charArray[i]))
        {
            charArray[i] = (char)(charArray[i] - 26);
        }
    }
}
string normalString = new string(charArray);
Console.WriteLine(normalString);

Output:

hello world

• The string "uryyb jbeyq" is the ROT13 encoded version of "hello world".
• We call the ToCharArray() method on the string to get a character array representation of the string.
• We iterate over each character in the array and check if it is a letter using the char.IsLetter() method.
• If the character is a letter, we apply the ROT13 cipher by adding 13 to the ASCII value of the character.
• If the resulting character is not a letter (i.e., it is outside the range of A-Z or a-z), we subtract 26 from the ASCII value to wrap around to the other end of the alphabet.
• Finally, we create a new string from the character array using the string constructor that takes a character array as an argument.

Method 2: Using the StringBuilder class

Another way to convert a ROT13 decoded string to a normal string in C# is to use the StringBuilder class. The StringBuilder class is a mutable sequence of characters that can be modified in-place. We can use the StringBuilder class to build the new string character by character, applying the ROT13 cipher to each character as we go.

Here's the C# code to convert a ROT13 decoded string to a normal string using the StringBuilder class:

string rot13String = "uryyb jbeyq";
StringBuilder stringBuilder = new StringBuilder();
foreach (char c in rot13String)
{
    if (char.IsLetter(c))
    {
        char newChar = (char)(c + 13);
        if (!char.IsLetter(newChar))
        {
            newChar = (char)(newChar - 26);
        }
        stringBuilder.Append(newChar);
    }
    else
    {
        stringBuilder.Append(c);
    }
}
string normalString = stringBuilder.ToString();
Console.WriteLine(normalString);

Output:

hello world

• We create a new StringBuilder object to build the new string character by character.
• We iterate over each character in the original string using a foreach loop.
• If the character is a letter, we apply the ROT13 cipher by adding 13 to the ASCII value of the character.
• If the resulting character is not a letter (i.e., it is outside the range of A-Z or a-z), we subtract 26 from the ASCII value to wrap around to the other end of the alphabet.
• We append the new character to the StringBuilder object.
• If the character is not a letter, we simply append it to the StringBuilder object without modifying it.
• Finally, we call the ToString() method on the StringBuilder object to create a new string from the character sequence.

Method 3: Using LINQ

In C#, we can also use LINQ to convert a ROT13 decoded string to a normal string. LINQ provides a powerful set of query operators that allow us to manipulate collections of objects in a declarative way. We can use LINQ to create a new string by applying the ROT13 cipher to each character in the original string.

Here's the C# code to convert a ROT13 decoded string to a normal string using LINQ:

string rot13String = "uryyb jbeyq";
string normalString = new string(rot13String.Select(c =>
{
    if (!char.IsLetter(c))
    {
        return c;
    }
    char newChar = (char)(c + 13);
    if (!char.IsLetter(newChar))
    {
        newChar = (char)(newChar - 26);
    }
    return newChar;
}).ToArray());
Console.WriteLine(normalString);

Output:

hello world

• We use the Select() method from the System.Linq namespace to apply a transformation to each character in the original string.
• If the character is not a letter, we simply return it unchanged.
• If the character is a letter, we apply the ROT13 cipher by adding 13 to the ASCII value of the character and wrapping around to the other end of the alphabet if necessary.
• We use the ToArray() method to convert the resulting sequence of characters to an array.
• We pass the resulting array to the string constructor to create a new string.

Conclusion:

In this blog, we explored three different methods to convert ROT13 decoded strings to normal strings in C#. We used the String class, the StringBuilder class, and LINQ to implement the ROT13 cipher and create a new string. Each method has its own advantages and disadvantages, and the best method to use depends on the specific requirements of your application. The String class is the simplest and most straightforward approach, but it creates a new character array and string object for each operation, which can be inefficient for large strings.