From 6c0f738ea3aeccdc2f3f90a700f03116c8a473ea Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanarlert@users.noreply.github.com>
Date: Wed, 12 Oct 2022 13:03:53 +0530
Subject: [PATCH 01/20] Create maximum_circular_subarray.cpp

---
 others/maximum_circular_subarray.cpp | 52 ++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 others/maximum_circular_subarray.cpp

diff --git a/others/maximum_circular_subarray.cpp b/others/maximum_circular_subarray.cpp
new file mode 100644
index 00000000000..361a3adfa1d
--- /dev/null
+++ b/others/maximum_circular_subarray.cpp
@@ -0,0 +1,52 @@
+// C++ program for maximum contiguous circular sum problem
+#include <iostream>
+using namespace std;
+  
+// The function returns maximum circular contiguous sum in a[]
+
+int maxCircularSum(int a[], int n)
+{
+    // Edge Case
+    if (n == 1)
+        return a[0];
+  
+    // Sum variable which store total sum of the array.
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+        sum += a[i];
+    }
+  
+    // Every variable stores first value of the array.
+    int current_max = a[0], max_so_far = a[0], current_min = a[0], min_so_far = a[0];
+  
+    // Concept of Kadane's Algorithm
+    for (int i = 1; i < n; i++) {
+        // Kadane's Algorithm to find Maximum subarray sum.
+        current_max = max(current_max + a[i], a[i]);
+        max_so_far = max(max_so_far, current_max);
+  
+        // Kadane's Algorithm to find Minimum subarray sum.
+        current_min = min(current_min + a[i], a[i]);
+        min_so_far = min(min_so_far, current_min);
+    }
+  
+    if (min_so_far == sum)
+        return max_so_far;
+  
+    // returning the maximum value
+    return max(max_so_far, sum - min_so_far);
+}
+  
+int main()
+{
+    int size;
+    cout << "Enter size of array: ";
+    cin >> size;
+    int a[size];
+    cout << "Enter the elements of the array: ";
+    for (int i = 0; i < size; i++) {
+      cin >> a[i];
+    }
+    cout << "Maximum circular sum is " << maxCircularSum(a, size) << endl;
+    return 0;
+}

From 52552e37d58920ccc3a6a2bf2f718a366abd7fc5 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanarlert@users.noreply.github.com>
Date: Wed, 12 Oct 2022 13:13:03 +0530
Subject: [PATCH 02/20] Delete maximum_circular_subarray.cpp

---
 others/maximum_circular_subarray.cpp | 52 ----------------------------
 1 file changed, 52 deletions(-)
 delete mode 100644 others/maximum_circular_subarray.cpp

diff --git a/others/maximum_circular_subarray.cpp b/others/maximum_circular_subarray.cpp
deleted file mode 100644
index 361a3adfa1d..00000000000
--- a/others/maximum_circular_subarray.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// C++ program for maximum contiguous circular sum problem
-#include <iostream>
-using namespace std;
-  
-// The function returns maximum circular contiguous sum in a[]
-
-int maxCircularSum(int a[], int n)
-{
-    // Edge Case
-    if (n == 1)
-        return a[0];
-  
-    // Sum variable which store total sum of the array.
-    int sum = 0;
-    for (int i = 0; i < n; i++) {
-        sum += a[i];
-    }
-  
-    // Every variable stores first value of the array.
-    int current_max = a[0], max_so_far = a[0], current_min = a[0], min_so_far = a[0];
-  
-    // Concept of Kadane's Algorithm
-    for (int i = 1; i < n; i++) {
-        // Kadane's Algorithm to find Maximum subarray sum.
-        current_max = max(current_max + a[i], a[i]);
-        max_so_far = max(max_so_far, current_max);
-  
-        // Kadane's Algorithm to find Minimum subarray sum.
-        current_min = min(current_min + a[i], a[i]);
-        min_so_far = min(min_so_far, current_min);
-    }
-  
-    if (min_so_far == sum)
-        return max_so_far;
-  
-    // returning the maximum value
-    return max(max_so_far, sum - min_so_far);
-}
-  
-int main()
-{
-    int size;
-    cout << "Enter size of array: ";
-    cin >> size;
-    int a[size];
-    cout << "Enter the elements of the array: ";
-    for (int i = 0; i < size; i++) {
-      cin >> a[i];
-    }
-    cout << "Maximum circular sum is " << maxCircularSum(a, size) << endl;
-    return 0;
-}

From c1f188838be6f37b98fd9dcddd2b6823acb2f8ac Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanarlert@users.noreply.github.com>
Date: Wed, 12 Oct 2022 13:13:35 +0530
Subject: [PATCH 03/20] Create maximum_circular_subarray.cpp

---
 .../maximum_circular_subarray.cpp             | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 dynamic_programming/maximum_circular_subarray.cpp

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
new file mode 100644
index 00000000000..361a3adfa1d
--- /dev/null
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -0,0 +1,52 @@
+// C++ program for maximum contiguous circular sum problem
+#include <iostream>
+using namespace std;
+  
+// The function returns maximum circular contiguous sum in a[]
+
+int maxCircularSum(int a[], int n)
+{
+    // Edge Case
+    if (n == 1)
+        return a[0];
+  
+    // Sum variable which store total sum of the array.
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+        sum += a[i];
+    }
+  
+    // Every variable stores first value of the array.
+    int current_max = a[0], max_so_far = a[0], current_min = a[0], min_so_far = a[0];
+  
+    // Concept of Kadane's Algorithm
+    for (int i = 1; i < n; i++) {
+        // Kadane's Algorithm to find Maximum subarray sum.
+        current_max = max(current_max + a[i], a[i]);
+        max_so_far = max(max_so_far, current_max);
+  
+        // Kadane's Algorithm to find Minimum subarray sum.
+        current_min = min(current_min + a[i], a[i]);
+        min_so_far = min(min_so_far, current_min);
+    }
+  
+    if (min_so_far == sum)
+        return max_so_far;
+  
+    // returning the maximum value
+    return max(max_so_far, sum - min_so_far);
+}
+  
+int main()
+{
+    int size;
+    cout << "Enter size of array: ";
+    cin >> size;
+    int a[size];
+    cout << "Enter the elements of the array: ";
+    for (int i = 0; i < size; i++) {
+      cin >> a[i];
+    }
+    cout << "Maximum circular sum is " << maxCircularSum(a, size) << endl;
+    return 0;
+}

From 6a2f1bcaecc1a34a1d4304f8973d3587e0ec47c6 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanarlert@users.noreply.github.com>
Date: Thu, 13 Oct 2022 13:37:59 +0530
Subject: [PATCH 04/20] Update maximum_circular_subarray.cpp

Used the template provided.
---
 .../maximum_circular_subarray.cpp             | 51 ++++++++++++-------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 361a3adfa1d..e8ba94c9193 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -1,8 +1,15 @@
-// C++ program for maximum contiguous circular sum problem
+/**
+* @file
+* @brief C++ program for maximum contiguous circular sum problem using Kadane's Algorithm [https://en.wikipedia.org/wiki/Maximum_subarray_problem]
+* @details
+* The idea is to modify Kadane’s algorithm to find a minimum contiguous subarray sum and the maximum contiguous subarray sum,
+* then check for the maximum value between the max_value and the value left after subtracting min_value from the total sum.
+* Geeks For Geeks link [https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/]
+*/
+
+#include <cassert>   
 #include <iostream>
-using namespace std;
-  
-// The function returns maximum circular contiguous sum in a[]
+using namespace std;  
 
 int maxCircularSum(int a[], int n)
 {
@@ -36,17 +43,27 @@ int maxCircularSum(int a[], int n)
     // returning the maximum value
     return max(max_so_far, sum - min_so_far);
 }
-  
-int main()
-{
-    int size;
-    cout << "Enter size of array: ";
-    cin >> size;
-    int a[size];
-    cout << "Enter the elements of the array: ";
-    for (int i = 0; i < size; i++) {
-      cin >> a[i];
-    }
-    cout << "Maximum circular sum is " << maxCircularSum(a, size) << endl;
-    return 0;
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    // description of the test
+    // Input: arr[] = {8, -8, 9, -9, 10, -11, 12}
+    // Output: 22 
+    // Explanation: Subarray 12, 8, -8, 9, -9, 10 gives the maximum sum, that is 22.
+
+    int n = 7; // size of the array
+    int arr[7] = {8, -8, 9, -9, 10, -11, 12}; 
+    assert(maxCircularSum(arr, n) == 22); // this ensures that the algorithm works as expected
+
+    int arrr[7] = {8, -8, 10, -9, 10, -11, 12};
+    assert(maxCircularSum(arrr, n) == 23);
+}
+
+
+int main(int argc, char *argv[]) {
+     test();  // run self-test implementations
+     return 0;
 }

From e16f39b1cb9dbcc940410f106e169bcc21e09854 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions@users.noreply.github.com>
Date: Fri, 30 Dec 2022 06:19:21 +0000
Subject: [PATCH 05/20] updating DIRECTORY.md

---
 DIRECTORY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index c613222efb5..110bf02dc64 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -104,6 +104,7 @@
   * [Longest Increasing Subsequence (Nlogn)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp)
   * [Longest Palindromic Subsequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/longest_palindromic_subsequence.cpp)
   * [Matrix Chain Multiplication](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/matrix_chain_multiplication.cpp)
+  * [Maximum Circular Subarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/maximum_circular_subarray.cpp)
   * [Minimum Edit Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/minimum_edit_distance.cpp)
   * [Palindrome Partitioning](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/palindrome_partitioning.cpp)
   * [Partition Problem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/partition_problem.cpp)

From 4d8fb501f8e58587055698f4761bc7b41a32a314 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Fri, 30 Dec 2022 11:50:41 +0530
Subject: [PATCH 06/20] Update maximum_circular_subarray.cpp

---
 dynamic_programming/maximum_circular_subarray.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index e8ba94c9193..e491d57023b 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -7,8 +7,8 @@
 * Geeks For Geeks link [https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/]
 */
 
-#include <cassert>   
-#include <iostream>
+#include <cassert>   /// for assert
+#include <iostream>   /// for IO stream    
 using namespace std;  
 
 int maxCircularSum(int a[], int n)

From ed65ca0d010603e8d04ef1d06013875f51480fc2 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Fri, 30 Dec 2022 11:51:33 +0530
Subject: [PATCH 07/20] Update maximum_circular_subarray.cpp

---
 dynamic_programming/maximum_circular_subarray.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index e491d57023b..77ca7663e78 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -8,7 +8,7 @@
 */
 
 #include <cassert>   /// for assert
-#include <iostream>   /// for IO stream    
+#include <iostream>   /// for IO operations    
 using namespace std;  
 
 int maxCircularSum(int a[], int n)

From 988b2add428d74ca52564212d91db246a8fd2867 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Fri, 30 Dec 2022 11:58:06 +0530
Subject: [PATCH 08/20] Update maximum_circular_subarray.cpp

---
 dynamic_programming/maximum_circular_subarray.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 77ca7663e78..25f30470720 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -1,10 +1,10 @@
 /**
 * @file
-* @brief C++ program for maximum contiguous circular sum problem using Kadane's Algorithm [https://en.wikipedia.org/wiki/Maximum_subarray_problem]
+* @brief C++ program for maximum contiguous circular sum problem using [Kadane's Algorithm](https://en.wikipedia.org/wiki/Maximum_subarray_problem)
 * @details
 * The idea is to modify Kadane’s algorithm to find a minimum contiguous subarray sum and the maximum contiguous subarray sum,
 * then check for the maximum value between the max_value and the value left after subtracting min_value from the total sum.
-* Geeks For Geeks link [https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/]
+* [Geeks For Geeks](https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/)
 */
 
 #include <cassert>   /// for assert

From ba15ee66eaf9a357cace1212f03a829b4b6e9f1a Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Fri, 30 Dec 2022 12:50:54 +0530
Subject: [PATCH 09/20] Update maximum_circular_subarray.cpp

---
 dynamic_programming/maximum_circular_subarray.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 25f30470720..c0a78c433ca 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -7,9 +7,8 @@
 * [Geeks For Geeks](https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/)
 */
 
-#include <cassert>   /// for assert
-#include <iostream>   /// for IO operations    
-using namespace std;  
+#include <cassert>   // for assert
+#include <iostream>   // for IO operations
 
 int maxCircularSum(int a[], int n)
 {
@@ -29,19 +28,19 @@ int maxCircularSum(int a[], int n)
     // Concept of Kadane's Algorithm
     for (int i = 1; i < n; i++) {
         // Kadane's Algorithm to find Maximum subarray sum.
-        current_max = max(current_max + a[i], a[i]);
-        max_so_far = max(max_so_far, current_max);
+        current_max = std::max(current_max + a[i], a[i]);
+        max_so_far = std::max(max_so_far, current_max);
   
         // Kadane's Algorithm to find Minimum subarray sum.
-        current_min = min(current_min + a[i], a[i]);
-        min_so_far = min(min_so_far, current_min);
+        current_min = std::min(current_min + a[i], a[i]);
+        min_so_far = std::min(min_so_far, current_min);
     }
   
     if (min_so_far == sum)
         return max_so_far;
   
     // returning the maximum value
-    return max(max_so_far, sum - min_so_far);
+    return std::max(max_so_far, sum - min_so_far);
 }
 
 /**

From c2cddfedbd1b75f3aa2cee8f4681da12549b5a66 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Sun, 1 Jan 2023 22:14:08 +0530
Subject: [PATCH 10/20] Update maximum_circular_subarray.cpp

---
 .../maximum_circular_subarray.cpp             | 38 ++++++++++++-------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index c0a78c433ca..b1a6deb6b71 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -9,30 +9,40 @@
 
 #include <cassert>   // for assert
 #include <iostream>   // for IO operations
+#include <vector>   // for vectors    
+// using namespace std;  
 
-int maxCircularSum(int a[], int n)
+
+/**
+ * @brief returns the maximum contiguous circular sum of an array
+ * 
+ * @param a is the array
+ * @param n is the size of the array
+ * @return int which is the maximum sum
+ */
+int maxCircularSum(std::vector<int>& arr)
 {
     // Edge Case
-    if (n == 1)
-        return a[0];
+    if (arr.size() == 1)
+        return arr[0];
   
-    // Sum variable which store total sum of the array.
+    // Sum variable which stores total sum of the array.
     int sum = 0;
-    for (int i = 0; i < n; i++) {
-        sum += a[i];
+    for (int i = 0; i < arr.size(); i++) {
+        sum += arr[i];
     }
   
     // Every variable stores first value of the array.
-    int current_max = a[0], max_so_far = a[0], current_min = a[0], min_so_far = a[0];
+    int current_max = arr[0], max_so_far = arr[0], current_min = arr[0], min_so_far = arr[0];
   
     // Concept of Kadane's Algorithm
-    for (int i = 1; i < n; i++) {
+    for (int i = 1; i < arr.size(); i++) {
         // Kadane's Algorithm to find Maximum subarray sum.
-        current_max = std::max(current_max + a[i], a[i]);
+        current_max = std::max(current_max + arr[i], arr[i]);
         max_so_far = std::max(max_so_far, current_max);
   
         // Kadane's Algorithm to find Minimum subarray sum.
-        current_min = std::min(current_min + a[i], a[i]);
+        current_min = std::min(current_min + arr[i], arr[i]);
         min_so_far = std::min(min_so_far, current_min);
     }
   
@@ -54,11 +64,11 @@ static void test() {
     // Explanation: Subarray 12, 8, -8, 9, -9, 10 gives the maximum sum, that is 22.
 
     int n = 7; // size of the array
-    int arr[7] = {8, -8, 9, -9, 10, -11, 12}; 
-    assert(maxCircularSum(arr, n) == 22); // this ensures that the algorithm works as expected
+    std::vector<int> arr = {8, -8, 9, -9, 10, -11, 12}; 
+    assert(maxCircularSum(arr) == 22); // this ensures that the algorithm works as expected
 
-    int arrr[7] = {8, -8, 10, -9, 10, -11, 12};
-    assert(maxCircularSum(arrr, n) == 23);
+    std::vector<int> arrr = {8, -8, 10, -9, 10, -11, 12};
+    assert(maxCircularSum(arrr) == 23);
 }
 
 

From f00e9b2cc0eedf6a21517ec9f66fdf0b3d80784c Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:30:08 +0530
Subject: [PATCH 11/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index b1a6deb6b71..33e7b98e95a 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -7,10 +7,9 @@
 * [Geeks For Geeks](https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/)
 */
 
-#include <cassert>   // for assert
-#include <iostream>   // for IO operations
-#include <vector>   // for vectors    
-// using namespace std;  
+#include <cassert>     /// for assert
+#include <iostream>   /// for IO operations
+#include <vector>     /// for std::vector
 
 
 /**

From b3a9ac45090ba4da4102e9bd4e3be54dedf15993 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:31:10 +0530
Subject: [PATCH 12/20] Update maximum_circular_subarray.cpp

---
 dynamic_programming/maximum_circular_subarray.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 33e7b98e95a..789636c42ae 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -15,8 +15,7 @@
 /**
  * @brief returns the maximum contiguous circular sum of an array
  * 
- * @param a is the array
- * @param n is the size of the array
+ * @param arr is the array/vector
  * @return int which is the maximum sum
  */
 int maxCircularSum(std::vector<int>& arr)

From 658fed4c7ce845ab91ce94820af64fd2a8fdb564 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:32:07 +0530
Subject: [PATCH 13/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 789636c42ae..08f5d4c3d89 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -12,6 +12,11 @@
 #include <vector>     /// for std::vector
 
 
+/**
+ * @namespace dynamic_programming
+ * @brief Dynamic Programming algorithms
+ */
+namespace dynamic_programming {
 /**
  * @brief returns the maximum contiguous circular sum of an array
  * 

From 441d678cf9c2ef3e7b4404a2bf3e528e560b8423 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:32:17 +0530
Subject: [PATCH 14/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 08f5d4c3d89..4bf095413d3 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -55,6 +55,7 @@ int maxCircularSum(std::vector<int>& arr)
     // returning the maximum value
     return std::max(max_so_far, sum - min_so_far);
 }
+}  // namespace dynamic_programming
 
 /**
  * @brief Self-test implementations

From 696aa9601dddaa7dd62a2aac6ea0c2584ebf6141 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:32:42 +0530
Subject: [PATCH 15/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 4bf095413d3..b9e3fb58191 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -69,7 +69,7 @@ static void test() {
 
     int n = 7; // size of the array
     std::vector<int> arr = {8, -8, 9, -9, 10, -11, 12}; 
-    assert(maxCircularSum(arr) == 22); // this ensures that the algorithm works as expected
+    assert(dynamic_programming::maxCircularSum(arr) == 22); // this ensures that the algorithm works as expected
 
     std::vector<int> arrr = {8, -8, 10, -9, 10, -11, 12};
     assert(maxCircularSum(arrr) == 23);

From 78643d8a23e8dca936214432d77b60a88bb3b6c4 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:32:54 +0530
Subject: [PATCH 16/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index b9e3fb58191..24c972bb4d1 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -71,8 +71,8 @@ static void test() {
     std::vector<int> arr = {8, -8, 9, -9, 10, -11, 12}; 
     assert(dynamic_programming::maxCircularSum(arr) == 22); // this ensures that the algorithm works as expected
 
-    std::vector<int> arrr = {8, -8, 10, -9, 10, -11, 12};
-    assert(maxCircularSum(arrr) == 23);
+    arr = {8, -8, 10, -9, 10, -11, 12};
+    assert(dynamic_programming::maxCircularSum(arr) == 23);
 }
 
 

From b26f54d1e26359e3520c6c68f1c15e06318c38df Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Mon, 2 Jan 2023 08:33:07 +0530
Subject: [PATCH 17/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 24c972bb4d1..1c2b9196c0f 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -76,6 +76,12 @@ static void test() {
 }
 
 
+/**
+ * @brief Main function
+ * @param argc commandline argument count (ignored)
+ * @param argv commandline array of arguments (ignored)
+ * @returns 0 on exit
+ */
 int main(int argc, char *argv[]) {
      test();  // run self-test implementations
      return 0;

From ddf6da4550ca54c3bb1174b949870e6b2c3c1ff5 Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Wed, 18 Jan 2023 16:17:06 +0530
Subject: [PATCH 18/20] Update
 dynamic_programming/maximum_circular_subarray.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>
---
 dynamic_programming/maximum_circular_subarray.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 1c2b9196c0f..3942bbabefe 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -73,6 +73,8 @@ static void test() {
 
     arr = {8, -8, 10, -9, 10, -11, 12};
     assert(dynamic_programming::maxCircularSum(arr) == 23);
+
+    std::cout << "All tests have successfully passed!\n";
 }
 
 

From 3b8debe705d28b69051cda7863162496e969d9df Mon Sep 17 00:00:00 2001
From: Suman Mondal <94859440+sumanbmondal@users.noreply.github.com>
Date: Wed, 18 Jan 2023 16:21:06 +0530
Subject: [PATCH 19/20] Update maximum_circular_subarray.cpp

Fixed the comments according to @krishnacx
---
 dynamic_programming/maximum_circular_subarray.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index 3942bbabefe..a83025ba251 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -52,17 +52,17 @@ int maxCircularSum(std::vector<int>& arr)
     if (min_so_far == sum)
         return max_so_far;
   
-    // returning the maximum value
+    // Return the maximum value
     return std::max(max_so_far, sum - min_so_far);
 }
 }  // namespace dynamic_programming
 
 /**
- * @brief Self-test implementations
+ * @brief Self-test implementation
  * @returns void
  */
 static void test() {
-    // description of the test
+    // Description of the test
     // Input: arr[] = {8, -8, 9, -9, 10, -11, 12}
     // Output: 22 
     // Explanation: Subarray 12, 8, -8, 9, -9, 10 gives the maximum sum, that is 22.

From d02d745da03f71c6e66f367f6cc54580fa7db0f9 Mon Sep 17 00:00:00 2001
From: David Leal <halfpacho@gmail.com>
Date: Thu, 26 Jan 2023 00:06:15 -0600
Subject: [PATCH 20/20] chore: apply suggestions from code review

---
 dynamic_programming/maximum_circular_subarray.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
index a83025ba251..d32ac64e9b8 100644
--- a/dynamic_programming/maximum_circular_subarray.cpp
+++ b/dynamic_programming/maximum_circular_subarray.cpp
@@ -4,7 +4,7 @@
 * @details
 * The idea is to modify Kadane’s algorithm to find a minimum contiguous subarray sum and the maximum contiguous subarray sum,
 * then check for the maximum value between the max_value and the value left after subtracting min_value from the total sum.
-* [Geeks For Geeks](https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/)
+* For more information, check [Geeks For Geeks](https://www.geeksforgeeks.org/maximum-contiguous-circular-sum/) explanation page.
 */
 
 #include <cassert>     /// for assert