有效括号字符串 定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末 「有效括号字符串」部分。
嵌套深度 depth 定义:即有效括号字符串嵌套的层数,depth(A) 表示有效括号字符串 A 的嵌套深度。详情参见题末「嵌套深度」部分。
有效括号字符串类型与对应的嵌套深度计算方法如下图所示:
给你一个「有效括号字符串」 seq
,请你将其分成两个不相交的有效括号字符串,A
和 B
,并使这两个字符串的深度最小。
•不相交:每个 seq[i]
只能分给 A
和 B
二者中的一个,不能既属于 A
也属于 B
。•A
或 B
中的元素在原字符串中可以不连续。•A.length + B.length = seq.length
•深度最小:max(depth(A), depth(B))
的可能取值最小。
划分方案用一个长度为 seq.length 的答案数组 answer 表示,编码规则如下:
•answer[i] = 0
,seq[i]
分给 A
。•answer[i] = 1
,seq[i]
分给 B
。
如果存在多个满足要求的答案,只需返回其中任意 一个 即可。
示例1
输入:seq = "(()())"
输出:[0,1,1,1,1,0]
示例2
输入:seq = "()(())()"
输出:[0,0,0,1,1,0,1,1]
解释:本示例答案不唯一。
按此输出 A = "()()", B = "()()", max(depth(A), depth(B)) = 1,它们的深度最小。
像 [1,1,1,0,0,1,1,1],也是正确结果,其中 A = "()()()", B = "()", max(depth(A), depth(B)) = 1 。
提示
•1 <= text.size <= 10000
有效括号字符串:
仅由 "(" 和 ")" 构成的字符串,对于每个左括号,都能找到与之对应的右括号,反之亦然。
下述几种情况同样属于有效括号字符串:
1. 空字符串
2. 连接,可以记作 AB(A 与 B 连接),其中 A 和 B 都是有效括号字符串
3. 嵌套,可以记作 (A),其中 A 是有效括号字符串
嵌套深度:
类似地,我们可以定义任意有效括号字符串 s 的 嵌套深度 depth(S):
1. s 为空时,depth("") = 0
2. s 为 A 与 B 连接时,depth(A + B) = max(depth(A), depth(B)),其中 A 和 B 都是有效括号字符串
3. s 为嵌套情况,depth("(" + A + ")") = 1 + depth(A),其中 A 是有效括号字符串
例如:"","()()",和 "()(()())" 都是有效括号字符串,嵌套深度分别为 0,1,2,而 ")(" 和 "(()" 都不是有效括号字符串。
这道题其实主要在审题,代码如下挺简单,新匹配到括号则++然后%2,否则--然后%2。
/**
* @param {string} seq
* @return {number[]}
*/
let maxDepthAfterSplit = (seq, dep = 0) => {
return seq.split('').map(e => e === '(' ? dep++ % 2 : --dep % 2)
}
Promise.all()方法将多个Promise实例包装成一个Promise对象(p),接受一个数组(p1,p2,p3)作为参数,数组中不一定需要都是Promise对象,但是一定具有Iterator接口,如果不是的话,就会调用Promise.resolve将其转化为Promise对象之后再进行处理。使用Promise.all()生成的Promise对象(p)的状态是由数组中的Promise对象(p1,p2,p3)决定的;
1.如果所有的Promise对象(p1,p2,p3)都变成fullfilled状态的话,生成的Promise对象(p)也会变成fullfilled状态,p1,p2,p3三个Promise对象产生的结果会组成一个数组返回给传递给p的回调函数;2.如果p1,p2,p3中有一个Promise对象变为rejected状态的话,p也会变成rejected状态,第一个被rejected的对象的返回值会传递给p的回调函数。
Promise.all()方法生成的Promise对象也会有一个catch方法来捕获错误处理,但是如果数组中的Promise对象变成rejected状态时,并且这个对象还定义了catch的方法,那么rejected的对象会执行自己的catch方法,并且返回一个状态为fullfilled的Promise对象,Promise.all()生成的对象会接受这个Promise对象,不会返回rejected状态。
// 以下 demo,请求两个 url,当两个异步请求返还结果后,再请求第三个 url
const p1 = request(`http://some.url.1`)
const p2 = request(`http://some.url.2`)
Promise.all([p1, p2])
.then((datas) => { // 此处 datas 为调用 p1, p2 后的结果的数组
return request(`http://some.url.3?a=${datas[0]}&b=${datas[1]}`)
})
.then((data) => {
console.log(msg)
})
function promiseAll(promises) {
return new Promise(function(resolve, reject) {
if (!Array.isArray(promises)) {
return reject(new TypeError('argument must be anarray'));
}
var countNum = 0;
var promiseNum = promises.length;
var resolvedvalue = new Array(promiseNum);
for (var i = 0; i < promiseNum; i++) {
(function(i) {
Promise.resolve(promises[i]).then(
function(value) {
countNum++;
resolvedvalue[i] = value;
if (countNum === promiseNum) {
return resolve(resolvedvalue);
}
},
function(reason) {
return reject(reason);
},
);
})(i);
}
});
}
var p1 = Promise.resolve(1),
p2 = Promise.resolve(2),
p3 = Promise.resolve(3);
promiseAll([p1, p2, p3]).then(function(value) {
console.log(value);
});
有时候我们使用Promise.all()执行很多个网络请求,可能有一个请求出错,但我们并不希望其他的网络请求也返回reject,要错都错,这样显然是不合理的。如何做才能做到promise.all中即使一个promise程序reject,promise.all依然能把其他数据正确返回呢?
var p1 = new Promise(function(resolve, reject) {
setTimeout(function() {
resolve(1);
}, 0);
});
var p2 = new Promise(function(resolve, reject) {
setTimeout(function() {
resolve(2);
}, 200);
});
var p3 = new Promise(function(resolve, reject) {
setTimeout(function() {
try {
console.log(XX.BBB);
} catch (exp) {
resolve('error');
}
}, 100);
});
Promise.all([p1, p2, p3])
.then(function(results) {
console.log('success');
console.log(results);
})
.catch(function(r) {
console.log('err');
console.log(r);
});
[1]
1111. 有效括号的嵌套深度: https://leetcode-cn.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/
本文分享自 JavaScript全栈 微信公众号,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体同步曝光计划 ,欢迎热爱写作的你一起参与!