mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
Merge branch 'TheAlgorithms:master' into master
This commit is contained in:
Alvin Philips
GitHub
commit
3d36c83c8f
@ -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)
|
||||
@ -45,6 +46,8 @@
|
||||
* [Main Cll](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/cll/main_cll.cpp)
|
||||
* [Disjoint Set](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/disjoint_set.cpp)
|
||||
* [Doubly Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/doubly_linked_list.cpp)
|
||||
* [Dsu Path Compression](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/dsu_path_compression.cpp)
|
||||
* [Dsu Union Rank](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/dsu_union_rank.cpp)
|
||||
* [Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/linked_list.cpp)
|
||||
* [Linkedlist Implentation Usingarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/linkedlist_implentation_usingarray.cpp)
|
||||
* [List Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/list_array.cpp)
|
||||
@ -162,6 +165,7 @@
|
||||
* [Vector Ops](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/vector_ops.hpp)
|
||||
|
||||
## Math
|
||||
* [Area](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/area.cpp)
|
||||
* [Armstrong Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/armstrong_number.cpp)
|
||||
* [Binary Exponent](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/binary_exponent.cpp)
|
||||
* [Binomial Calculate](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/binomial_calculate.cpp)
|
||||
@ -240,7 +244,7 @@
|
||||
* [Circular Queue Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/circular_queue_using_array.cpp)
|
||||
* [Get Size Of Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/get_size_of_linked_list.cpp)
|
||||
* [Inorder Successor Of Bst](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/inorder_successor_of_bst.cpp)
|
||||
* [Intersection Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/intersection_of_2_arrays.cpp)
|
||||
* [Intersection Of Two Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/intersection_of_two_arrays.cpp)
|
||||
* [Reverse A Linked List Using Recusion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp)
|
||||
* [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)
|
||||
|
||||
162
ciphers/a1z26_cipher.cpp
Normal file
162
ciphers/a1z26_cipher.cpp
Normal file
@ -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;
|
||||
}
|
||||
213
data_structures/dsu_path_compression.cpp
Normal file
213
data_structures/dsu_path_compression.cpp
Normal file
@ -0,0 +1,213 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief [DSU (Disjoint
|
||||
* sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
|
||||
* @details
|
||||
* It is a very powerful data structure that keeps track of different
|
||||
* clusters(sets) of elements, these sets are disjoint(doesnot have a common
|
||||
* element). Disjoint sets uses cases : for finding connected components in a
|
||||
* graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
|
||||
* Operations that can be performed:
|
||||
* 1) UnionSet(i,j): add(element i and j to the set)
|
||||
* 2) findSet(i): returns the representative of the set to which i belogngs to.
|
||||
* 3) get_max(i),get_min(i) : returns the maximum and minimum
|
||||
* Below is the class-based approach which uses the heuristic of path
|
||||
* compression. Using path compression in findSet(i),we are able to get to the
|
||||
* representative of i in O(1) time.
|
||||
* @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
|
||||
* @see dsu_union_rank.cpp
|
||||
*/
|
||||
|
||||
#include <cassert> /// for assert
|
||||
#include <iostream> /// for IO operations
|
||||
#include <vector> /// for std::vector
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::vector;
|
||||
|
||||
/**
|
||||
* @brief Disjoint sets union data structure, class based representation.
|
||||
* @param n number of elements
|
||||
*/
|
||||
class dsu {
|
||||
private:
|
||||
vector<uint64_t> p; ///< keeps track of the parent of ith element
|
||||
vector<uint64_t> depth; ///< tracks the depth(rank) of i in the tree
|
||||
vector<uint64_t> setSize; ///< size of each chunk(set)
|
||||
vector<uint64_t> maxElement; ///< maximum of each set to which i belongs to
|
||||
vector<uint64_t> minElement; ///< minimum of each set to which i belongs to
|
||||
public:
|
||||
/**
|
||||
* @brief contructor for initialising all data members.
|
||||
* @param n number of elements
|
||||
*/
|
||||
explicit dsu(uint64_t n) {
|
||||
p.assign(n, 0);
|
||||
/// initially, all of them are their own parents
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
p[i] = i;
|
||||
}
|
||||
/// initially all have depth are equals to zero
|
||||
depth.assign(n, 0);
|
||||
maxElement.assign(n, 0);
|
||||
minElement.assign(n, 0);
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
depth[i] = 0;
|
||||
maxElement[i] = i;
|
||||
minElement[i] = i;
|
||||
}
|
||||
setSize.assign(n, 0);
|
||||
/// initially set size will be equals to one
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
setSize[i] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Method to find the representative of the set to which i belongs
|
||||
* to, T(n) = O(1)
|
||||
* @param i element of some set
|
||||
* @returns representative of the set to which i belongs to.
|
||||
*/
|
||||
uint64_t findSet(uint64_t i) {
|
||||
/// using path compression
|
||||
if (p[i] == i) {
|
||||
return i;
|
||||
}
|
||||
return (p[i] = findSet(p[i]));
|
||||
}
|
||||
/**
|
||||
* @brief Method that combines two disjoint sets to which i and j belongs to
|
||||
* and make a single set having a common representative.
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns void
|
||||
*/
|
||||
void UnionSet(uint64_t i, uint64_t j) {
|
||||
/// check if both belongs to the same set or not
|
||||
if (isSame(i, j)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// we find the representative of the i and j
|
||||
uint64_t x = findSet(i);
|
||||
uint64_t y = findSet(j);
|
||||
|
||||
/// always keeping the min as x
|
||||
/// shallow tree
|
||||
if (depth[x] > depth[y]) {
|
||||
std::swap(x, y);
|
||||
}
|
||||
/// making the shallower root's parent the deeper root
|
||||
p[x] = y;
|
||||
|
||||
/// if same depth, then increase one's depth
|
||||
if (depth[x] == depth[y]) {
|
||||
depth[y]++;
|
||||
}
|
||||
/// total size of the resultant set
|
||||
setSize[y] += setSize[x];
|
||||
/// changing the maximum elements
|
||||
maxElement[y] = std::max(maxElement[x], maxElement[y]);
|
||||
minElement[y] = std::min(minElement[x], minElement[y]);
|
||||
}
|
||||
/**
|
||||
* @brief A utility function which check whether i and j belongs to
|
||||
* same set or not
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns `true` if element `i` and `j` ARE in the same set
|
||||
* @returns `false` if element `i` and `j` are NOT in same set
|
||||
*/
|
||||
bool isSame(uint64_t i, uint64_t j) {
|
||||
if (findSet(i) == findSet(j)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* @brief prints the minimum, maximum and size of the set to which i belongs
|
||||
* to
|
||||
* @param i element of some set
|
||||
* @returns void
|
||||
*/
|
||||
vector<uint64_t> get(uint64_t i) {
|
||||
vector<uint64_t> ans;
|
||||
ans.push_back(get_min(i));
|
||||
ans.push_back(get_max(i));
|
||||
ans.push_back(size(i));
|
||||
return ans;
|
||||
}
|
||||
/**
|
||||
* @brief A utility function that returns the size of the set to which i
|
||||
* belongs to
|
||||
* @param i element of some set
|
||||
* @returns size of the set to which i belongs to
|
||||
*/
|
||||
uint64_t size(uint64_t i) { return setSize[findSet(i)]; }
|
||||
/**
|
||||
* @brief A utility function that returns the max element of the set to
|
||||
* which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns maximum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_max(uint64_t i) { return maxElement[findSet(i)]; }
|
||||
/**
|
||||
* @brief A utility function that returns the min element of the set to
|
||||
* which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns minimum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_min(uint64_t i) { return minElement[findSet(i)]; }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Self-test implementations, 1st test
|
||||
* @returns void
|
||||
*/
|
||||
static void test1() {
|
||||
// the minimum, maximum, and size of the set
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
// set 1
|
||||
d.UnionSet(1, 2); // performs union operation on 1 and 2
|
||||
d.UnionSet(1, 4); // performs union operation on 1 and 4
|
||||
vector<uint64_t> ans = {1, 4, 3};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.get(4).at(i) == ans[i]); // makes sure algorithm works fine
|
||||
}
|
||||
cout << "1st test passed!" << endl;
|
||||
}
|
||||
/**
|
||||
* @brief Self-implementations, 2nd test
|
||||
* @returns void
|
||||
*/
|
||||
static void test2() {
|
||||
// the minimum, maximum, and size of the set
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
// set 1
|
||||
d.UnionSet(3, 5);
|
||||
d.UnionSet(5, 6);
|
||||
d.UnionSet(5, 7);
|
||||
vector<uint64_t> ans = {3, 7, 4};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.get(3).at(i) == ans[i]); // makes sure algorithm works fine
|
||||
}
|
||||
cout << "2nd test passed!" << endl;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Main function
|
||||
* @returns 0 on exit
|
||||
* */
|
||||
int main() {
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
|
||||
test1(); // run 1st test case
|
||||
test2(); // run 2nd test case
|
||||
|
||||
return 0;
|
||||
}
|
||||
187
data_structures/dsu_union_rank.cpp
Normal file
187
data_structures/dsu_union_rank.cpp
Normal file
@ -0,0 +1,187 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief [DSU (Disjoint
|
||||
* sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
|
||||
* @details
|
||||
* dsu : It is a very powerful data structure which keeps track of different
|
||||
* clusters(sets) of elements, these sets are disjoint(doesnot have a common
|
||||
* element). Disjoint sets uses cases : for finding connected components in a
|
||||
* graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
|
||||
* Operations that can be performed:
|
||||
* 1) UnionSet(i,j): add(element i and j to the set)
|
||||
* 2) findSet(i): returns the representative of the set to which i belogngs to.
|
||||
* 3) getParents(i): prints the parent of i and so on and so forth.
|
||||
* Below is the class-based approach which uses the heuristic of union-ranks.
|
||||
* Using union-rank in findSet(i),we are able to get to the representative of i
|
||||
* in slightly delayed O(logN) time but it allows us to keep tracks of the
|
||||
* parent of i.
|
||||
* @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
|
||||
* @see dsu_path_compression.cpp
|
||||
*/
|
||||
|
||||
#include <cassert> /// for assert
|
||||
#include <iostream> /// for IO operations
|
||||
#include <vector> /// for std::vector
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::vector;
|
||||
|
||||
/**
|
||||
* @brief Disjoint sets union data structure, class based representation.
|
||||
* @param n number of elements
|
||||
*/
|
||||
class dsu {
|
||||
private:
|
||||
vector<uint64_t> p; ///< keeps track of the parent of ith element
|
||||
vector<uint64_t> depth; ///< tracks the depth(rank) of i in the tree
|
||||
vector<uint64_t> setSize; ///< size of each chunk(set)
|
||||
public:
|
||||
/**
|
||||
* @brief constructor for initialising all data members
|
||||
* @param n number of elements
|
||||
*/
|
||||
explicit dsu(uint64_t n) {
|
||||
p.assign(n, 0);
|
||||
/// initially all of them are their own parents
|
||||
depth.assign(n, 0);
|
||||
setSize.assign(n, 0);
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
p[i] = i;
|
||||
depth[i] = 0;
|
||||
setSize[i] = 1;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @brief Method to find the representative of the set to which i belongs
|
||||
* to, T(n) = O(logN)
|
||||
* @param i element of some set
|
||||
* @returns representative of the set to which i belongs to
|
||||
*/
|
||||
uint64_t findSet(uint64_t i) {
|
||||
/// using union-rank
|
||||
while (i != p[i]) {
|
||||
i = p[i];
|
||||
}
|
||||
return i;
|
||||
}
|
||||
/**
|
||||
* @brief Method that combines two disjoint sets to which i and j belongs to
|
||||
* and make a single set having a common representative.
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns void
|
||||
*/
|
||||
void unionSet(uint64_t i, uint64_t j) {
|
||||
/// checks if both belongs to same set or not
|
||||
if (isSame(i, j)) {
|
||||
return;
|
||||
}
|
||||
/// we find representative of the i and j
|
||||
uint64_t x = findSet(i);
|
||||
uint64_t y = findSet(j);
|
||||
|
||||
/// always keeping the min as x
|
||||
/// in order to create a shallow tree
|
||||
if (depth[x] > depth[y]) {
|
||||
std::swap(x, y);
|
||||
}
|
||||
/// making the shallower tree, root parent of the deeper root
|
||||
p[x] = y;
|
||||
|
||||
/// if same depth, then increase one's depth
|
||||
if (depth[x] == depth[y]) {
|
||||
depth[y]++;
|
||||
}
|
||||
/// total size of the resultant set
|
||||
setSize[y] += setSize[x];
|
||||
}
|
||||
/**
|
||||
* @brief A utility function which check whether i and j belongs to same set
|
||||
* or not
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns `true` if element i and j are in same set
|
||||
* @returns `false` if element i and j are not in same set
|
||||
*/
|
||||
bool isSame(uint64_t i, uint64_t j) {
|
||||
if (findSet(i) == findSet(j)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* @brief Method to print all the parents of i, or the path from i to
|
||||
* representative.
|
||||
* @param i element of some set
|
||||
* @returns void
|
||||
*/
|
||||
vector<uint64_t> getParents(uint64_t i) {
|
||||
vector<uint64_t> ans;
|
||||
while (p[i] != i) {
|
||||
ans.push_back(i);
|
||||
i = p[i];
|
||||
}
|
||||
ans.push_back(i);
|
||||
return ans;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* @brief Self-implementations, 1st test
|
||||
* @returns void
|
||||
*/
|
||||
static void test1() {
|
||||
/* checks the parents in the resultant structures */
|
||||
uint64_t n = 10; ///< number of elements
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
d.unionSet(2, 1); ///< performs union operation on 1 and 2
|
||||
d.unionSet(1, 4);
|
||||
d.unionSet(8, 1);
|
||||
d.unionSet(3, 5);
|
||||
d.unionSet(5, 6);
|
||||
d.unionSet(5, 7);
|
||||
d.unionSet(9, 10);
|
||||
d.unionSet(2, 10);
|
||||
// keeping track of the changes using parent pointers
|
||||
vector<uint64_t> ans = {7, 5};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.getParents(7).at(i) ==
|
||||
ans[i]); // makes sure algorithm works fine
|
||||
}
|
||||
cout << "1st test passed!" << endl;
|
||||
}
|
||||
/**
|
||||
* @brief Self-implementations, 2nd test
|
||||
* @returns void
|
||||
*/
|
||||
static void test2() {
|
||||
// checks the parents in the resultant structures
|
||||
uint64_t n = 10; ///< number of elements
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
d.unionSet(2, 1); /// performs union operation on 1 and 2
|
||||
d.unionSet(1, 4);
|
||||
d.unionSet(8, 1);
|
||||
d.unionSet(3, 5);
|
||||
d.unionSet(5, 6);
|
||||
d.unionSet(5, 7);
|
||||
d.unionSet(9, 10);
|
||||
d.unionSet(2, 10);
|
||||
|
||||
/// keeping track of the changes using parent pointers
|
||||
vector<uint64_t> ans = {2, 1, 10};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.getParents(2).at(i) ==
|
||||
ans[i]); /// makes sure algorithm works fine
|
||||
}
|
||||
cout << "2nd test passed!" << endl;
|
||||
}
|
||||
/**
|
||||
* @brief Main function
|
||||
* @returns 0 on exit
|
||||
*/
|
||||
int main() {
|
||||
test1(); // run 1st test case
|
||||
test2(); // run 2nd test case
|
||||
|
||||
return 0;
|
||||
}
|
||||
274
math/area.cpp
Normal file
274
math/area.cpp
Normal file
@ -0,0 +1,274 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief Implementations for the [area](https://en.wikipedia.org/wiki/Area) of various shapes
|
||||
* @details The area of a shape is the amount of 2D space it takes up.
|
||||
* All shapes have a formula to get the area of any given shape.
|
||||
* These implementations support multiple return types.
|
||||
*
|
||||
* @author [Focusucof](https://github.com/Focusucof)
|
||||
*/
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <cmath> /// for M_PI definition and pow()
|
||||
#include <cstdint> /// for uint16_t datatype
|
||||
#include <iostream> /// for IO operations
|
||||
#include <cassert> /// for assert
|
||||
|
||||
/**
|
||||
* @namespace math
|
||||
* @brief Mathematical algorithms
|
||||
*/
|
||||
namespace math {
|
||||
/**
|
||||
* @brief area of a [square](https://en.wikipedia.org/wiki/Square) (l * l)
|
||||
* @param length is the length of the square
|
||||
* @returns area of square
|
||||
*/
|
||||
template <typename T>
|
||||
T square_area(T length) {
|
||||
return length * length;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief area of a [rectangle](https://en.wikipedia.org/wiki/Rectangle) (l * w)
|
||||
* @param length is the length of the rectangle
|
||||
* @param width is the width of the rectangle
|
||||
* @returns area of the rectangle
|
||||
*/
|
||||
template <typename T>
|
||||
T rect_area(T length, T width) {
|
||||
return length * width;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief area of a [triangle](https://en.wikipedia.org/wiki/Triangle) (b * h /
|
||||
* 2)
|
||||
* @param base is the length of the bottom side of the triangle
|
||||
* @param height is the length of the tallest point in the triangle
|
||||
* @returns area of the triangle
|
||||
*/
|
||||
template <typename T>
|
||||
T triangle_area(T base, T height) {
|
||||
return base * height / 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief area of a [circle](https://en.wikipedia.org/wiki/Area_of_a_circle) (pi
|
||||
* * r^2)
|
||||
* @param radius is the radius of the circle
|
||||
* @returns area of the circle
|
||||
*/
|
||||
template <typename T>
|
||||
T circle_area(T radius) {
|
||||
return M_PI * pow(radius, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief area of a [parallelogram](https://en.wikipedia.org/wiki/Parallelogram)
|
||||
* (b * h)
|
||||
* @param base is the length of the bottom side of the parallelogram
|
||||
* @param height is the length of the tallest point in the parallelogram
|
||||
* @returns area of the parallelogram
|
||||
*/
|
||||
template <typename T>
|
||||
T parallelogram_area(T base, T height) {
|
||||
return base * height;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief surface area of a [cube](https://en.wikipedia.org/wiki/Cube) ( 6 * (l
|
||||
* * l))
|
||||
* @param length is the length of the cube
|
||||
* @returns surface area of the cube
|
||||
*/
|
||||
template <typename T>
|
||||
T cube_surface_area(T length) {
|
||||
return 6 * length * length;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief surface area of a [sphere](https://en.wikipedia.org/wiki/Sphere) ( 4 *
|
||||
* pi * r^2)
|
||||
* @param radius is the radius of the sphere
|
||||
* @returns surface area of the sphere
|
||||
*/
|
||||
template <typename T>
|
||||
T sphere_surface_area(T radius) {
|
||||
return 4 * M_PI * pow(radius, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief surface area of a [cylinder](https://en.wikipedia.org/wiki/Cylinder)
|
||||
* (2 * pi * r * h + 2 * pi * r^2)
|
||||
* @param radius is the radius of the cylinder
|
||||
* @param height is the height of the cylinder
|
||||
* @returns surface area of the cylinder
|
||||
*/
|
||||
template <typename T>
|
||||
T cylinder_surface_area(T radius, T height) {
|
||||
return 2 * M_PI * radius * height + 2 * M_PI * pow(radius, 2);
|
||||
}
|
||||
} // namespace math
|
||||
|
||||
/**
|
||||
* @brief Self-test implementations
|
||||
* @returns void
|
||||
*/
|
||||
static void test() {
|
||||
// I/O variables for testing
|
||||
uint16_t int_length; // 16 bit integer length input
|
||||
uint16_t int_width; // 16 bit integer width input
|
||||
uint16_t int_base; // 16 bit integer base input
|
||||
uint16_t int_height; // 16 bit integer height input
|
||||
uint16_t int_expected; // 16 bit integer expected output
|
||||
uint16_t int_area; // 16 bit integer output
|
||||
|
||||
float float_length; // float length input
|
||||
float float_expected; // float expected output
|
||||
float float_area; // float output
|
||||
|
||||
double double_length; // double length input
|
||||
double double_width; // double width input
|
||||
double double_radius; // double radius input
|
||||
double double_height; // double height input
|
||||
double double_expected; // double expected output
|
||||
double double_area; // double output
|
||||
|
||||
// 1st test
|
||||
int_length = 5;
|
||||
int_expected = 25;
|
||||
int_area = math::square_area(int_length);
|
||||
|
||||
std::cout << "AREA OF A SQUARE (int)" << std::endl;
|
||||
std::cout << "Input Length: " << int_length << std::endl;
|
||||
std::cout << "Expected Output: " << int_expected << std::endl;
|
||||
std::cout << "Output: " << int_area << std::endl;
|
||||
assert(int_area == int_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 2nd test
|
||||
float_length = 2.5;
|
||||
float_expected = 6.25;
|
||||
float_area = math::square_area(float_length);
|
||||
|
||||
std::cout << "AREA OF A SQUARE (float)" << std::endl;
|
||||
std::cout << "Input Length: " << float_length << std::endl;
|
||||
std::cout << "Expected Output: " << float_expected << std::endl;
|
||||
std::cout << "Output: " << float_area << std::endl;
|
||||
assert(float_area == float_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 3rd test
|
||||
int_length = 4;
|
||||
int_width = 7;
|
||||
int_expected = 28;
|
||||
int_area = math::rect_area(int_length, int_width);
|
||||
|
||||
std::cout << "AREA OF A RECTANGLE (int)" << std::endl;
|
||||
std::cout << "Input Length: " << int_length << std::endl;
|
||||
std::cout << "Input Width: " << int_width << std::endl;
|
||||
std::cout << "Expected Output: " << int_expected << std::endl;
|
||||
std::cout << "Output: " << int_area << std::endl;
|
||||
assert(int_area == int_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 4th test
|
||||
double_length = 2.5;
|
||||
double_width = 5.7;
|
||||
double_expected = 14.25;
|
||||
double_area = math::rect_area(double_length, double_width);
|
||||
|
||||
std::cout << "AREA OF A RECTANGLE (double)" << std::endl;
|
||||
std::cout << "Input Length: " << double_length << std::endl;
|
||||
std::cout << "Input Width: " << double_width << std::endl;
|
||||
std::cout << "Expected Output: " << double_expected << std::endl;
|
||||
std::cout << "Output: " << double_area << std::endl;
|
||||
assert(double_area == double_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 5th test
|
||||
int_base = 10;
|
||||
int_height = 3;
|
||||
int_expected = 15;
|
||||
int_area = math::triangle_area(int_base, int_height);
|
||||
|
||||
std::cout << "AREA OF A TRIANGLE" << std::endl;
|
||||
std::cout << "Input Base: " << int_base << std::endl;
|
||||
std::cout << "Input Height: " << int_height << std::endl;
|
||||
std::cout << "Expected Output: " << int_expected << std::endl;
|
||||
std::cout << "Output: " << int_area << std::endl;
|
||||
assert(int_area == int_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 6th test
|
||||
double_radius = 6;
|
||||
double_expected = 113.09733552923255; // rounded down because the double datatype truncates after 14 decimal places
|
||||
double_area = math::circle_area(double_radius);
|
||||
|
||||
std::cout << "AREA OF A CIRCLE" << std::endl;
|
||||
std::cout << "Input Radius: " << double_radius << std::endl;
|
||||
std::cout << "Expected Output: " << double_expected << std::endl;
|
||||
std::cout << "Output: " << double_area << std::endl;
|
||||
assert(double_area == double_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 7th test
|
||||
int_base = 6;
|
||||
int_height = 7;
|
||||
int_expected = 42;
|
||||
int_area = math::parallelogram_area(int_base, int_height);
|
||||
|
||||
std::cout << "AREA OF A PARALLELOGRAM" << std::endl;
|
||||
std::cout << "Input Base: " << int_base << std::endl;
|
||||
std::cout << "Input Height: " << int_height << std::endl;
|
||||
std::cout << "Expected Output: " << int_expected << std::endl;
|
||||
std::cout << "Output: " << int_area << std::endl;
|
||||
assert(int_area == int_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 8th test
|
||||
double_length = 5.5;
|
||||
double_expected = 181.5;
|
||||
double_area = math::cube_surface_area(double_length);
|
||||
|
||||
std::cout << "SURFACE AREA OF A CUBE" << std::endl;
|
||||
std::cout << "Input Length: " << double_length << std::endl;
|
||||
std::cout << "Expected Output: " << double_expected << std::endl;
|
||||
std::cout << "Output: " << double_area << std::endl;
|
||||
assert(double_area == double_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 9th test
|
||||
double_radius = 10.0;
|
||||
double_expected = 1256.6370614359172; // rounded down because the whole value gets truncated
|
||||
double_area = math::sphere_surface_area(double_radius);
|
||||
|
||||
std::cout << "SURFACE AREA OF A SPHERE" << std::endl;
|
||||
std::cout << "Input Radius: " << double_radius << std::endl;
|
||||
std::cout << "Expected Output: " << double_expected << std::endl;
|
||||
std::cout << "Output: " << double_area << std::endl;
|
||||
assert(double_area == double_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
|
||||
// 10th test
|
||||
double_radius = 4.0;
|
||||
double_height = 7.0;
|
||||
double_expected = 276.46015351590177;
|
||||
double_area = math::cylinder_surface_area(double_radius, double_height);
|
||||
|
||||
std::cout << "SURFACE AREA OF A CYLINDER" << std::endl;
|
||||
std::cout << "Input Radius: " << double_radius << std::endl;
|
||||
std::cout << "Input Height: " << double_height << std::endl;
|
||||
std::cout << "Expected Output: " << double_expected << std::endl;
|
||||
std::cout << "Output: " << double_area << std::endl;
|
||||
assert(double_area == double_expected);
|
||||
std::cout << "TEST PASSED" << std::endl << std::endl;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Main function
|
||||
* @returns 0 on exit
|
||||
*/
|
||||
int main() {
|
||||
test(); // run self-test implementations
|
||||
return 0;
|
||||
}
|
||||
@ -7,12 +7,14 @@
|
||||
* @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 <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 +25,13 @@ 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;
|
||||
}
|
||||
|
||||
@ -1,27 +1,175 @@
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int main() {
|
||||
int n, k;
|
||||
cout << "Enter size of array=\t";
|
||||
cin >> n;
|
||||
cout << "Enter Number of indices u want to rotate the array to right=\t";
|
||||
cin >> k;
|
||||
int a[n];
|
||||
cout << "Enter elements of array=\t";
|
||||
for (int i = 0; i < n; i++) cin >> a[i];
|
||||
int temp = 0;
|
||||
for (int i = 0; i < k; i++) {
|
||||
temp = a[n - 1];
|
||||
for (int j = n - 1; j >= 0; j--) {
|
||||
if (j == 0) {
|
||||
a[j] = temp;
|
||||
} else {
|
||||
a[j] = a[j - 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
cout << "Your rotated array is=\t";
|
||||
for (int i = 0; i < n; i++) {
|
||||
cout << a[i] << " ";
|
||||
/**
|
||||
* @file
|
||||
* @brief Implementation for the [Array right
|
||||
* Rotation](https://www.javatpoint.com/program-to-right-rotate-the-elements-of-an-array)
|
||||
* algorithm.
|
||||
* @details Shifting an array to the right involves moving each element of the
|
||||
* array so that it occupies a position of a certain shift value after its
|
||||
* current one. This implementation uses a result vector and does not mutate the
|
||||
* input.
|
||||
* @see array_left_rotation.cpp
|
||||
* @author [Alvin](https://github.com/polarvoid)
|
||||
*/
|
||||
|
||||
#include <cassert> /// for assert
|
||||
#include <iostream> /// for IO operations
|
||||
#include <vector> /// 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<int32_t> &array) {
|
||||
for (int32_t i : array) {
|
||||
std::cout << i << " "; /// Print each value in the array
|
||||
}
|
||||
std::cout << "\n"; /// Print newline
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Shifts the given vector to the right by the shift amount and returns a
|
||||
* new vector with the result. The original vector is not mutated.
|
||||
* @details Shifts the values of the vector, by creating a new vector and adding
|
||||
* values from the shift index to the end, then appending the rest of the
|
||||
* elements to the start of the vector.
|
||||
* @param array A reference to the input std::vector
|
||||
* @param shift The amount to be shifted to the right
|
||||
* @returns A std::vector with the shifted values
|
||||
*/
|
||||
std::vector<int32_t> shift_right(const std::vector<int32_t> &array,
|
||||
size_t shift) {
|
||||
if (array.size() <= shift) {
|
||||
return {}; ///< We got an invalid shift, return empty array
|
||||
}
|
||||
std::vector<int32_t> res(array.size()); ///< Result array
|
||||
for (size_t i = shift; i < array.size(); i++) {
|
||||
res[i] = array[i - shift]; ///< Add values after the shift index
|
||||
}
|
||||
for (size_t i = 0; i < shift; i++) {
|
||||
res[i] =
|
||||
array[array.size() - shift + i]; ///< Add the values from the start
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
} // namespace operations_on_datastructures
|
||||
|
||||
/**
|
||||
* @namespace tests
|
||||
* @brief Testcases to check Union of Two Arrays.
|
||||
*/
|
||||
namespace tests {
|
||||
using operations_on_datastructures::print;
|
||||
using operations_on_datastructures::shift_right;
|
||||
/**
|
||||
* @brief A Test to check an simple case
|
||||
* @returns void
|
||||
*/
|
||||
void test1() {
|
||||
std::cout << "TEST CASE 1\n";
|
||||
std::cout << "Initialized arr = {1, 2, 3, 4, 5}\n";
|
||||
std::cout << "Expected result: {4, 5, 1, 2, 3}\n";
|
||||
std::vector<int32_t> arr = {1, 2, 3, 4, 5};
|
||||
std::vector<int32_t> res = shift_right(arr, 2);
|
||||
std::vector<int32_t> expected = {4, 5, 1, 2, 3};
|
||||
assert(res == expected);
|
||||
print(res); ///< Should print 4 5 1 2 3
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
/**
|
||||
* @brief A Test to check an empty vector
|
||||
* @returns void
|
||||
*/
|
||||
void test2() {
|
||||
std::cout << "TEST CASE 2\n";
|
||||
std::cout << "Initialized arr = {}\n";
|
||||
std::cout << "Expected result: {}\n";
|
||||
std::vector<int32_t> arr = {};
|
||||
std::vector<int32_t> res = shift_right(arr, 2);
|
||||
std::vector<int32_t> expected = {};
|
||||
assert(res == expected);
|
||||
print(res); ///< Should print empty newline
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
/**
|
||||
* @brief A Test to check an invalid shift value
|
||||
* @returns void
|
||||
*/
|
||||
void test3() {
|
||||
std::cout << "TEST CASE 3\n";
|
||||
std::cout << "Initialized arr = {1, 2, 3, 4, 5}\n";
|
||||
std::cout << "Expected result: {}\n";
|
||||
std::vector<int32_t> arr = {1, 2, 3, 4, 5};
|
||||
std::vector<int32_t> res = shift_right(arr, 7); ///< 7 > 5
|
||||
std::vector<int32_t> expected = {};
|
||||
assert(res == expected);
|
||||
print(res); ///< Should print empty newline
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
/**
|
||||
* @brief A Test to check a very large input
|
||||
* @returns void
|
||||
*/
|
||||
void test4() {
|
||||
std::cout << "TEST CASE 4\n";
|
||||
std::cout << "Initialized arr = {2, 4, ..., 420}\n";
|
||||
std::cout << "Expected result: {420, 2, 4, ..., 418}\n";
|
||||
std::vector<int32_t> arr;
|
||||
for (int i = 1; i <= 210; i++) {
|
||||
arr.push_back(i * 2);
|
||||
}
|
||||
print(arr);
|
||||
std::vector<int32_t> res = shift_right(arr, 1);
|
||||
std::vector<int32_t> expected;
|
||||
expected.push_back(420);
|
||||
for (int i = 0; i < 209; i++) {
|
||||
expected.push_back(arr[i]);
|
||||
}
|
||||
assert(res == expected);
|
||||
print(res); ///< Should print {420, 2, 4, ..., 418}
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
/**
|
||||
* @brief A Test to check a shift of zero
|
||||
* @returns void
|
||||
*/
|
||||
void test5() {
|
||||
std::cout << "TEST CASE 5\n";
|
||||
std::cout << "Initialized arr = {1, 2, 3, 4, 5}\n";
|
||||
std::cout << "Expected result: {1, 2, 3, 4, 5}\n";
|
||||
std::vector<int32_t> arr = {1, 2, 3, 4, 5};
|
||||
std::vector<int32_t> res = shift_right(arr, 0);
|
||||
assert(res == arr);
|
||||
print(res); ///< Should print 1 2 3 4 5
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
} // namespace tests
|
||||
|
||||
/**
|
||||
* @brief Function to test the correctness of shift_right() function
|
||||
* @returns void
|
||||
*/
|
||||
static void test() {
|
||||
tests::test1();
|
||||
tests::test2();
|
||||
tests::test3();
|
||||
tests::test4();
|
||||
tests::test5();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief main function
|
||||
* @returns 0 on exit
|
||||
*/
|
||||
int main() {
|
||||
test(); // run self-test implementations
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
#include <iostream>
|
||||
int main() {
|
||||
int i, j, m, n;
|
||||
cout << "Enter size of array 1:";
|
||||
cin >> m;
|
||||
cout << "Enter size of array 2:";
|
||||
cin >> n;
|
||||
int a[m];
|
||||
int b[n];
|
||||
cout << "Enter elements of array 1:";
|
||||
for (i = 0; i < m; i++) cin >> a[i];
|
||||
for (i = 0; i < n; i++) cin >> b[i];
|
||||
i = 0;
|
||||
j = 0;
|
||||
while ((i < m) && (j < n)) {
|
||||
if (a[i] < b[j])
|
||||
i++;
|
||||
else if (a[i] > b[j])
|
||||
j++;
|
||||
else {
|
||||
cout << a[i++] << " ";
|
||||
j++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
203
operations_on_datastructures/intersection_of_two_arrays.cpp
Normal file
203
operations_on_datastructures/intersection_of_two_arrays.cpp
Normal file
@ -0,0 +1,203 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief Implementation for the [Intersection of two sorted
|
||||
* Arrays](https://en.wikipedia.org/wiki/Intersection_(set_theory))
|
||||
* algorithm.
|
||||
* @details The intersection of two arrays is the collection of all the elements
|
||||
* that are common in both the first and second arrays. This implementation uses
|
||||
* ordered arrays, and an algorithm to correctly order them and return the
|
||||
* result as a new array (vector).
|
||||
* @see union_of_two_arrays.cpp
|
||||
* @author [Alvin](https://github.com/polarvoid)
|
||||
*/
|
||||
|
||||
#include <algorithm> /// for std::sort
|
||||
#include <cassert> /// for assert
|
||||
#include <iostream> /// for IO operations
|
||||
#include <vector> /// 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<int32_t> &array) {
|
||||
for (int32_t i : array) {
|
||||
std::cout << i << " "; /// Print each value in the array
|
||||
}
|
||||
std::cout << "\n"; /// Print newline
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Gets the intersection of two sorted arrays, and returns them in a
|
||||
* vector.
|
||||
* @details An algorithm is used that compares the elements of the two vectors,
|
||||
* incrementing the index of the smaller of the two. If the elements are the
|
||||
* same, the element is appended to the result array to be returned.
|
||||
* @param first A std::vector of sorted integer values
|
||||
* @param second A std::vector of sorted integer values
|
||||
* @returns A std::vector of the intersection of the two arrays, in ascending
|
||||
* order
|
||||
*/
|
||||
std::vector<int32_t> get_intersection(const std::vector<int32_t> &first,
|
||||
const std::vector<int32_t> &second) {
|
||||
std::vector<int32_t> res; ///< Vector to hold the intersection
|
||||
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
|
||||
|
||||
while (f_index < f_length && s_index < s_length) {
|
||||
if (first[f_index] < second[s_index]) {
|
||||
f_index++; ///< Increment index of second array
|
||||
} else if (first[f_index] > second[s_index]) {
|
||||
s_index++; ///< Increment index of second array
|
||||
} else {
|
||||
if ((res.size() == 0) || (first[f_index] != res.back())) {
|
||||
res.push_back(
|
||||
first[f_index]); ///< Add the element if it is unique
|
||||
}
|
||||
f_index++; ///< Increment index of first array
|
||||
s_index++; ///< Increment index of second array too
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
} // namespace operations_on_datastructures
|
||||
|
||||
/**
|
||||
* @namespace tests
|
||||
* @brief Testcases to check intersection of Two Arrays.
|
||||
*/
|
||||
namespace tests {
|
||||
using operations_on_datastructures::get_intersection;
|
||||
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<int32_t> a = {};
|
||||
std::vector<int32_t> b = {};
|
||||
std::vector<int32_t> result = get_intersection(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: {}\n";
|
||||
std::vector<int32_t> a = {};
|
||||
std::vector<int32_t> b = {2, 3};
|
||||
std::vector<int32_t> result = get_intersection(a, b);
|
||||
assert(result == a); ///< Check if result is equal to a
|
||||
print(result); ///< Should only print newline
|
||||
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 = {3, 6}\n";
|
||||
std::cout << "Expected result: {6}\n";
|
||||
std::vector<int32_t> a = {4, 6};
|
||||
std::vector<int32_t> b = {3, 6};
|
||||
std::vector<int32_t> result = get_intersection(a, b);
|
||||
std::vector<int32_t> expected = {6};
|
||||
assert(result == expected); ///< Check if result is correct
|
||||
print(result); ///< Should print 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, 6} b = {2, 4, 4, 6}\n";
|
||||
std::cout << "Expected result: {4, 6}\n";
|
||||
std::vector<int32_t> a = {4, 6, 6, 6};
|
||||
std::vector<int32_t> b = {2, 4, 4, 6};
|
||||
std::vector<int32_t> result = get_intersection(a, b);
|
||||
std::vector<int32_t> expected = {4, 6};
|
||||
assert(result == expected); ///< Check if result is correct
|
||||
print(result); ///< Should print 4 6
|
||||
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, 2, 3, 4, 6, 7, 9} b = {2, 3, 4, 5}\n";
|
||||
std::cout << "Expected result: {2, 3, 4}\n";
|
||||
std::vector<int32_t> a = {1, 2, 3, 4, 6, 7, 9};
|
||||
std::vector<int32_t> b = {2, 3, 4, 5};
|
||||
std::vector<int32_t> result = get_intersection(a, b);
|
||||
std::vector<int32_t> expected = {2, 3, 4};
|
||||
assert(result == expected); ///< Check if result is correct
|
||||
print(result); ///< Should print 2 3 4
|
||||
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, 7, 3, 2} ";
|
||||
std::cout << "b = {11, 3, 7, 8, 6}\n";
|
||||
std::cout << "Expected result: {3, 7}\n";
|
||||
std::vector<int32_t> a = {1, 3, 3, 2, 5, 9, 4, 7, 3, 2};
|
||||
std::vector<int32_t> 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<int32_t> result = get_intersection(a, b);
|
||||
std::vector<int32_t> expected = {3, 7};
|
||||
assert(result == expected); ///< Check if result is correct
|
||||
print(result); ///< Should print 3 7
|
||||
std::cout << "TEST PASSED!\n\n";
|
||||
}
|
||||
} // namespace tests
|
||||
|
||||
/**
|
||||
* @brief Function to test the correctness of get_intersection() 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;
|
||||
}
|
||||
@ -28,7 +28,7 @@ namespace operations_on_datastructures {
|
||||
* @returns void
|
||||
*/
|
||||
void print(const std::vector<int32_t> &array) {
|
||||
for (int64_t i : array) {
|
||||
for (int32_t i : array) {
|
||||
std::cout << i << " "; /// Print each value in the array
|
||||
}
|
||||
std::cout << "\n"; /// Print newline
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user