Merge branch 'master' into iterative_quick_sort

Author: realstealthninja

.github/workflows/awesome_workflow.yml

@@ -61,7 +61,7 @@ jobs:
           submodules: true
       - run: |
           cmake -B ./build -S .
-          cmake --build build
+          cmake --build build --parallel 4
       - name: Label on PR fail
         uses: actions/github-script@v6
         if: ${{ failure() && matrix.os == 'ubuntu-latest' && github.event_name == 'pull_request' }}

.github/workflows/gh-pages.yml

@@ -25,8 +25,8 @@ jobs:
           clean: false
       - name: Move & Commit files
         run: |
-          git config --global user.name github-actions
-          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git config --global user.name "$GITHUB_ACTOR"
+          git config --global user.email "$[email protected]"
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
           rm -rf d* && rm *.html && rm *.svg && rm *.map && rm *.md5 && rm *.png && rm *.js && rm *.css
           git add .

dynamic_programming/trapped_rainwater.cpp

@@ -0,0 +1,104 @@
+/**
+ * @file
+ * @brief Implementation of the [Trapped Rainwater
+ * Problem](https://www.geeksforgeeks.org/trapping-rain-water/)
+ * @details
+ * This implementation calculates the amount of rainwater that can be trapped
+ * between walls represented by an array of heights.
+ * @author [SOZEL](https://github.com/TruongNhanNguyen)
+ */
+
+#include <algorithm>  /// For std::min and std::max
+#include <cassert>    /// For assert
+#include <cstddef>    /// For std::size_t
+#include <cstdint>    /// For integral typedefs
+#include <vector>     /// For std::vector
+
+/*
+ * @namespace
+ * @brief Dynamic Programming Algorithms
+ */
+namespace dynamic_programming {
+/**
+ * @brief Function to calculate the trapped rainwater
+ * @param heights Array representing the heights of walls
+ * @return The amount of trapped rainwater
+ */
+uint32_t trappedRainwater(const std::vector<uint32_t>& heights) {
+    std::size_t n = heights.size();
+    if (n <= 2)
+        return 0;  // No water can be trapped with less than 3 walls
+
+    std::vector<uint32_t> leftMax(n), rightMax(n);
+
+    // Calculate the maximum height of wall to the left of each wall
+    leftMax[0] = heights[0];
+    for (std::size_t i = 1; i < n; ++i) {
+        leftMax[i] = std::max(leftMax[i - 1], heights[i]);
+    }
+
+    // Calculate the maximum height of wall to the right of each wall
+    rightMax[n - 1] = heights[n - 1];
+    for (std::size_t i = n - 2; i < n; --i) {
+        rightMax[i] = std::max(rightMax[i + 1], heights[i]);
+    }
+
+    // Calculate the trapped rainwater between walls
+    uint32_t trappedWater = 0;
+    for (std::size_t i = 0; i < n; ++i) {
+        trappedWater +=
+            std::max(0u, std::min(leftMax[i], rightMax[i]) - heights[i]);
+    }
+
+    return trappedWater;
+}
+
+}  // namespace dynamic_programming
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    std::vector<uint32_t> test_basic = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
+    assert(dynamic_programming::trappedRainwater(test_basic) == 6);
+
+    std::vector<uint32_t> test_peak_under_water = {3, 0, 2, 0, 4};
+    assert(dynamic_programming::trappedRainwater(test_peak_under_water) == 7);
+
+    std::vector<uint32_t> test_bucket = {5, 1, 5};
+    assert(dynamic_programming::trappedRainwater(test_bucket) == 4);
+
+    std::vector<uint32_t> test_skewed_bucket = {4, 1, 5};
+    assert(dynamic_programming::trappedRainwater(test_skewed_bucket) == 3);
+
+    std::vector<uint32_t> test_empty = {};
+    assert(dynamic_programming::trappedRainwater(test_empty) == 0);
+
+    std::vector<uint32_t> test_flat = {0, 0, 0, 0, 0};
+    assert(dynamic_programming::trappedRainwater(test_flat) == 0);
+
+    std::vector<uint32_t> test_no_trapped_water = {1, 1, 2, 4, 0, 0, 0};
+    assert(dynamic_programming::trappedRainwater(test_no_trapped_water) == 0);
+
+    std::vector<uint32_t> test_single_elevation = {5};
+    assert(dynamic_programming::trappedRainwater(test_single_elevation) == 0);
+
+    std::vector<uint32_t> test_two_point_elevation = {5, 1};
+    assert(dynamic_programming::trappedRainwater(test_two_point_elevation) ==
+           0);
+
+    std::vector<uint32_t> test_large_elevation_map_difference = {5, 1, 6, 1,
+                                                                 7, 1, 8};
+    assert(dynamic_programming::trappedRainwater(
+               test_large_elevation_map_difference) == 15);
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

greedy_algorithms/jump_game.cpp

@@ -0,0 +1,74 @@
+/**
+ * @file
+ * @brief [Jumping Game](https://leetcode.com/problems/jump-game/)
+ * algorithm implementation
+ * @details
+ *
+ * Given an array of non-negative integers, you are initially positioned at the
+ * first index of the array. Each element in the array represents your maximum
+ * jump length at that position. Determine if you are able to reach the last
+ * index. This solution takes in input as a vector and output as a boolean to
+ * check if you can reach the last position. We name the indices good and bad
+ * based on whether we can reach the destination if we start at that position.
+ * We initialize the last index as lastPos.
+ * Here, we start from the end of the array and check if we can ever reach the
+ * first index. We check if the sum of the index and the maximum jump count
+ * given is greater than or equal to the lastPos. If yes, then that is the last
+ * position you can reach starting from the back. After the end of the loop, if
+ * we reach the lastPos as 0, then the destination can be reached from the start
+ * position.
+ *
+ * @author [Rakshaa Viswanathan](https://github.com/rakshaa2000)
+ * @author [David Leal](https://github.com/Panquesito7)
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for std::cout
+#include <vector>    /// for std::vector
+
+/**
+ * @namespace
+ * @brief Greedy Algorithms
+ */
+namespace greedy_algorithms {
+/**
+ * @brief Checks whether the given element (default is `1`) can jump to the last
+ * index.
+ * @param nums array of numbers containing the maximum jump (in steps) from that
+ * index
+ * @returns true  if the index can be reached
+ * @returns false if the index can NOT be reached
+ */
+bool can_jump(const std::vector<int> &nums) {
+    size_t lastPos = nums.size() - 1;
+    for (size_t i = lastPos; i != static_cast<size_t>(-1); i--) {
+        if (i + nums[i] >= lastPos) {
+            lastPos = i;
+        }
+    }
+    return lastPos == 0;
+}
+}  // namespace greedy_algorithms
+
+/**
+ * @brief Function to test the above algorithm
+ * @returns void
+ */
+static void test() {
+    assert(greedy_algorithms::can_jump(std::vector<int>({4, 3, 1, 0, 5})));
+    assert(!greedy_algorithms::can_jump(std::vector<int>({3, 2, 1, 0, 4})));
+    assert(greedy_algorithms::can_jump(std::vector<int>({5, 9, 4, 7, 15, 3})));
+    assert(!greedy_algorithms::can_jump(std::vector<int>({1, 0, 5, 8, 12})));
+    assert(greedy_algorithms::can_jump(std::vector<int>({2, 1, 4, 7})));
+
+    std::cout << "All tests have successfully passed!\n";
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

greedy_algorithms/jumpgame.cpp

@@ -136,7 +136,7 @@ class DenseLayer {
      * @param neurons number of neurons
      * @param activation activation function for layer
      * @param kernel_shape shape of kernel
-     * @param random_kernel flag for whether to intialize kernel randomly
+     * @param random_kernel flag for whether to initialize kernel randomly
      */
     DenseLayer(const int &neurons, const std::string &activation,
                const std::pair<size_t, size_t> &kernel_shape,
@@ -502,7 +502,7 @@ class NeuralNetwork {
             auto start =
                 std::chrono::high_resolution_clock::now();  // Start clock
             double loss = 0,
-                   acc = 0;  // Intialize performance metrics with zero
+                   acc = 0;  // Initialize performance metrics with zero
             // For each starting index of batch
             for (size_t batch_start = 0; batch_start < X.size();
                  batch_start += batch_size) {
@@ -515,7 +515,7 @@ class NeuralNetwork {
                     // They will be averaged and applied to kernel
                     std::vector<std::vector<std::valarray<double>>> gradients;
                     gradients.resize(this->layers.size());
-                    // First intialize gradients to zero
+                    // First initialize gradients to zero
                     for (size_t i = 0; i < gradients.size(); i++) {
                         zeroes_initialization(
                             gradients[i], get_shape(this->layers[i].kernel));
@@ -606,7 +606,7 @@ class NeuralNetwork {
     void evaluate(const std::vector<std::vector<std::valarray<double>>> &X,
                   const std::vector<std::vector<std::valarray<double>>> &Y) {
         std::cout << "INFO: Evaluation Started" << std::endl;
-        double acc = 0, loss = 0;  // intialize performance metrics with zero
+        double acc = 0, loss = 0;  // initialize performance metrics with zero
         for (size_t i = 0; i < X.size(); i++) {  // For every sample in input
             // Get predictions
             std::vector<std::valarray<double>> pred =

machine_learning/neural_network.cpp

@@ -11,6 +11,7 @@
  */
 #include <algorithm>  // for swap function
 #include <iostream>
+#include <cstdint>
 
 /**
  * function to update the coefficients per iteration

math/extended_euclid_algorithm.cpp

@@ -46,7 +46,7 @@ namespace math {
  */
 uint64_t iterativeFactorial(uint8_t n) {
     if (n > 20) {
-        throw new std::invalid_argument("Maximum n value is 20");
+        throw std::invalid_argument("Maximum n value is 20");
     }
 
     // 1 because it is the identity number of multiplication.
@@ -101,12 +101,14 @@ static void test() {
     std::cout << "Exception test \n"
                  "Input: 21 \n"
                  "Expected output: Exception thrown \n";
+
+    bool wasExceptionThrown = false;
     try {
         math::iterativeFactorial(21);
-    } catch (std::invalid_argument* e) {
-        std::cout << "Exception thrown successfully \nContent: " << e->what()
-                  << "\n";
+    } catch (const std::invalid_argument&) {
+        wasExceptionThrown = true;
     }
+    assert(wasExceptionThrown);
 
     std::cout << "All tests have passed successfully.\n";
 }