func solveNQueens(n int) [][]string {
    result := [][]string{}
    board := make([][]string, n)
    for i := 0; i < n; i++ {
        board[i] = make([]string, n)
        for j := 0; j < n; j++ {
            board[i][j] = "."
        }
    }
    isValid := func(row, col int) bool {
        for i := 0; i < row; i++ {
            if board[i][col] == "Q" {
                return false
            }
        }
        for i := 0; i < col; i++ {
            if board[row][i] == "Q" {
                return false
            }
        }
        for i, j := row, col; i >= 0 && j >= 0; i, j = i - 1, j - 1 {
            if board[i][j] == "Q" {
                return false
            }
        }
        for i, j := row, col; i >= 0 && j < n; i, j = i - 1, j + 1 {
            if board[i][j] == "Q" {
                return false
            }
        }
        return true
    }
    var backtracking func(int)
    backtracking = func(row int) {
        if row == n {
            temp := make([]string, n)
            for i, boardRow := range board {
                temp[i] = strings.Join(boardRow, "")
            }
            result = append(result, temp)
            return
        }
        for col := 0; col < n; col++ {
            if isValid(row, col) {
                board[row][col] = "Q"
                backtracking(row + 1)
                board[row][col] = "."
            }
        }
    }
    backtracking(0)
    return result
}

func partition(s string) [][]string {
    result := [][]string{}
    path := []string{}
    length := len(s)
    isParlindrom := func(s string) bool {
        for i, j := 0, len(s) - 1; i < j; i, j := i + 1, j - 1 {
            if s[i] != s[j] {
                return false
            }
        }
        return true
    }
    var backtracking func(int)
    backtracking = func(index int) {
        if index == length {
            temp := make([]int, len(path))
            copy(temp, path)
            result = append(result, temp)
            return
        }
        for i := index; i < length; i++ {
            if isParlindrom(s[index:i + 1]) {
                path = append(path, s[index: i + 1])
                backtracking(i + 1)
                path = path[:len(path) - 1]
            }
        }
    }
    backtracking(0)
    return result
}