Sujet : Selon l'entier d'entrée Int n (1<n<8) comme nombre total de parenthèses, et sortie le tableau string[] de toutes les combinaisons possibles de parenthèses.
Exemple 1
entrée : n=1
sortie :["()"]
Exemple 2
entrée : n=3
sortie :["((()))", "(()())", "(())()", "()(())", "()()()"]
function handler(n) {
let res;
// code here...
return res;
}
La raison pour laquelle cette question est étrange est que les questions sur l'algorithme de programmation que j'ai vues auparavant concernent également le tri des crochets, mais cette question fournit une chaîne contenant plusieurs crochets, comme "(()())))) ()" vous oblige
à déterminez combien de demi-crochets doivent être ajoutés pour que tous les crochets forment une paire correcte de crochets gauche et droit.
Ce type de tri par crochets existe, principalement pour la complétion automatique des balises gauche et droite dans les éditeurs HTML. Mais je ne vois aucune utilité pour la question écrite ci-dessus.Est-il utilisé pour pré-calculer le tri possible lors du déplacement de blocs?
Et j'ai passé une demi-heure sur cette question à ne penser qu'à insérer des valeurs dans des chaînes, mais je n'ai pas compris quelles règles utiliser pour les insérer. Pendant le test, j'ai répondu à deux questions d'algorithme en une heure, donc j'ai automatiquement soumis des heures supplémentaires et ne pouvait pas répondre.
Voici la solution que j'ai passé un autre jour et nuit (syntaxe : 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="((()))"。
本质上这种方法没有脱离第一种思路，只是少了迭代过程中数组和字符串之间频繁来回转换的行为，只需要在首尾各进行一次转换即可，所以不再放具体代码，感兴趣的可以自行实现。
*/
Exemple de code complet
Copiez et enregistrez le code suivant en tant que fichier local filename.js, puis saisissez-le et exécutez-le sur la ligne de commande node filename.jspour effectuer des tests d'entrée et de sortie :
// @@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();
Ce qui précède est le problème, les idées de résolution de problèmes et la mise en œuvre du code de ce problème d'algorithme de programmation. Bienvenue à commenter ci-dessous si vous avez une meilleure solution ~~