Added Morse Code

ciphers/morse_code.cpp

@@ -0,0 +1,267 @@
+/**
+ * @file
+ * @author [Deep Raval](https://github.com/imdeep2905)
+ * 
+ * @brief Implementation of [Morse Code] (https://en.wikipedia.org/wiki/Morse_code).
+ *
+ * @details
+ * Morse code is a method used in telecommunication to encode text characters 
+ * as standardized sequences of two different signal durations, called dots 
+ * and dashes or dits and dahs. Morse code is named after Samuel Morse, an 
+ * inventor of the telegraph.
+ */
+#include <iostream>
+#include <string>
+#include <cassert>
+#include <vector>
+
+/** \namespace ciphers
+ * \brief Algorithms for encryption and decryption
+ */
+namespace ciphers {
+/** \namespace morse
+ * \brief Functions for [Morse Code] 
+ * (https://en.wikipedia.org/wiki/Morse_code).
+ */
+namespace morse {
+/**
+ * Get the morse representation for given character.
+ * @param c Character 
+ * @return morse representation string of character 
+ */
+std::string char_to_morse(const char &c) {
+    // return corresponding morse code
+      switch (c) { 
+        case 'a': 
+            return ".-"; 
+        case 'b': 
+            return "-..."; 
+        case 'c': 
+            return "-.-."; 
+        case 'd': 
+            return "-.."; 
+        case 'e': 
+            return "."; 
+        case 'f': 
+            return "..-."; 
+        case 'g': 
+            return "--."; 
+        case 'h': 
+            return "...."; 
+        case 'i': 
+            return ".."; 
+        case 'j': 
+            return ".---"; 
+        case 'k': 
+            return "-.-"; 
+        case 'l': 
+            return ".-.."; 
+        case 'm': 
+            return "--"; 
+        case 'n': 
+            return "-."; 
+        case 'o': 
+            return "---"; 
+        case 'p': 
+            return ".--."; 
+        case 'q': 
+            return "--.-"; 
+        case 'r': 
+            return ".-."; 
+        case 's': 
+            return "..."; 
+        case 't': 
+            return "-"; 
+        case 'u': 
+            return "..-"; 
+        case 'v': 
+            return "...-"; 
+        case 'w': 
+            return ".--"; 
+        case 'x': 
+            return "-..-"; 
+        case 'y': 
+            return "-.--"; 
+        case 'z': 
+            return "--.."; 
+        case '1':
+            return ".----";
+        case '2':
+            return "..---";
+        case '3':
+            return "...--";
+        case '4':
+            return "....-";
+        case '5':
+            return ".....";
+        case '6':
+            return "-....";
+        case '7':
+            return "--...";
+        case '8':
+            return "---..";
+        case '9':
+            return "----.";
+        case '0':
+            return "-----";
+        default:
+            std::cerr << "Found invalid character: " << c << ' ' << std::endl;
+            std::exit(0);
+    } 
+}
+/**
+ * Get character from the morse representation.
+ * @param s Morse representation
+ * @return corresponding character
+ */
+char morse_to_char(const std::string &s) {
+    // return corresponding character
+    if (s == ".-") {
+        return 'a';
+    } else if (s == "-...") {
+        return 'b';
+    } else if (s == "-.-.") {
+        return 'c';
+    } else if (s == "-..") {
+        return 'd';
+    } else if (s == ".") {
+        return 'e';
+    } else if (s == "..-.") {
+        return 'f';
+    } else if (s == "--.") {
+        return 'g';
+    } else if (s == "....") {
+        return 'h';
+    } else if (s == "..") {
+        return 'i';
+    } else if (s == ".---") {
+        return 'j';
+    } else if (s == "-.-") {
+        return 'k';
+    } else if (s == ".-..") {
+        return 'l';
+    } else if (s == "--") {
+        return 'm';
+    } else if (s == "-.") {
+        return 'n';
+    } else if (s == "---") {
+        return 'o';
+    } else if (s == ".--.") {
+        return 'p';
+    } else if (s == "--.-") {
+        return 'q';
+    } else if (s == ".-.") {
+        return 'r';
+    } else if (s == "...") {
+        return 's';
+    } else if (s == "-") {
+        return 't';
+    } else if (s == "..-") {
+        return 'u';
+    } else if (s == "...-") {
+        return 'v';
+    } else if (s == ".--") {
+        return 'w';
+    } else if (s == "-..-") {
+        return 'x';
+    } else if (s == "-.--") {
+        return 'y';
+    } else if (s == "--..") {
+        return 'z';
+    } else if (s == ".----") {
+        return '1';
+    } else if (s == "..---") {
+        return '2';
+    } else if (s == "...--") {
+        return '3';
+    } else if (s == "....-") {
+        return '4';
+    } else if (s == ".....") {
+        return '5';
+    } else if (s == "-....") {
+        return '6';
+    } else if (s == "--...") {
+        return '7';
+    } else if (s == "---..") {
+        return '8';
+    } else if (s == "----.") {
+        return '9';
+    } else if (s == "-----") {
+        return '0';
+    } else {
+        std::cerr << "Found invalid Morse code: " << s << ' ' << std::endl;
+        std::exit(0);        
+    }
+}
+/**
+ * Encrypt given text using morse code.
+ * @param text text to be encrypted
+ * @return new encrypted text
+ */
+std::string encrypt(const std::string &text) {
+    std::string encrypted_text = "";  // Empty string to store encrypted text
+    // Going through each character of text and converting it 
+    // to morse representation
+    for (const char &c : text) {
+        encrypted_text += ciphers::morse::char_to_morse(c) + " ";
+    }
+    return encrypted_text;  // Returning encrypted text
+}
+/**
+ * Decrypt given morse coded text. 
+ * @param text text to be decrypted
+ * @return new decrypted text
+ */
+std::string decrypt(const std::string &text) {
+    // Going through each character of text and converting it 
+    // back to normal representation.
+    std::string decrypted_text = "";  // Empty string to store decrypted text
+    // Spliting string (with delimiter = " ") and storing it 
+    // in vector
+    std::size_t pos_start = 0, pos_end, delim_len = 1;
+    std::vector <std::string> splits;
+    while ((pos_end = text.find(' ', pos_start)) != std::string::npos) {
+        std::string token = text.substr (pos_start, pos_end - pos_start);
+        pos_start = pos_end + delim_len;
+        splits.push_back(token);
+    }
+    
+    // Traversing through each morse code string 
+    for (const std::string &s : splits) {
+        // Add corresponding character
+        decrypted_text += ciphers::morse::morse_to_char(s);
+    }
+
+    return decrypted_text;  // Returning decrypted text
+}
+}  // namespace morse
+}  // namespace ciphers
+
+/**
+ * Function to test above algorithm
+ */
+void test() {
+    // Test 1
+    std::string text1 = "01234567890";
+    std::string encrypted1 = ciphers::morse::encrypt(text1);
+    std::string decrypted1 = ciphers::morse::decrypt(encrypted1);
+    assert(text1 == decrypted1);
+    std::cout << "Original text : " << text1 << std::endl;
+    std::cout << "Encrypted text : " << encrypted1 << std::endl;
+    std::cout << "Decrypted text : " << decrypted1 << std::endl;
+    // Test 2
+    std::string text2 = "abcdefghijklmnopqrstuvwxyz";
+    std::string encrypted2 = ciphers::morse::encrypt(text2);
+    std::string decrypted2 = ciphers::morse::decrypt(encrypted2);
+    assert(text2 == decrypted2);
+    std::cout << "Original text : " << text2 << std::endl;
+    std::cout << "Encrypted text : " << encrypted2 << std::endl;
+    std::cout << "Decrypted text : " << decrypted2 << std::endl;
+}
+
+/** Driver Code */
+int main() {
+    // Testing
+    test();
+    return 0;
+}