第三天继续，还是继续简单题
【题目】： 实现一个MyQueue类，该类用两个栈来实现一个队列。
【示例：】
MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 false
【思路】：这个就直接一把梭就完事了，可以用数组，嗯，也可以用其他的，比如Set
【代码】：
/**
* Initialize your data structure here.
*/
var MyQueue = function() {
this.state = []
};
/**
* Push element x to the back of queue.
* @param {number} x
* @return {void}
*/
MyQueue.prototype.push = function(x) {
this.state.push(x)
};
/**
* Removes the element from in front of queue and returns that element.
* @return {number}
*/
MyQueue.prototype.pop = function() {
if(this.state.length){
return this.state.splice(0,1)
}
};
/**
* Get the front element.
* @return {number}
*/
MyQueue.prototype.peek = function() {
if(this.state.length){
return this.state[0]
}
};
/**
* Returns whether the queue is empty.
* @return {boolean}
*/
MyQueue.prototype.empty = function() {
return this.state.length===0
};
【题目682.棒球比赛】：
你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。
比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：
整数 x - 表示本回合新获得分数 x "+" - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。 "D" - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。 "C" - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。 请你返回记录中所有得分的总和
【示例1：】
输出：30
解释：
"5" - 记录加 5 ，记录现在是 [5]
"2" - 记录加 2 ，记录现在是 [5, 2]
"C" - 使前一次得分的记录无效并将其移除，记录现在是 [5].
"D" - 记录加 2 * 5 = 10 ，记录现在是 [5, 10].
"+" - 记录加 5 + 10 = 15 ，记录现在是 [5, 10, 15].
所有得分的总和 5 + 10 + 15 = 30
【示例2：】
输入：ops = ["5","-2","4","C","D","9","+","+"]
输出：27
解释：
"5" - 记录加 5 ，记录现在是 [5]
"-2" - 记录加 -2 ，记录现在是 [5, -2]
"4" - 记录加 4 ，记录现在是 [5, -2, 4]
"C" - 使前一次得分的记录无效并将其移除，记录现在是 [5, -2]
"D" - 记录加 2 * -2 = -4 ，记录现在是 [5, -2, -4]
"9" - 记录加 9 ，记录现在是 [5, -2, -4, 9]
"+" - 记录加 -4 + 9 = 5 ，记录现在是 [5, -2, -4, 9, 5]
"+" - 记录加 9 + 5 = 14 ，记录现在是 [5, -2, -4, 9, 5, 14]
所有得分的总和 5 + -2 + -4 + 9 + 5 + 14 = 27
【示例3：】
输入： ops = ["1"]
输出： 1
【思路】：这个题目还是比较简单的，用一个新数组按步骤保存有效值再求和就可以了
【代码】：
/**
* @param {string[]} ops
* @return {number}
*/
var calPoints = function(ops) {
if(!ops.length) return 0
if(ops.length === 1) return ops[0]
let resultArr = []
for(let o of ops){
switch(o){
case '+':
resultArr.push(resultArr[resultArr.length-2]*1+resultArr[resultArr.length-1]*1)
break
case 'D':
resultArr.push(resultArr[resultArr.length-1]*2)
break
case 'C':
resultArr.pop()
break
default:
resultArr.push(o)
break
}
}
return resultArr.reduce((a,b)=>{
return a*1+b*1
}, 0)
};
【题目844. 比较含退格的字符串】：
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，请你判断二者是否相等。# 代表退格字符。
如果相等，返回 true ；否则，返回 false 。
注意：如果对空文本输入退格字符，文本继续为空。
【示例1：】
输入： s = "ab#c", t = "ad#c"
输出： true
解释： S 和 T 都会变成 “ac”。
【示例2：】
输入： s = "ab##", t = "c#d#"
输出： true
解释： s 和 t 都会变成 “”。
【示例3：】
输入： s = "a##c", t = "#a#c"
输出： true
解释： s 和 t 都会变成 “c”。
【示例4：】
输入： s = "a#c", t = "b"
输出： false
解释： s 会变成 “c”，但 t 仍然是 “b”。
【思路】：略！😏
【代码】：
/**
* @param {string} s
* @param {string} t
* @return {boolean}
*/
var backspaceCompare = function(s, t) {
return getString(s)===getString(t)
};
function getString(s){
let str = ''
if(!s.length){
return ''
}
if(s.length === 1){
if(s[0]==='#') return ''
return s[0]
}
for(let i = 0;i<s.length;i++){
if(s[i] === '#'){
str = str.slice(0,-1)
}else{
str+=s[i]
}
}
return str
}
