Add Autokey encoder

Algorithms.Tests/Encoders/AutokeyEncoderTests.cs

@@ -0,0 +1,26 @@
+using System;
+using Algorithms.Encoders;
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+
+namespace Algorithms.Tests.Encoders
+{
+    public class AutokeyEncoderTests
+    {
+        [Test]
+        public static void DecodedStringIsTheSame()
+        {
+            // Arrange
+            var plainText = "PLAINTEXT";
+            var keyword = "KEYWORD";
+            var encoder = new AutokeyEncorder();
+
+            // Act
+            var encoded = encoder.Encode(plainText, keyword);
+            var decoded = encoder.Decode(encoded, keyword);
+
+            // Assert
+            Assert.That(decoded, Is.EqualTo(plainText));
+        }
+    }
+}

Algorithms/Encoders/AutokeyEncorder.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Algorithms.Encoders
+{
+    /// <summary>
+    ///     Class for AutoKey encoding strings.
+    /// </summary>
+    public class AutokeyEncorder
+    {
+        /// <summary>
+        ///     Autokey Cipher is a type of polyalphabetic cipher.
+        ///     This works by choosing a key (a word or short phrase),
+        ///     then you append the plaintext to itself to form a longer key.
+        /// </summary>
+        /// <param name="plainText">The string to be appended to the key.</param>
+        /// <param name="keyword">The string to be appended to the plaintext.</param>
+        /// <returns>The Autokey encoded string (All Uppercase).</returns>
+        public string Encode(string plainText, string keyword)
+        {
+            plainText = Regex.Replace(plainText.ToUpper(), "[^A-Z]", string.Empty);
+            keyword = keyword.ToUpper();
+
+            keyword += plainText;
+
+            StringBuilder cipherText = new StringBuilder();
+
+            for(int i = 0; i < plainText.Length; i++)
+            {
+                char plainCharacter = plainText[i];
+                char keyCharacter = keyword[i];
+
+                int encryptedCharacter = (plainCharacter - 'A' + keyCharacter - 'A') % 26 + 'A';
+                cipherText.Append((char)encryptedCharacter);
+            }
+
+            return cipherText.ToString();
+        }
+
+        /// <summary>
+        ///     Removed the key from the encoded string.
+        /// </summary>
+        /// <param name="cipherText">The encoded string.</param>
+        /// <param name="keyword">The key to be removed from the encoded string.</param>
+        /// <returns>The plaintext (All Uppercase).</returns>
+        public string Decode(string cipherText, string keyword)
+        {
+            cipherText = Regex.Replace(cipherText.ToUpper(), "[^A-Z]", string.Empty);
+            keyword = keyword.ToUpper();
+
+            StringBuilder plainText = new StringBuilder();
+            StringBuilder extendedKeyword = new StringBuilder(keyword);
+
+            for(int i = 0; i < cipherText.Length; i++)
+            {
+                char cipherCharacter = cipherText[i];
+                char keywordCharacter = extendedKeyword[i];
+
+                int decryptedCharacter = (cipherCharacter - 'A' - (keywordCharacter - 'A') + 26) % 26 + 'A';
+                plainText.Append((char)decryptedCharacter);
+                extendedKeyword.Append((char)decryptedCharacter);
+            }
+
+            return plainText.ToString();
+        }
+    }
+}

README.md

@@ -41,6 +41,7 @@ find more than one implementation for the same objective but using different alg
     * [Soundex](./Algorithms/Encoders/SoundexEncoder.cs)
     * [Feistel](./Algorithms/Encoders/FeistelCipher.cs)
     * [Blowfish](./Algorithms/Encoders/BlowfishEncoder.cs)
+    * [Autokey](./Algorithms/Encoders/AutokeyEncoder.cs)
   * [Graph](./Algorithms/Graph)
     * [Minimum Spanning Tree](./Algorithms/Graph/MinimumSpanningTree)
       * [Prim's Algorithm (Adjacency Matrix)](./Algorithms/Graph/MinimumSpanningTree/PrimMatrix.cs)