From 00b4406bc56274836582de057b47f11f139cab07 Mon Sep 17 00:00:00 2001 From: Alvin Philips Date: Fri, 22 Oct 2021 00:51:39 +0530 Subject: [PATCH 1/3] fix: Union of two arrays (#1770) * Create reverse_binary_tree.cpp * Added documentation Added Documentation for the level_order_traversal() function, and implemented a print() function to display the tree to STDOUT * Added documentation * Renamed tests to test * Fixed issue with incorrect using statement * updating DIRECTORY.md * clang-format and clang-tidy fixes for fb86292d * Added Test cases * Update operations_on_datastructures/reverse_binary_tree.cpp Co-authored-by: David Leal * Update operations_on_datastructures/reverse_binary_tree.cpp Co-authored-by: David Leal * Update operations_on_datastructures/reverse_binary_tree.cpp Co-authored-by: David Leal * Update operations_on_datastructures/reverse_binary_tree.cpp Co-authored-by: David Leal * Update operations_on_datastructures/reverse_binary_tree.cpp Co-authored-by: David Leal * Changed int to int64_t * Updated documentation wording * Added namespace and print function Added the operations_on_datastructures namespace and created a function to print a vector. * Added implementation of union for two arrays * Fixed bug with initialization of indexes and added test case * Added test cases * Modified references to const & * Renamed file to meet filename guidelines better * updating DIRECTORY.md * Update operations_on_datastructures/union_of_two_arrays.cpp Co-authored-by: David Leal * Update operations_on_datastructures/union_of_two_arrays.cpp Co-authored-by: David Leal * Update operations_on_datastructures/union_of_two_arrays.cpp Co-authored-by: David Leal * Made changes to documentation Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: David Leal --- DIRECTORY.md | 2 +- .../union_of_2_arrays.cpp | 27 --- .../union_of_two_arrays.cpp | 219 ++++++++++++++++++ 3 files changed, 220 insertions(+), 28 deletions(-) delete mode 100644 operations_on_datastructures/union_of_2_arrays.cpp create mode 100644 operations_on_datastructures/union_of_two_arrays.cpp diff --git a/DIRECTORY.md b/DIRECTORY.md index 9a2481213..048b95a41 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -245,7 +245,7 @@ * [Reverse Binary Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/reverse_binary_tree.cpp) * [Selectionsortlinkedlist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/selectionsortlinkedlist.cpp) * [Trie Multiple Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/trie_multiple_search.cpp) - * [Union Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/union_of_2_arrays.cpp) + * [Union Of Two Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/union_of_two_arrays.cpp) ## Others * [Buzz Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/buzz_number.cpp) diff --git a/operations_on_datastructures/union_of_2_arrays.cpp b/operations_on_datastructures/union_of_2_arrays.cpp deleted file mode 100644 index cdacf1d2e..000000000 --- a/operations_on_datastructures/union_of_2_arrays.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include -int main() { - int m, n, i = 0, j = 0; - cout << "Enter size of both arrays:"; - cin >> m >> n; - int a[m]; - int b[n]; - cout << "Enter elements of array 1:"; - for (i = 0; i < m; i++) cin >> a[i]; - cout << "Enter elements of array 2:"; - for (i = 0; i < n; i++) cin >> b[i]; - i = 0; - j = 0; - while ((i < m) && (j < n)) { - if (a[i] < b[j]) - cout << a[i++] << " "; - else if (a[i] > b[j]) - cout << b[j++] << " "; - else { - cout << a[i++]; - j++; - } - } - while (i < m) cout << a[i++] << " "; - while (j < n) cout << b[j++] << " "; - return 0; -} diff --git a/operations_on_datastructures/union_of_two_arrays.cpp b/operations_on_datastructures/union_of_two_arrays.cpp new file mode 100644 index 000000000..45433379e --- /dev/null +++ b/operations_on_datastructures/union_of_two_arrays.cpp @@ -0,0 +1,219 @@ +/** + * @file + * @brief Implementation for the [Union of two sorted + * Arrays](https://en.wikipedia.org/wiki/Union_(set_theory)) + * algorithm. + * @details The Union of two arrays is the collection of all the unique elements + * in the first array, combined with all of the unique elements of a second + * array. This implementation uses ordered arrays, and an algorithm to correctly + * order them and return the result as a new array (vector). + * @author [Alvin](https://github.com/polarvoid) + */ + +#include /// for std::sort +#include /// for assert +#include /// for IO operations +#include /// for std::vector + +/** + * @namespace operations_on_datastructures + * @brief Operations on Data Structures + */ +namespace operations_on_datastructures { + +/** + * @brief Prints the values of a vector sequentially, ending with a newline + * character. + * @param array Reference to the array to be printed + * @returns void + */ +void print(const std::vector &array) { + for (int64_t i : array) { + std::cout << i << " "; /// Print each value in the array + } + std::cout << "\n"; /// Print newline +} + +/** + * @brief Gets the union of two sorted arrays, and returns them in a + * vector. + * @details An algorithm is used that compares the elements of the two vectors, + * appending the one that has a lower value, and incrementing the index for that + * array. If one of the arrays reaches its end, all the elements of the other + * are appended to the resultant vector. + * @param first A std::vector of sorted integer values + * @param second A std::vector of sorted integer values + * @returns A std::vector of the union of the two arrays, in ascending order + */ +std::vector get_union(const std::vector &first, + const std::vector &second) { + std::vector res; ///< Vector to hold the union + size_t f_index = 0; ///< Index for the first array + size_t s_index = 0; ///< Index for the second array + size_t f_length = first.size(); ///< Length of first array + size_t s_length = second.size(); ///< Length of second array + int32_t next = 0; ///< Integer to store value of the next element + + while (f_index < f_length && s_index < s_length) { + if (first[f_index] < second[s_index]) { + next = first[f_index]; ///< Append from first array + f_index++; ///< Increment index of second array + } else if (first[f_index] > second[s_index]) { + next = second[s_index]; ///< Append from second array + s_index++; ///< Increment index of second array + } else { + next = first[f_index]; ///< Element is the same in both + f_index++; ///< Increment index of first array + s_index++; ///< Increment index of second array too + } + if ((res.size() == 0) || (next != res.back())) { + res.push_back(next); ///< Add the element if it is unique + } + } + while (f_index < f_length) { + next = first[f_index]; ///< Add remaining elements + if ((res.size() == 0) || (next != res.back())) { + res.push_back(next); ///< Add the element if it is unique + } + f_index++; + } + while (s_index < s_length) { + next = second[s_index]; ///< Add remaining elements + if ((res.size() == 0) || (next != res.back())) { + res.push_back(next); ///< Add the element if it is unique + } + s_index++; + } + return res; +} + +} // namespace operations_on_datastructures + +/** + * @namespace tests + * @brief Testcases to check Union of Two Arrays. + */ +namespace tests { +using operations_on_datastructures::get_union; +using operations_on_datastructures::print; +/** + * @brief A Test to check an edge case (two empty arrays) + * @returns void + */ +void test1() { + std::cout << "TEST CASE 1\n"; + std::cout << "Intialized a = {} b = {}\n"; + std::cout << "Expected result: {}\n"; + std::vector a = {}; + std::vector b = {}; + std::vector result = get_union(a, b); + assert(result == a); ///< Check if result is empty + print(result); ///< Should only print newline + std::cout << "TEST PASSED!\n\n"; +} +/** + * @brief A Test to check an edge case (one empty array) + * @returns void + */ +void test2() { + std::cout << "TEST CASE 2\n"; + std::cout << "Intialized a = {} b = {2, 3}\n"; + std::cout << "Expected result: {2, 3}\n"; + std::vector a = {}; + std::vector b = {2, 3}; + std::vector result = get_union(a, b); + assert(result == b); ///< Check if result is equal to b + print(result); ///< Should print 2 3 + std::cout << "TEST PASSED!\n\n"; +} +/** + * @brief A Test to check correct functionality with a simple test case + * @returns void + */ +void test3() { + std::cout << "TEST CASE 3\n"; + std::cout << "Intialized a = {4, 6} b = {2, 3}\n"; + std::cout << "Expected result: {2, 3, 4, 6}\n"; + std::vector a = {4, 6}; + std::vector b = {2, 3}; + std::vector result = get_union(a, b); + std::vector expected = {2, 3, 4, 6}; + assert(result == expected); ///< Check if result is correct + print(result); ///< Should print 2 3 4 6 + std::cout << "TEST PASSED!\n\n"; +} +/** + * @brief A Test to check correct functionality with duplicate values + * @returns void + */ +void test4() { + std::cout << "TEST CASE 4\n"; + std::cout << "Intialized a = {4, 6, 6, 7} b = {2, 3, 4}\n"; + std::cout << "Expected result: {2, 3, 4, 6, 7}\n"; + std::vector a = {4, 6, 6, 7}; + std::vector b = {2, 3, 4}; + std::vector result = get_union(a, b); + std::vector expected = {2, 3, 4, 6, 7}; + assert(result == expected); ///< Check if result is correct + print(result); ///< Should print 2 3 4 6 7 + std::cout << "TEST PASSED!\n\n"; +} +/** + * @brief A Test to check correct functionality with a harder test case + * @returns void + */ +void test5() { + std::cout << "TEST CASE 5\n"; + std::cout << "Intialized a = {1, 4, 6, 7, 9} b = {2, 3, 5}\n"; + std::cout << "Expected result: {1, 2, 3, 4, 5, 6, 7, 9}\n"; + std::vector a = {1, 4, 6, 7, 9}; + std::vector b = {2, 3, 5}; + std::vector result = get_union(a, b); + std::vector expected = {1, 2, 3, 4, 5, 6, 7, 9}; + assert(result == expected); ///< Check if result is correct + print(result); ///< Should print 1 2 3 4 5 6 7 9 + std::cout << "TEST PASSED!\n\n"; +} +/** + * @brief A Test to check correct functionality with an array sorted using + * std::sort + * @returns void + */ +void test6() { + std::cout << "TEST CASE 6\n"; + std::cout << "Intialized a = {1, 3, 3, 2, 5, 9, 4, 3, 2} "; + std::cout << "b = {11, 3, 7, 8, 6}\n"; + std::cout << "Expected result: {1, 2, 3, 4, 5, 6, 7, 8, 9, 11}\n"; + std::vector a = {1, 3, 3, 2, 5, 9, 4, 3, 2}; + std::vector b = {11, 3, 7, 8, 6}; + std::sort(a.begin(), a.end()); ///< Sort vector a + std::sort(b.begin(), b.end()); ///< Sort vector b + std::vector result = get_union(a, b); + std::vector expected = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11}; + assert(result == expected); ///< Check if result is correct + print(result); ///< Should print 1 2 3 4 5 6 7 8 9 11 + std::cout << "TEST PASSED!\n\n"; +} +} // namespace tests + +/** + * @brief Function to test the correctness of get_union() function + * @returns void + */ +static void test() { + tests::test1(); + tests::test2(); + tests::test3(); + tests::test4(); + tests::test5(); + tests::test6(); +} + +/** + * @brief main function + * @returns 0 on exit + */ +int main() { + test(); // run self-test implementations + return 0; +} From 5b78538570fa9f2a236512162c28f733783902d7 Mon Sep 17 00:00:00 2001 From: Focus <65309793+Focusucof@users.noreply.github.com> Date: Fri, 22 Oct 2021 01:48:41 -0400 Subject: [PATCH 2/3] feat: added a1z26 cipher (#1775) * feat: added a1z26 cipher * updating DIRECTORY.md * clang-format and clang-tidy fixes for 6e5b6be0 * Update ciphers/a1z26_cipher.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for 36edde81 * fix: brace style Co-authored-by: David Leal * [feat/fix]: uses uint8_t for maps instead of int * clang-format and clang-tidy fixes for ef211d41 Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: David Leal --- DIRECTORY.md | 1 + ciphers/a1z26_cipher.cpp | 162 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 163 insertions(+) create mode 100644 ciphers/a1z26_cipher.cpp diff --git a/DIRECTORY.md b/DIRECTORY.md index 048b95a41..4480f7892 100644 --- a/DIRECTORY.md +++ b/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) diff --git a/ciphers/a1z26_cipher.cpp b/ciphers/a1z26_cipher.cpp new file mode 100644 index 000000000..82a3d3bb4 --- /dev/null +++ b/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 /// for std::transform and std::replace +#include /// for assert +#include /// for uint8_t +#include /// for IO operations +#include /// for std::map +#include /// for std::stringstream +#include /// for std::string +#include /// 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 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 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 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 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; +} From 6c6747174ce018c0ab7e152e313c35bc594bee1a Mon Sep 17 00:00:00 2001 From: OM GUPTA Date: Fri, 22 Oct 2021 17:07:33 +0530 Subject: [PATCH 3/3] feat: updated the Prime number checking code to make it more efficient (#1714) * updated the code to make it more efficient * Update math/check_prime.cpp Co-authored-by: David Leal * Update math/check_prime.cpp Co-authored-by: David Leal * Apply suggestions from code review Co-authored-by: David Leal --- math/check_prime.cpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/math/check_prime.cpp b/math/check_prime.cpp index 3c3ff2b62..1e1bd975a 100644 --- a/math/check_prime.cpp +++ b/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 - * is even except 2, break the loop and return false telling number is not - * prime. + * our loop with i+6 jumping and check for i or i+2 to be a factor of the number; + * 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) */ -#include -#include + +#include /// for assert +#include /// 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) { - for (T i = 3; (i * i) <= (num); i = (i + 2)) { - if ((num % i) == 0) { + else { + for (T i = 5; (i * i) <= (num); i = (i + 6)) { + if ((num % i) == 0 || (num%(i+2)==0 )) { result = false; break; }