Backtracking

function subsets(items) {
  const result = [];
  const path = [];
  function explore(start) {
    result.push([...path]); // record a copy, not path itself
    for (let i = start; i < items.length; i++) {
      path.push(items[i]);  // choose
      explore(i + 1);       // explore
      path.pop();           // un-choose
    }
  }
  explore(0);
  return result;
}
 
subsets(["C", "E", "T"]);
// [[], ["C"], ["C","E"], ["C","E","T"], ["C","T"], ["E"], ["E","T"], ["T"]]

def subsets(items):
    result = []
    path = []
 
    def explore(start):
        result.append(path[:])  # record a copy, not path itself
        for i in range(start, len(items)):
            path.append(items[i])  # choose
            explore(i + 1)         # explore
            path.pop()             # un-choose
 
    explore(0)
    return result
 
subsets(["C", "E", "T"])
# [[], ['C'], ['C', 'E'], ['C', 'E', 'T'], ['C', 'T'], ['E'], ['E', 'T'], ['T']]

function permutations(items) {
  const result = [];
  const path = [];
  const used = new Array(items.length).fill(false);
  function explore() {
    if (path.length === items.length) {
      result.push([...path]);
      return;
    }
    for (let i = 0; i < items.length; i++) {
      if (used[i]) continue;
      used[i] = true;     // choose
      path.push(items[i]);
      explore();          // explore
      path.pop();         // un-choose
      used[i] = false;
    }
  }
  explore();
  return result;
}
 
permutations(["Ana", "Ben", "Cy"]).length; // 6

def permutations(items):
    result = []
    path = []
    used = [False] * len(items)
 
    def explore():
        if len(path) == len(items):
            result.append(path[:])
            return
        for i in range(len(items)):
            if used[i]:
                continue
            used[i] = True          # choose
            path.append(items[i])
            explore()               # explore
            path.pop()              # un-choose
            used[i] = False
 
    explore()
    return result
 
len(permutations(["Ana", "Ben", "Cy"]))  # 6

function solveQueens(n) {
  const cols = new Set(), down = new Set(), up = new Set();
  const placed = []; // placed[row] = column of that row's queen
  const solutions = [];
  function explore(row) {
    if (row === n) { solutions.push([...placed]); return; }
    for (let col = 0; col < n; col++) {
      // prune: column or diagonal already taken
      if (cols.has(col) || down.has(row - col) || up.has(row + col)) continue;
      // choose
      cols.add(col); down.add(row - col); up.add(row + col);
      placed.push(col);
      explore(row + 1); // explore
      // un-choose
      cols.delete(col); down.delete(row - col); up.delete(row + col);
      placed.pop();
    }
  }
  explore(0);
  return solutions;
}
 
solveQueens(4); // [[1, 3, 0, 2], [2, 0, 3, 1]]

def solve_queens(n):
    cols, down, up = set(), set(), set()
    placed = []  # placed[row] = column of that row's queen
    solutions = []
 
    def explore(row):
        if row == n:
            solutions.append(placed[:])
            return
        for col in range(n):
            if col in cols or row - col in down or row + col in up:
                continue  # prune
            cols.add(col)  # choose
            down.add(row - col)
            up.add(row + col)
            placed.append(col)
            explore(row + 1)  # explore
            cols.remove(col)  # un-choose
            down.remove(row - col)
            up.remove(row + col)
            placed.pop()
 
    explore(0)
    return solutions
 
solve_queens(4)  # [[1, 3, 0, 2], [2, 0, 3, 1]]