Merge branch 'master' into midpoint_branch

DIRECTORY.md

@@ -19,6 +19,7 @@
   * [Hamming Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/bit_manipulation/hamming_distance.cpp)
 
 ## Ciphers
+  * [A1Z26 Cipher](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/a1z26_cipher.cpp)
   * [Atbash Cipher](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/atbash_cipher.cpp)
   * [Base64 Encoding](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/base64_encoding.cpp)
   * [Caesar Cipher](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/caesar_cipher.cpp)

ciphers/a1z26_cipher.cpp

@@ -0,0 +1,162 @@
+/**
+ * @file
+ * @brief Implementation of the [A1Z26
+ * cipher](https://www.dcode.fr/letter-number-cipher)
+ * @details The A1Z26 cipher is a simple substiution cipher where each letter is
+ * replaced by the number of the order they're in. For example, A corresponds to
+ * 1, B = 2, C = 3, etc.
+ *
+ * @author [Focusucof](https://github.com/Focusucof)
+ */
+
+#include <algorithm>  /// for std::transform and std::replace
+#include <cassert>    /// for assert
+#include <cstdint>    /// for uint8_t
+#include <iostream>   /// for IO operations
+#include <map>        /// for std::map
+#include <sstream>    /// for std::stringstream
+#include <string>     /// for std::string
+#include <vector>     /// for std::vector
+
+/**
+ * @namespace ciphers
+ * @brief Algorithms for encryption and decryption
+ */
+namespace ciphers {
+/**
+ * @namespace a1z26
+ * @brief Functions for [A1Z26](https://www.dcode.fr/letter-number-cipher)
+ * encryption and decryption implementation
+ */
+namespace a1z26 {
+
+std::map<uint8_t, char> a1z26_decrypt_map = {
+    {1, 'a'},  {2, 'b'},  {3, 'c'},  {4, 'd'},  {5, 'e'},  {6, 'f'},  {7, 'g'},
+    {8, 'h'},  {9, 'i'},  {10, 'j'}, {11, 'k'}, {12, 'l'}, {13, 'm'}, {14, 'n'},
+    {15, 'o'}, {16, 'p'}, {17, 'q'}, {18, 'r'}, {19, 's'}, {20, 't'}, {21, 'u'},
+    {22, 'v'}, {23, 'w'}, {24, 'x'}, {25, 'y'}, {26, 'z'},
+};
+
+std::map<char, uint8_t> a1z26_encrypt_map = {
+    {'a', 1},  {'b', 2},  {'c', 3},  {'d', 4},  {'e', 5},  {'f', 6},  {'g', 7},
+    {'h', 8},  {'i', 9},  {'j', 10}, {'k', 11}, {'l', 12}, {'m', 13}, {'n', 14},
+    {'o', 15}, {'p', 16}, {'q', 17}, {'r', 18}, {'s', 19}, {'t', 20}, {'u', 21},
+    {'v', 22}, {'w', 23}, {'x', 24}, {'y', 25}, {'z', 26}};
+
+/**
+ * @brief a1z26 encryption implementation
+ * @param text is the plaintext input
+ * @returns encoded string with dashes to seperate letters
+ */
+std::string encrypt(std::string text) {
+    std::string result;
+    std::transform(text.begin(), text.end(), text.begin(),
+                   ::tolower);  // convert string to lowercase
+    std::replace(text.begin(), text.end(), ':', ' ');
+    for (char letter : text) {
+        if (letter != ' ') {
+            result += std::to_string(
+                a1z26_encrypt_map[letter]);  // convert int to string and append
+                                             // to result
+            result += "-";  // space out each set of numbers with spaces
+        } else {
+            result.pop_back();
+            result += ' ';
+        }
+    }
+    result.pop_back();  // remove leading dash
+    return result;
+}
+
+/**
+ * @brief a1z26 decryption implementation
+ * @param text is the encrypted text input
+ * @param bReturnUppercase is if the decoded string should be in uppercase or
+ * not
+ * @returns the decrypted string in all uppercase or all lowercase
+ */
+std::string decrypt(const std::string& text, bool bReturnUppercase = false) {
+    std::string result;
+
+    // split words seperated by spaces into a vector array
+    std::vector<std::string> word_array;
+    std::stringstream sstream(text);
+    std::string word;
+    while (sstream >> word) {
+        word_array.push_back(word);
+    }
+
+    for (auto& i : word_array) {
+        std::replace(i.begin(), i.end(), '-', ' ');
+        std::vector<std::string> text_array;
+
+        std::stringstream ss(i);
+        std::string res_text;
+        while (ss >> res_text) {
+            text_array.push_back(res_text);
+        }
+
+        for (auto& i : text_array) {
+            result += a1z26_decrypt_map[stoi(i)];
+        }
+
+        result += ' ';
+    }
+    result.pop_back();  // remove any leading whitespace
+
+    if (bReturnUppercase) {
+        std::transform(result.begin(), result.end(), result.begin(), ::toupper);
+    }
+    return result;
+}
+
+}  // namespace a1z26
+}  // namespace ciphers
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    // 1st test
+    std::string input = "Hello World";
+    std::string expected = "8-5-12-12-15 23-15-18-12-4";
+    std::string output = ciphers::a1z26::encrypt(input);
+
+    std::cout << "Input: " << input << std::endl;
+    std::cout << "Expected: " << expected << std::endl;
+    std::cout << "Output: " << output << std::endl;
+    assert(output == expected);
+    std::cout << "TEST PASSED";
+
+    // 2nd test
+    input = "12-15-23-5-18-3-1-19-5";
+    expected = "lowercase";
+    output = ciphers::a1z26::decrypt(input);
+
+    std::cout << "Input: " << input << std::endl;
+    std::cout << "Expected: " << expected << std::endl;
+    std::cout << "Output: " << output << std::endl;
+    assert(output == expected);
+    std::cout << "TEST PASSED";
+
+    // 3rd test
+    input = "21-16-16-5-18-3-1-19-5";
+    expected = "UPPERCASE";
+    output = ciphers::a1z26::decrypt(input, true);
+
+    std::cout << "Input: " << input << std::endl;
+    std::cout << "Expected: " << expected << std::endl;
+    std::cout << "Output: " << output << std::endl;
+    assert(output == expected);
+    std::cout << "TEST PASSED";
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

math/check_prime.cpp

@@ -7,12 +7,13 @@
  * @brief
  * Reduced all possibilities of a number which cannot be prime.
  * Eg: No even number, except 2 can be a prime number, hence we will increment
- * our loop with i+2 jumping on all odd numbers only. If number is <= 1 or if it
+ * our loop with i+6 jumping and check for i or i+2 to be a factor of the number;
- * is even except 2, break the loop and return false telling number is not
+ * if it's a factor then we will return false otherwise true after the loop terminates at the terminating condition which is (i*i<=num)
- * prime.
  */
-#include <cassert>
+
-#include <iostream>
+#include <cassert>    /// for assert
+#include <iostream>   /// for IO operations
+
 /**
  * Function to check if the given number is prime or not.
  * @param num number to be checked.
@@ -23,14 +24,14 @@ bool is_prime(T num) {
     bool result = true;
     if (num <= 1) {
         return false;
-    } else if (num == 2) {
+    } else if (num == 2 || num==3) {
         return true;
-    } else if ((num & 1) == 0) {
+    } else if ((num%2) == 0 || num%3 == 0) {
         return false;
     }
-    if (num >= 3) {
+    else {
-        for (T i = 3; (i * i) <= (num); i = (i + 2)) {
+        for (T i = 5; (i * i) <= (num); i = (i + 6)) {
-            if ((num % i) == 0) {
+            if ((num % i) == 0 || (num%(i+2)==0 )) {
                 result = false;
                 break;
             }