changes made

Author: giuseppe-coco

backtracking/generate_parentheses.cpp

@@ -1,63 +1,80 @@
 /**
  * @file
  * @brief Generates all combinations of well-formed parentheses.
+ * [Generate
+ Parentheses](https://leetcode.com/explore/interview/card/top-interview-questions-medium/109/backtracking/794/)
  *
  * @details a sequence of parentheses is well-formed if each opening parentheses
- has a corresponding closing parenthesis
- *  and the closing parentheses are correctly ordered
+ * has a corresponding closing parenthesis
+ * and the closing parentheses are correctly ordered
  *
  * @author [Giuseppe Coco](https://github.com/WoWS17)
 
  */
 
-#include <cassert>
-#include <iostream>
-#include <vector>
+#include <cassert>   /// for assert
+#include <iostream>  /// for I/O operation
+#include <vector>    /// for vector container
 
+/**
+ * @brief Backtracking algorithms
+ * @namespace backtracking
+ */
+namespace backtracking {
+/**
+ * @brief generate_parentheses class
+ * @namespace generate_parentheses
+ */
 class generate_parentheses {
  private:
-    std::vector<std::string> res;  // Contains all possible valid patterns
-
-    /**
-     * @brief function that implements backtracking
-     *
-     * @param str string build during backtracking
-     * @param n number of pairs of parentheses
-     * @param closed number of closed parentheses
-     * @param open number of open parentheses
-     */
-
-    void makeStrings(std::string str, int n, int closed, int open) {
-        if (closed > open)  // We can never have more closed than open
-            return;
-
-        if (str.length() == 2 * n and
-            closed != open)  // closed and open must be the same
-            return;
-
-        if (str.length() == 2 * n) {
-            res.push_back(str);
-            return;
-        }
-
-        makeStrings(str + ')', n, closed + 1, open);
-        makeStrings(str + '(', n, closed, open + 1);
-    }
+    std::vector<std::string> res;  ///< Contains all possible valid patterns
+
+    void makeStrings(std::string str, int n, int closed, int open);
 
  public:
-    /**
-     * @brief wrapper interface
-     *
-     * @param n number of pairs of parentheses
-     * @return all well-formed pattern of parentheses
-     */
-    std::vector<std::string> generate_parenthesis(int n) {
-        res.clear();
-        std::string str = "(";
-        makeStrings(str, n, 0, 1);
-        return res;
-    }
+    std::vector<std::string> generate(int n);
 };
+}  // namespace backtracking
+
+/**
+ * @brief function that implements backtracking
+ *
+ * @param str string build during backtracking
+ * @param n number of pairs of parentheses
+ * @param closed number of closed parentheses
+ * @param open number of open parentheses
+ */
+
+void backtracking::generate_parentheses::makeStrings(std::string str, int n,
+                                                     int closed, int open) {
+    if (closed > open)  // We can never have more closed than open
+        return;
+
+    if (str.length() == 2 * n and
+        closed != open)  // closed and open must be the same
+        return;
+
+    if (str.length() == 2 * n) {
+        res.push_back(str);
+        return;
+    }
+
+    makeStrings(str + ')', n, closed + 1, open);
+    makeStrings(str + '(', n, closed, open + 1);
+}
+
+/**
+ * @brief wrapper interface
+ *
+ * @param n number of pairs of parentheses
+ * @return all well-formed pattern of parentheses
+ */
+std::vector<std::string> backtracking::generate_parentheses::generate(int n) {
+    backtracking::generate_parentheses::res.clear();
+    std::string str = "(";
+    backtracking::generate_parentheses::makeStrings(str, n, 0, 1);
+    return res;
+}
 
 /**
  * @brief Self-test implementations
@@ -66,23 +83,23 @@ class generate_parentheses {
 static void test() {
     int n;
     std::vector<std::string> patterns;
-    generate_parentheses p;
+    backtracking::generate_parentheses p;
 
     n = 1;
     patterns = {{"()"}};
-    assert(p.generate_parenthesis(n) == patterns);
+    assert(p.generate(n) == patterns);
 
     n = 3;
     patterns = {{"()()()"}, {"()(())"}, {"(())()"}, {"(()())"}, {"((()))"}};
 
-    assert(p.generate_parenthesis(n) == patterns);
+    assert(p.generate(n) == patterns);
 
     n = 4;
     patterns = {{"()()()()"}, {"()()(())"}, {"()(())()"}, {"()(()())"},
                 {"()((()))"}, {"(())()()"}, {"(())(())"}, {"(()())()"},
                 {"(()()())"}, {"(()(()))"}, {"((()))()"}, {"((())())"},
                 {"((()()))"}, {"(((())))"}};
-    assert(p.generate_parenthesis(n) == patterns);
+    assert(p.generate(n) == patterns);
 
     std::cout << "All tests passed\n";
 }
@@ -94,4 +111,4 @@ static void test() {
 int main() {
     test();
     return 0;
-}
+}