fix: include cstdint to fix compilation

Author: realstealthninja

dynamic_programming/abbreviation.cpp

@@ -24,6 +24,7 @@
  */
 
 #include <cassert>   /// for `assert`
+#include <cstdint>   /// for `std::uint32_t`
 #include <iostream>  /// for IO operations
 #include <string>    /// for `std::string` library
 #include <vector>    /// for `std::vector` STL library

dynamic_programming/cut_rod.cpp

@@ -21,6 +21,7 @@
 #include <array>
 #include <cassert>
 #include <climits>
+#include <cstdint>
 #include <iostream>
 /**
  * @namespace dynamic_programming
@@ -70,8 +71,8 @@ int maxProfitByCuttingRod(const std::array<int, T> &price, const uint64_t &n) {
  */
 static void test() {
     // Test 1
-    const int16_t n1 = 8;                                        // size of rod
-    std::array<int32_t, n1> price1 = {1,2,4,6,8,45,21,9};  // price array
+    const int16_t n1 = 8;                                         // size of rod
+    std::array<int32_t, n1> price1 = {1, 2, 4, 6, 8, 45, 21, 9};  // price array
     const int64_t max_profit1 =
         dynamic_programming::cut_rod::maxProfitByCuttingRod(price1, n1);
     const int64_t expected_max_profit1 = 47;
@@ -86,15 +87,15 @@ static void test() {
         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
         41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
 
-    const int64_t max_profit2=
+    const int64_t max_profit2 =
         dynamic_programming::cut_rod::maxProfitByCuttingRod(price2, n2);
     const int32_t expected_max_profit2 = 90;
     assert(max_profit2 == expected_max_profit2);
     std::cout << "Maximum profit with " << n2 << " inch road is " << max_profit2
               << std::endl;
-     // Test 3
-    const int16_t n3 = 5;                                        // size of rod
-    std::array<int32_t, n3> price3 = {2,9,17,23,45};  // price array
+    // Test 3
+    const int16_t n3 = 5;                                 // size of rod
+    std::array<int32_t, n3> price3 = {2, 9, 17, 23, 45};  // price array
     const int64_t max_profit3 =
         dynamic_programming::cut_rod::maxProfitByCuttingRod(price3, n3);
     const int64_t expected_max_profit3 = 45;

dynamic_programming/house_robber.cpp

@@ -11,9 +11,9 @@
 
 #include <cassert>   /// for assert
 #include <climits>   /// for std::max
+#include <cstdint>   /// for std::uint32_t
 #include <iostream>  /// for io operations
 #include <vector>    /// for std::vector
-
 /**
  * @namespace dynamic_programming
  * @brief Dynamic Programming algorithms

dynamic_programming/longest_increasing_subsequence.cpp

@@ -21,6 +21,7 @@
 
 #include <cassert>   /// for assert
 #include <climits>   /// for std::max
+#include <cstdint>   /// for std::uint64_t
 #include <iostream>  /// for IO operations
 #include <vector>    /// for std::vector
 

dynamic_programming/minimum_edit_distance.cpp

@@ -1,6 +1,8 @@
 /**
  * @file
- * @brief Implementation of [Minimum Edit Distance](https://en.wikipedia.org/wiki/Edit_distance) using Dynamic Programing
+ * @brief Implementation of [Minimum Edit
+ * Distance](https://en.wikipedia.org/wiki/Edit_distance) using Dynamic
+ * Programing
  *
  * @details
  *
@@ -32,9 +34,11 @@
  * @author [Nirjas Jakilim](github.com/nirzak)
  */
 
-#include <cassert>     /// for assert
-#include <iostream>   /// for IO operations
+#include <cassert>   /// for assert
+#include <cstdint>   /// for std::uint64_t
+#include <iostream>  /// for IO operations
 #include <vector>    /// for std::vector
+
 /**
  * @namespace dynamic_programming
  * @brief Dynamic Programming algorithms
@@ -44,7 +48,8 @@ namespace dynamic_programming {
 
 /**
  * @namespace Minimum Edit Distance
- * @brief Implementation of [Minimum Edit Distance](https://en.wikipedia.org/wiki/Edit_distance) algorithm
+ * @brief Implementation of [Minimum Edit
+ * Distance](https://en.wikipedia.org/wiki/Edit_distance) algorithm
  */
 
 namespace minimum_edit_distance {
@@ -61,15 +66,14 @@ namespace minimum_edit_distance {
  * @returns z if `z` is the minimum value
  */
 uint64_t min(uint64_t x, uint64_t y, uint64_t z) {
-  if (x <= y && x <= z) {
-    return x; /// returns x, if x is the minimum value
-  }
-  if (y <= x && y <= z) {
-    return y; /// returns y, if y is the minimum value
-  }
-  else {
-    return z; /// returns z if z is the minimum value
-  }
+    if (x <= y && x <= z) {
+        return x;  /// returns x, if x is the minimum value
+    }
+    if (y <= x && y <= z) {
+        return y;  /// returns y, if y is the minimum value
+    } else {
+        return z;  /// returns z if z is the minimum value
+    }
 }
 
 /**
@@ -85,42 +89,48 @@ uint64_t min(uint64_t x, uint64_t y, uint64_t z) {
  * @returns dp[m][n] the minimum cost of operations
  * needed to convert str1 to str2
  */
-uint64_t editDistDP(std::string str1, std::string str2, uint64_t m, uint64_t n) {
-  /// Create a table to store results of subproblems
-  std::vector<std::vector<uint64_t>>dp(m+1, std::vector<uint64_t>(n+1)); /// creasting 2D vector dp to store the results of subproblems
+uint64_t editDistDP(std::string str1, std::string str2, uint64_t m,
+                    uint64_t n) {
+    /// Create a table to store results of subproblems
+    std::vector<std::vector<uint64_t>> dp(
+        m + 1,
+        std::vector<uint64_t>(
+            n +
+            1));  /// creasting 2D vector dp to store the results of subproblems
 
-  /// Fill d[][] in bottom up manner
-  for (uint64_t i = 0; i <= m; i++) {
-    for (uint64_t j = 0; j <= n; j++) {
-      /// If first string is empty, only option is to
-      /// insert all characters of second string
-      if (i == 0) {
-        dp[i][j] = j; /// Minimum operations = j
-      }
+    /// Fill d[][] in bottom up manner
+    for (uint64_t i = 0; i <= m; i++) {
+        for (uint64_t j = 0; j <= n; j++) {
+            /// If first string is empty, only option is to
+            /// insert all characters of second string
+            if (i == 0) {
+                dp[i][j] = j;  /// Minimum operations = j
+            }
 
-      /// If second string is empty, only option is to
-      /// remove all characters of second string
-      else if (j == 0) {
-        dp[i][j] = i; /// Minimum operations = i
-      }
+            /// If second string is empty, only option is to
+            /// remove all characters of second string
+            else if (j == 0) {
+                dp[i][j] = i;  /// Minimum operations = i
+            }
 
-      /// If last characters are same, ignore last char
-      /// and recur for remaining string
-      else if (str1[i - 1] == str2[j - 1]) {
-        dp[i][j] = dp[i - 1][j - 1];
-      }
+            /// If last characters are same, ignore last char
+            /// and recur for remaining string
+            else if (str1[i - 1] == str2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1];
+            }
 
-      /// If the last character is different, consider all
-      /// possibilities and find the minimum
-      else {
-        dp[i][j] = 1 + min(dp[i][j - 1],      // Insert
-                           dp[i - 1][j],      // Remove
-                           dp[i - 1][j - 1]); // Replace
-      }
+            /// If the last character is different, consider all
+            /// possibilities and find the minimum
+            else {
+                dp[i][j] = 1 + min(dp[i][j - 1],       // Insert
+                                   dp[i - 1][j],       // Remove
+                                   dp[i - 1][j - 1]);  // Replace
+            }
+        }
     }
-  }
 
-  return dp[m][n]; /// returning the minimum cost of operations needed to convert str1 to str2
+    return dp[m][n];  /// returning the minimum cost of operations needed to
+                      /// convert str1 to str2
 }
 }  // namespace minimum_edit_distance
 }  // namespace dynamic_programming
@@ -130,25 +140,28 @@ uint64_t editDistDP(std::string str1, std::string str2, uint64_t m, uint64_t n)
  * @returns void
  */
 static void test() {
-  // 1st test
-  std::string str1 = "INTENTION"; // Sample input of 1st string
-  std::string str2 = "EXECUTION"; // Sample input of 2nd string
-  uint64_t expected_output1 = 5; // Expected minimum cost
-  uint64_t output1 = dynamic_programming::minimum_edit_distance::editDistDP(
-      str1, str2, str1.length(), str2.length()); // calling the editDistDP function and storing the result on output1
-  assert(output1 == expected_output1); // comparing the output with the expected output
-  std::cout << "Minimum Number of Operations Required: " << output1
-            << std::endl;
+    // 1st test
+    std::string str1 = "INTENTION";  // Sample input of 1st string
+    std::string str2 = "EXECUTION";  // Sample input of 2nd string
+    uint64_t expected_output1 = 5;   // Expected minimum cost
+    uint64_t output1 = dynamic_programming::minimum_edit_distance::editDistDP(
+        str1, str2, str1.length(),
+        str2.length());  // calling the editDistDP function and storing the
+                         // result on output1
+    assert(output1 ==
+           expected_output1);  // comparing the output with the expected output
+    std::cout << "Minimum Number of Operations Required: " << output1
+              << std::endl;
 
-  // 2nd test
-  std::string str3 = "SATURDAY";
-  std::string str4 = "SUNDAY";
-  uint64_t expected_output2 = 3;
-  uint64_t output2 = dynamic_programming::minimum_edit_distance::editDistDP(
-      str3, str4, str3.length(), str4.length());
-  assert(output2 == expected_output2);
-  std::cout << "Minimum Number of Operations Required: " << output2
-            << std::endl;
+    // 2nd test
+    std::string str3 = "SATURDAY";
+    std::string str4 = "SUNDAY";
+    uint64_t expected_output2 = 3;
+    uint64_t output2 = dynamic_programming::minimum_edit_distance::editDistDP(
+        str3, str4, str3.length(), str4.length());
+    assert(output2 == expected_output2);
+    std::cout << "Minimum Number of Operations Required: " << output2
+              << std::endl;
 }
 
 /**
@@ -158,6 +171,6 @@ static void test() {
  * @returns 0 on exit
  */
 int main(int argc, char *argv[]) {
-  test();  // run self-test implementations
-  return 0;
+    test();  // run self-test implementations
+    return 0;
 }

dynamic_programming/partition_problem.cpp

@@ -28,10 +28,10 @@
  *
  *******************************************************************************/
 #include <cassert>   /// for assert
+#include <cstdint>   /// for std::uint64_t
 #include <iostream>  /// for IO Operations
 #include <numeric>   /// for std::accumulate
 #include <vector>    /// for std::vector
-
 /******************************************************************************
  * @namespace dp
  * @brief Dynamic programming algorithms

operations_on_datastructures/trie_multiple_search.cpp

@@ -1,6 +1,7 @@
 /**
  * @file
- * @brief [Trie datastructure](https://iq.opengenus.org/autocomplete-using-trie-data-structure/)
+ * @brief [Trie
+ * datastructure](https://iq.opengenus.org/autocomplete-using-trie-data-structure/)
  * with search variants
  * @details
  * This provides multiple variants of search functions
@@ -12,6 +13,7 @@
 #include <algorithm>  /// for std::count
 #include <cassert>    /// for assert
 #include <cctype>     /// for tolower
+#include <cstdint>    /// for std::uint32_t
 #include <cstring>    /// for string operations
 #include <iostream>   /// for IO Operations
 #include <queue>      /// for std::priority_queue
@@ -23,7 +25,8 @@
 namespace operations_on_datastructures {
 /**
  * @namespace trie_operations
- * @brief Functions for [Trie datastructure](https://iq.opengenus.org/autocomplete-using-trie-data-structure/)
+ * @brief Functions for [Trie
+ * datastructure](https://iq.opengenus.org/autocomplete-using-trie-data-structure/)
  * implementation
  */
 namespace trie_operations {

range_queries/segtree.cpp

@@ -21,6 +21,7 @@
 
 #include <cassert>   /// for assert
 #include <cmath>     /// for log2
+#include <cstdint>   /// for std::uint64_t
 #include <iostream>  /// for IO operations
 #include <vector>    /// for std::vector