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)
+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/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/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 <iostream>
 #include <string>
+#include <vector>
 
 using std::cin;
 using std::cout;
@@ -24,7 +25,9 @@
     }
 
     ~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 @@
 };
 
 // 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++) {
@@ -53,7 +56,7 @@
 // to all other vertices using Floyd-Warshall Algorithm.
 void FloydWarshall(Graph graph) {
     int V = graph.vertexNum;
-    int dist[V][V];
+    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 @@
                     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/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;
 }