Merge branch 'master' into array-left-rotation

DIRECTORY.md

@@ -46,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)
@@ -163,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)
@@ -241,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)

data_structures/dsu_path_compression.cpp

@@ -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;
+}

data_structures/dsu_union_rank.cpp

@@ -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;
+}

math/area.cpp

@@ -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;
+}

operations_on_datastructures/array_right_rotation.cpp

@@ -1,27 +1,175 @@
-#include <iostream>
+/**
-using namespace std;
+ * @file
-int main() {
+ * @brief Implementation for the [Array right
-    int n, k;
+ * Rotation](https://www.javatpoint.com/program-to-right-rotate-the-elements-of-an-array)
-    cout << "Enter size of array=\t";
+ * algorithm.
-    cin >> n;
+ * @details Shifting an array to the right involves moving each element of the
-    cout << "Enter Number of indices u want to rotate the array to right=\t";
+ * array so that it occupies a position of a certain shift value after its
-    cin >> k;
+ * current one. This implementation uses a result vector and does not mutate the
-    int a[n];
+ * input.
-    cout << "Enter elements of array=\t";
+ * @see array_left_rotation.cpp
-    for (int i = 0; i < n; i++) cin >> a[i];
+ * @author [Alvin](https://github.com/polarvoid)
-    int temp = 0;
+ */
-    for (int i = 0; i < k; i++) {
+
-        temp = a[n - 1];
+#include <cassert>   /// for assert
-        for (int j = n - 1; j >= 0; j--) {
+#include <iostream>  /// for IO operations
-            if (j == 0) {
+#include <vector>    /// for std::vector
-                a[j] = temp;
+
-            } else {
+/**
-                a[j] = a[j - 1];
+ * @namespace operations_on_datastructures
-            }
+ * @brief Operations on Data Structures
-        }
+ */
-    }
+namespace operations_on_datastructures {
-    cout << "Your rotated array is=\t";
+
-    for (int i = 0; i < n; i++) {
+/**
-        cout << a[i] << " ";
+ * @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;
 }

operations_on_datastructures/intersection_of_2_arrays.cpp

@@ -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;
-}

operations_on_datastructures/intersection_of_two_arrays.cpp

@@ -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;
+}