feat: update to CXX standard 17 and add CMakeLists file to directories without them

.gitignore

@@ -34,5 +34,9 @@ a.out
 *.out
 *.app
 
+# Cache
+.cache/
+
+# Build
 build/
 git_diff.txt

CMakeLists.txt

@@ -5,16 +5,17 @@ project(Algorithms_in_C++
     DESCRIPTION "Set of algorithms implemented in C++."
 )
 
-# set(CMAKE_CXX_CPPLINT "~/anaconda3/bin/cpplint --filter=-legal/copyright --std=c++11")
-# find_program(CLANG_FORMAT "clang-format")
-
-set(CMAKE_CXX_STANDARD 11)
+# C++ standard
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# Additional warnings and errors
 if(MSVC)
-    # set(CMAKE_CXX_STANDARD 14)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
-endif(MSVC)
+    add_compile_options(/W4 /permissive-)
+else()
+    add_compile_options(-Wall -Wextra -Wno-register -Werror=vla)
+endif()
 
 option(USE_OPENMP "flag to use OpenMP for multithreading" ON)
 if(USE_OPENMP)
@@ -38,6 +39,10 @@ add_subdirectory(graphics)
 add_subdirectory(probability)
 add_subdirectory(backtracking)
 add_subdirectory(bit_manipulation)
+add_subdirectory(dynamic_programming)
+add_subdirectory(greedy_algorithms)
+add_subdirectory(range_queries)
+add_subdirectory(operations_on_datastructures)
 add_subdirectory(data_structures)
 add_subdirectory(machine_learning)
 add_subdirectory(numerical_methods)

README.md

@@ -22,7 +22,7 @@ This repository is a collection of open-source implementation of a variety of al
 * Well documented source code with detailed explanations provide a valuable resource for educators and students alike.
 * Each source code is atomic using [STL classes](https://en.wikipedia.org/wiki/Standard_Template_Library) and _no external libraries_ are required for their compilation and execution. Thus, the fundamentals of the algorithms can be studied in much depth.
 * Source codes are [compiled and tested](https://github.com/TheAlgorithms/C-Plus-Plus/actions?query=workflow%3A%22Awesome+CI+Workflow%22) for every commit on the latest versions of three major operating systems viz., Windows, MacOS, and Ubuntu (Linux) using MSVC 19 2022, AppleClang 14.0.0, and GNU 11.3.0 respectively. 
-* Strict adherence to [C++11](https://en.wikipedia.org/wiki/C%2B%2B11) standard ensures portability of code to embedded systems as well like ESP32, ARM Cortex, etc. with little to no changes.
+* Strict adherence to [C++17](https://en.wikipedia.org/wiki/C%2B%2B17) standard ensures portability of code to embedded systems as well like [ESP32](https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/cplusplus.html#c-language-standard), [ARM Cortex](https://developer.arm.com/documentation/101458/2404/Standards-support/Supported-C-C---standards-in-Arm-C-C---Compiler), etc. with little to no changes.
 * Self-checks within programs ensure correct implementations with confidence.
 * Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
 

dynamic_programming/CMakeLists.txt

@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/dynamic_programming")
+
+endforeach( testsourcefile ${APP_SOURCES} )

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/bellman_ford.cpp

@@ -1,5 +1,6 @@
-#include <limits.h>
+#include <climits>
 #include <iostream>
+#include <vector>
 
 using namespace std;
 
@@ -13,13 +14,13 @@ class Edge {
 class Graph {
  public:
     int vertexNum, edgeNum;
-    Edge *edges;
+    std::vector<Edge> edges;
 
     // Constructs a graph with V vertices and E edges
     Graph(int V, int E) {
         this->vertexNum = V;
         this->edgeNum = E;
-        this->edges = (Edge *)malloc(E * sizeof(Edge));
+        this->edges.reserve(E);
     }
 
     // Adds the given edge to the graph
@@ -36,7 +37,7 @@ class Graph {
 };
 
 // Utility function to print distances
-void print(int dist[], int V) {
+void print(const std::vector<int>& dist, int V) {
     cout << "\nVertex  Distance" << endl;
     for (int i = 0; i < V; i++) {
         if (dist[i] != INT_MAX)
@@ -52,7 +53,8 @@ void print(int dist[], int V) {
 void BellmanFord(Graph graph, int src) {
     int V = graph.vertexNum;
     int E = graph.edgeNum;
-    int dist[V];
+    std::vector<int> dist;
+    dist.reserve(E);
 
     // Initialize distances array as INF for all except source
     // Intialize source as zero

dynamic_programming/catalan_numbers.cpp

@@ -9,11 +9,12 @@
     https://oeis.org/A000108/
  */
 
-#include <cassert>  /// for assert
-#include <cstdint>  /// for std::uint64_t
-#include <cstdlib>  /// for std::size_t
-#include <numeric>  /// for std::transform_reduce
-#include <vector>   /// for std::vector
+#include <cassert>     /// for assert
+#include <cstdint>     /// for std::uint64_t
+#include <cstdlib>     /// for std::size_t
+#include <functional>  /// for std::plus & std::multiplies
+#include <numeric>     /// for std::transform_reduce
+#include <vector>      /// for std::vector
 
 /**
  * @brief computes and caches Catalan numbers
@@ -24,7 +25,7 @@ class catalan_numbers {
 
     value_type compute_next() {
         return std::transform_reduce(known.begin(), known.end(), known.rbegin(),
-                                     static_cast<value_type>(), std::plus<>(),
+                                     static_cast<value_type>(0), std::plus<>(),
                                      std::multiplies<>());
     }
 

dynamic_programming/coin_change.cpp

@@ -1,11 +1,12 @@
 #include <climits>
 #include <iostream>
+#include <vector>
 using namespace std;
 
 // Function to find the Minimum number of coins required to get Sum S
 int findMinCoins(int arr[], int n, int N) {
     // dp[i] = no of coins required to get a total of i
-    int dp[N + 1];
+    std::vector<int> dp(N + 1);
 
     // 0 coins are needed for 0 sum
 

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/edit_distance.cpp

@@ -13,6 +13,7 @@
 
 #include <iostream>
 #include <string>
+#include <vector>
 using namespace std;
 
 int min(int x, int y, int z) { return min(min(x, y), z); }
@@ -46,7 +47,7 @@ int editDist(string str1, string str2, int m, int n) {
  */
 int editDistDP(string str1, string str2, int m, int n) {
     // Create Table for SubProblems
-    int dp[m + 1][n + 1];
+    std::vector<std::vector<int> > dp(m + 1, std::vector<int>(n + 1));
 
     // Fill d[][] in bottom up manner
     for (int i = 0; i <= m; i++) {

dynamic_programming/egg_dropping_puzzle.cpp

@@ -4,10 +4,13 @@
 
 #include <climits>
 #include <iostream>
+#include <vector>
+
 using namespace std;
 
 int eggDrop(int n, int k) {
-    int eggFloor[n + 1][k + 1];
+    std::vector<std::vector<int> > eggFloor(n + 1, std::vector<int>(k + 1));
+
     int result;
 
     for (int i = 1; i <= n; i++) {

dynamic_programming/floyd_warshall.cpp

@@ -1,6 +1,7 @@
 #include <climits>
+#include <cstddef>
 #include <iostream>
-#include <string>
+#include <vector>
 
 using std::cin;
 using std::cout;
@@ -24,7 +25,9 @@ class Graph {
     }
 
     ~Graph() {
-        for (int i = 0; i < vertexNum; i++) delete[] edges[i];
+        for (int i = 0; i < vertexNum; i++) {
+            delete[] edges[i];
+        }
         delete[] edges;
     }
 
@@ -35,7 +38,7 @@ class Graph {
 };
 
 // Utility function to print distances
-void print(int dist[], int V) {
+void print(const std::vector<int>& dist, int V) {
     cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
     for (int i = 0; i < V; i++) {
         for (int j = 0; j < V; j++) {
@@ -52,8 +55,8 @@ void print(int dist[], int V) {
 // The main function that finds the shortest path from a vertex
 // to all other vertices using Floyd-Warshall Algorithm.
 void FloydWarshall(Graph graph) {
-    int V = graph.vertexNum;
-    int dist[V][V];
+    std::size_t V = graph.vertexNum;
+    std::vector<std::vector<int> > dist(V, std::vector<int>(V));
 
     // Initialise distance array
     for (int i = 0; i < V; i++)
@@ -76,7 +79,7 @@ void FloydWarshall(Graph graph) {
                     dist[i][j] = dist[i][k] + dist[k][j];
 
     // Convert 2d array to 1d array for print
-    int dist1d[V * V];
+    std::vector<int> dist1d(V * V);
     for (int i = 0; i < V; i++)
         for (int j = 0; j < V; j++) dist1d[i * V + j] = dist[i][j];
 

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/kadane.cpp

@@ -1,29 +1,74 @@
+/**
+ * @file
+ * @brief Implementation of [Kadane
+ * Algorithm](https://en.wikipedia.org/wiki/Kadane%27s_algorithm)
+ *
+ * @details
+ * Kadane algorithm is used to find the maximum sum subarray in an array and
+ * maximum sum subarray problem is the task of finding a contiguous subarray
+ * with the largest sum
+ *
+ * ### Algorithm
+ * The simple idea of the algorithm is to search for all positive
+ * contiguous segments of the array and keep track of maximum sum contiguous
+ * segment among all positive segments(curr_sum is used for this)
+ * Each time we get a positive sum we compare it with max_sum and update max_sum
+ * if it is greater than curr_sum
+ *
+ * @author [Ayush Singh](https://github.com/ayush523)
+ */
+#include <array>
 #include <climits>
 #include <iostream>
-
-int maxSubArraySum(int a[], int size) {
-    int max_so_far = INT_MIN, max_ending_here = 0;
-
-    for (int i = 0; i < size; i++) {
-        max_ending_here = max_ending_here + a[i];
-        if (max_so_far < max_ending_here)
-            max_so_far = max_ending_here;
-
-        if (max_ending_here < 0)
-            max_ending_here = 0;
+/**
+ * @namespace dynamic_programming
+ * @brief Dynamic Programming algorithms
+ */
+namespace dynamic_programming {
+/**
+ * @namespace kadane
+ * @brief Functions for
+ * [Kadane](https://en.wikipedia.org/wiki/Kadane%27s_algorithm) algorithm.
+ */
+namespace kadane {
+/**
+ * @brief maxSubArray function is used to calculate the maximum sum subarray
+ * and returns the value of maximum sum which is stored in the variable max_sum
+ * @tparam N number of array size
+ * @param n array where numbers are saved
+ * @returns the value of maximum subarray sum
+ */
+template <size_t N>
+int maxSubArray(const std::array<int, N> &n) {
+    int curr_sum =
+        0;  // declaring a variable named as curr_sum and initialized it to 0
+    int max_sum = INT_MIN;  // Initialized max_sum to INT_MIN
+    for (int i : n) {  // for loop to iterate over the elements of the array
+        curr_sum += n[i];
+        max_sum = std::max(max_sum, curr_sum);  // getting the maximum value
+        curr_sum = std::max(curr_sum, 0);  // updating the value of curr_sum
     }
-    return max_so_far;
+    return max_sum;  // returning the value of max_sum
 }
+}  // namespace kadane
+}  // namespace dynamic_programming
 
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
 int main() {
-    int n, i;
-    std::cout << "Enter the number of elements \n";
-    std::cin >> n;
-    int a[n];  // NOLINT
-    for (i = 0; i < n; i++) {
-        std::cin >> a[i];
+    const int N = 5;
+    std::array<int, N> n{};  // declaring array
+                             // taking values of elements from user
+    for (int i = 0; i < n.size(); i++) {
+        std::cout << "Enter value of n[" << i << "]"
+                  << "\n";
+        std::cin >> n[i];
     }
-    int max_sum = maxSubArraySum(a, n);
-    std::cout << "Maximum contiguous sum is " << max_sum;
+    int max_sum = dynamic_programming::kadane::maxSubArray<N>(
+        n);  // calling maxSubArray function
+    std::cout << "Maximum subarray sum is " << max_sum;  // Printing the answer
+
     return 0;
 }