Tema: De acuerdo con el entero de entrada Int n (1<n<8) como el número total de corchetes, y genera la cadena de matriz [] de todas las combinaciones posibles de corchetes.
Ejemplo 1
entrada: n=1
salida:["()"]
Ejemplo 2
entrada: n=3
salida:["((()))", "(()())", "(())()", "()(())", "()()()"]
function handler(n) {
let res;
// code here...
return res;
}
La razón por la que esta pregunta es extraña es que las preguntas del algoritmo de programación que vi antes también se refieren a la clasificación de corchetes, pero esa pregunta proporciona una cadena que contiene varios corchetes, como "(()())))) ()" requiere
que calcule cuántos medios corchetes deben agregarse para que todos los corchetes sean un par correcto de corchetes izquierdo y derecho.
Este tipo de clasificación de paréntesis existe, principalmente para completar automáticamente las etiquetas izquierda y derecha en los editores de HTML. Pero no puedo pensar en ningún uso para la pregunta escrita anteriormente.¿Se usa para precalcular la posible clasificación al arrastrar bloques?
Y pasé media hora en esta pregunta solo pensando en insertar valores en cadenas, pero no he descubierto qué reglas usar para insertarlos. Durante la prueba, completé dos preguntas de algoritmo en una hora, por lo que automáticamente envió horas extras y no pudo responder.
Aquí está la solución que pasé otro día y noche (sintaxis: javascript):
/*
第一种思路是打散字符串插值
将字符串A插入到长度为L的字符串B中所有字符的前后间隙位置中得到Array(L+1)个可能性结果，之后再将结果去重得到本次真正的结果。
之后根据输入值循环n次，得到最终结果。
其中字符串A="()"，字符串B就是上一次得到的n-1结果数组[字符串B1,字符串B2]，进行迭代得到的。
*/
function handler(n) {
// code here...
let res = [""];
// 获取所有插值可能性
const single = (str = "", ins = "()") => {
const strArr = [...str.split(""), ""]; // 数组最后一位添加任意项，确保前后空隙都会插入值
return Array.from(new Set(strArr.map((noMatter, index) => {
let _arr = Array.from(strArr);
_arr.splice(index, 0, ins);
return _arr.join("");
})));
};
// 根据输入值执行n次插入
while (n > 0) {
res = res.reduce((prev, item) => Array.from(new Set([...prev, ...single(item)])), []);
n--;
}
return res;
}
/*
第二种思路是先转换为数值单位进行叠加
是先将字符值"()"视为一个数值单位1，之后每次进行是间隙和自身都叠加值，第一次是[1]，第二次是[[1,1],[2]]，第三次是[[1,1,1],[2,1],[1,2],[3]]，最后才根据单位数量叠加数量重新替换为字符值，例如2="(())"，3="((()))"。
本质上这种方法没有脱离第一种思路，只是少了迭代过程中数组和字符串之间频繁来回转换的行为，只需要在首尾各进行一次转换即可，所以不再放具体代码，感兴趣的可以自行实现。
*/
Código de ejemplo completo
Copie y guarde el siguiente código como un archivo local filename.jsy luego ingréselo y ejecútelo en la línea de comandos node filename.jspara realizar pruebas de entrada y salida:
// @@filename.js
const readline = require("readline");
const insReadline = readline.createInterface({
input: process.stdin,
output: process.stdout
});
function showQuestion(question = "Please input the number of brackets you want, 0<number<8 \n", _handler = handler) {
insReadline.question(question, input => {
try {
if (input >= 8 || input < 1) {
throw new Error("input should be in [1,8].");
}
console.log("result:" + JSON.stringify(_handler(input)));
} catch (err) {
console.log(err);
}
console.log("End...");
showQuestion();
});
}
// 使用第一种思路：打散字符串插值
function handler(n) {
// code here...
let res = [""];
// 获取所有插值可能性
const single = (str = "", ins = "()") => {
const strArr = [...str.split(""), ""]; // 数组最后一位添加任意项，确保前后空隙都会插入值
return Array.from(new Set(strArr.map((noMatter, index) => {
let _arr = Array.from(strArr);
_arr.splice(index, 0, ins);
return _arr.join("");
})));
};
// 根据输入值执行n次插入
while (n > 0) {
res = res.reduce((prev, item) => Array.from(new Set([...prev, ...single(item)])), []);
n--;
}
return res;
}
// don't touch
showQuestion();
Lo anterior es el problema, las ideas para resolver problemas y la implementación del código de este problema de algoritmo de programación. Bienvenido a comentar a continuación si tiene una mejor solución ~~