Merge branch 'master' into dp/trapped_rainwater

Author: sozelfist

.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 .

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