22. Generate Parentheses

public class Solution {
        private IList<string> result = new List<string>();
        public IList<string> GenerateParenthesis(int n)
        {
            Helper(new StringBuilder(), n, n);
            return result;
        }
        private void Helper(StringBuilder cur, int l, int r)
        {
            if (r == 0)
                result.Add(cur.ToString());
            else
            {
                if (l == r)
                {
                    cur.Append('(');
                    Helper(cur, l - 1, r);
                    cur.Remove(cur.Length - 1, 1);
                }
                else
                {
                    if (l > 0)
                    {
                        cur.Append('(');
                        Helper(cur, l - 1, r);
                        cur.Remove(cur.Length - 1, 1);
                    }
                    if (r > 0)
                    {
                        cur.Append(')');
                        Helper(cur, l, r - 1);
                        cur.Remove(cur.Length - 1, 1);
                    }
                }
            }
        }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
        private vector<string> result = new List<string>();
        public vector<string> GenerateParenthesis(int n)
        {
            Helper(new StringBuilder(), n, n);
            return result;
        }
        private void Helper(StringBuilder cur, int l, int r)
        {
            if (r == 0)
                result.push_back(cur.ToString());
            else
            {
                if (l == r)
                {
                    cur.Append('(');
                    Helper(cur, l - 1, r);
                    cur.Remove(cur.size() - 1, 1);
                }
                else
                {
                    if (l > 0)
                    {
                        cur.Append('(');
                        Helper(cur, l - 1, r);
                        cur.Remove(cur.size() - 1, 1);
                    }
                    if (r > 0)
                    {
                        cur.Append(')');
                        Helper(cur, l, r - 1);
                        cur.Remove(cur.size() - 1, 1);
                    }
                }
            }
        }
}

public List<String> generateParenthesis(int n) {
        Set<String> ans = new HashSet<>();
        ans = createParenthesis(n, ans);
        System.out.println("Ans: " + ans);
        return new ArrayList<>(ans);
    }

    private static Set<String> createParenthesis(int n, Set<String> currentList) {
        java.util.Set<String> temp = new HashSet<>();
        if (n <= 0) return new HashSet<>();
        if (n == 1) {
            temp.add("()");
            return temp;
        }
        currentList = createParenthesis(n - 1, currentList);
        System.out.println("At n-1 " + String.valueOf(n-1) + ": " + currentList);
        for (String parenthesis : currentList) {
            for (int i = 0; i <= parenthesis.length(); i++) {
                String newStr;
                if (i == 0) {
                    System.out.println("At 0 for " + parenthesis);
                    newStr = "()" + parenthesis;
                    System.out.println(newStr);
                } else if (i == parenthesis.length()) {
                    System.out.println("At last for " + parenthesis);
                    newStr = parenthesis + "()";
                    System.out.println(newStr);
                } else {
                    System.out.println("At " + i + " for " + parenthesis);
                    newStr = parenthesis.substring(0, i) + "()" + parenthesis.substring(i);
                    System.out.println(newStr);
                }
                temp.add(newStr);
            }
        }
        currentList = temp;

        return currentList;
    }

/**
 * @param {number} n
 * @return {string[]}
 */
var generateParenthesis = function (n) {
    function dfs(l, r, t) {
        if (l > n  r > n  l < r) {
            return;
        }
        if (l == n && r == n) {
            ans.push(t);
            return;
        }
        dfs(l + 1, r, t + '(');
        dfs(l, r + 1, t + ')');
    }
    let ans = [];
    dfs(0, 0, '');
    return ans;
};

class Solution:
    def generateParenthesis(self, n: int):
        def dfs(left, right, s):
            if len(s) == n * 2:
                res.append(s)
                return
            
            if left < n:
                dfs(left + 1, right, s + '(')
            if right < left:
                dfs(left, right + 1, s + ')')

        res = []
        dfs(0, 0, '')
        return res

1. Класс `Solution` содержит приватное поле `result`, представленное интерфейсом `IList<string>`, инициализированное пустым списком типа `List<string>`. Это поле предназначено для хранения сгенерированных последовательностей скобок.

2. Публичный метод `GenerateParenthesis` принимает entier аргумент `n`, который представляет количество пар скобок, которые нужно сгенерировать. Внутри этого метода вызывается приватный метод `Helper` для генерации скобочных последовательностей.

3. Приватный метод `Helper` принимает `StringBuilder cur` для построения текущей последовательности, а также два целочисленных параметра `l` и `r`, представляющих количество оставшихся открывающих и закрывающих скобок соответственно. Метод `Helper` рекурсивно создает допустимые комбинации скобок с помощью условий и операций добавления и удаления скобок из `cur`.

4. Базовый случай в методе `Helper` проверяет, достигло ли количество закрывающих скобок `r` нуля. В этом случае текущая последовательность скобок добавляется в список `result`.

5. В зависимости от количества оставшихся открывающих и закрывающих скобок, метод `Helper` решает, можно ли добавить открывающую или закрывающую скобку и вызывает рекурсивно себя для генерации остальных комбинаций.

6. В конце метода `GenerateParenthesis` returnsся список `result`, содержащий все допустимые комбинации скобок для заданного количества пар скобок `n`. Каждая комбинация представлена строкой без явного использования символов.