Merge branch 'master' into patch-1

Author: realstealthninja

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

@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <array>
 #include <cassert>
+#include <random>
 
 
 /**
@@ -50,8 +51,10 @@ std::array <T, N> shuffle (std::array <T, N> arr) {
 template <typename T, size_t N>
 std::array <T, N> randomized_bogosort (std::array <T, N> arr) {
     // Untill array is not sorted
+    std::random_device random_device;
+    std::mt19937 generator(random_device());
     while (!std::is_sorted(arr.begin(), arr.end())) {
-        std::random_shuffle(arr.begin(), arr.end());// Shuffle the array
+        std::shuffle(arr.begin(), arr.end(), generator);// Shuffle the array
     }
     return arr;
 }