记录

1124 10.  Strobogrammatic Number

/**
* @param {string} num
* @return {boolean}
*/
var isStrobogrammatic = function(num) {
    if (num == null || num.length === 0) {
        return false;
    }
    // !!! order will switch, so 0, 1, 8 will also need to be checked
    let left = 0;
    let right = num.length - 1;
    while (left <= right) {
        const leftChar = num[left];
        const rightChar = num[right];
        if (['1', '8', '0'].includes(leftChar)) {
            if (rightChar !== leftChar) {
                return false;
            }
        } else if (leftChar === '6') {
            if (rightChar !== '9') {
                return false;
            }
        } else if (leftChar === '9') {
            if (rightChar !== '6') {
                return false;
            }
        } else {
            return false;
        }
        left++;
        right--;
    }
    return true;
};

1124 11. Valid Word Square

/**
* @param {string[]} words
* @return {boolean}
*/
var validWordSquare = function(words) {
    if (words == null || words.length === 0) {
        return false;
    }
    for (let i = 0; i < words.length; i++) {
        for (let j = 0; j < words[i].length; j++) {
            if (!words[j]) { // !!! need to guard it, one has it one doesn't is false
                return false;
            }
            if (words[i][j] !== words[j][i]) { // !!!! i, j mixed !!!
                return false;
            }
        }
    }
    return true;
};

1124 12. Paint Fence

/**
* @param {number} n
* @param {number} k
* @return {number}
*/
var numWays = function(n, k) {
    if (n === 0) {return 0;}
    if (n === 1) {return k;}
    let same = k;
    let diff = k * (k - 1);
    for (let i = 2; i < n; i++) {
        // could use ;[] = []; to do the assignment.
        // use same color as prev one
        const useSame = diff;
        // use diff color as prev one
        const useDiff = (k - 1) * (same + diff);
        same = useSame;
        diff = useDiff;
    }
    return same + diff;
};

1124 13. Maximum Distance in Arrays

/**
* @param {number[][]} arrays
* @return {number}
*/
var maxDistance = function(arrays) {
    if (arrays == null || arrays.length === 0) {
        return 0;
    }
    let minVal = arrays[0][0];
    let maxVal = arrays[0][arrays[0].length - 1];
    let max = 0;
    for (let i = 1; i < arrays.length; i++) {
        const array = arrays[i];
        const currMax = array[array.length - 1];
        const currMin = array[0];
        max = Math.max(max, Math.abs(currMax - minVal), Math.abs(maxVal - currMin));
        maxVal = Math.max(maxVal, currMax);
        minVal = Math.min(minVal, currMin);
    }
    return max;
};

1124 14. Max Stack

/**
* initialize your data structure here.
*/
var MaxStack = function() {
    this.stack = [];
    this.maxStack = [];
};

/**
* @param {number} x
* @return {void}
*/
MaxStack.prototype.push = function(x) {
    this.stack.push(x);
    if (this.maxStack.length === 0) {
        this.maxStack.push(x);
    } else {
        const max = Math.max(x, this.maxStack[this.maxStack.length - 1]);
        this.maxStack.push(max);
    }
};

/**
* @return {number}
*/
MaxStack.prototype.pop = function() {
    this.maxStack.pop();
    return this.stack.pop();
};

/**
* @return {number}
*/
MaxStack.prototype.top = function() {
    return this.stack[this.stack.length - 1];
};

/**
* @return {number}
*/
MaxStack.prototype.peekMax = function() {
    return this.maxStack[this.maxStack.length - 1];
};

/**
* @return {number}
*/
MaxStack.prototype.popMax = function() {
    const tmpStack = [];
    while (this.stack[this.stack.length - 1] !== this.maxStack[this.maxStack.length - 1]) {
        tmpStack.push(this.stack.pop());
        this.maxStack.pop();
    }
    const num = this.stack.pop();
    this.maxStack.pop();
    while (tmpStack.length > 0) {
        this.push(tmpStack.pop());
    }
    return num;
};

/**
* Your MaxStack object will be instantiated and called as such:
* var obj = Object.create(MaxStack).createNew()
* obj.push(x)
* var param_2 = obj.pop()
* var param_3 = obj.top()
* var param_4 = obj.peekMax()
* var param_5 = obj.popMax()
*/

1124 15. Design Compressed String Iterator

/**
* @param {string} compressedString
*/
var StringIterator = function(compressedString) {
    compressedString = compressedString || '';
    let i = 0;
    const list = [];
    while (i < compressedString.length) {
        const c = compressedString[i];
        let j = i + 1;
        while (j < compressedString.length && compressedString[j] >= '0' && compressedString[j] <= '9') {
            j++;
        }
        const str = compressedString.slice(i + 1, j);
        const num = Number.parseInt(str, 10);
        list.push([c, num]);
        i = j;
    }
    this.list = list;
    this.i = 0;
    this.j = 0;
};

/**
* @return {character}
*/
StringIterator.prototype.next = function() {
    if (!this.hasNext()) {return ' '} // !!! retunr a white space, not empty string
    const [c, num] = this.list[this.i];
    this.j++;
    if (this.j === num) {
        this.i++;
        this.j = 0;
    }
    return c;
};

/**
* @return {boolean}
*/
StringIterator.prototype.hasNext = function() {
    return this.i < this.list.length;
};

/**
* Your StringIterator object will be instantiated and called as such:
* var obj = Object.create(StringIterator).createNew(compressedString)
* var param_1 = obj.next()
* var param_2 = obj.hasNext()
*/

1124 16. Read N Characters Given Read4

This made it clear:
I agree with you regarding the ambiguity of the problem, especially for non-C++ programmers. It should explicitly say read4 reads 4 characters from a file into "buf" char array, and implement a function that reads n characters from the file into "buf" char array.

/**
* Definition for read4()
*
* @param {character[]} buf Destination buffer
* @return {number} The number of characters read
* read4 = function(buf) {
*     ...
* };
*/

/**
* @param {function} read4()
* @return {function}
*/
var solution = function(read4) {
    /**
     * @param {character[]} buf Destination buffer
     * @param {number} n Maximum number of characters to read
     * @return {number} The number of characters read
     */
    return function(buf, n) {
        if (n <= 0) {return 0;}
        let i = 0;
        while (i + 4 <= n) {
            const tmp = [];
            const num = read4(tmp);
            buf.push(...tmp)
            if (num !== 4) {
                return i + num;
            }
            i = i + 4;
        }
        const remain = n - i;
        const tmp = [];
        const num = read4(tmp);
        const minNum = Math.min(remain, num);
        for (let j = 0; j < minNum; j++) {
            buf.push(tmp[j]);
        }
        return minNum + i;
    };
};

sicilianee 发表于 2017-11-25 13:14
1124 16. Read N Characters Given Read4

This made it clear:

could combine everything into the loop, i.e. put the last iteration into the loop.

1124 17. Valid Word Abbreviation

/**
* @param {string} word
* @param {string} abbr
* @return {boolean}
*/
var validWordAbbreviation = function(word, abbr) {
    const list = [];
    let i = 0;
    while (i < abbr.length) {
        if (abbr[i] >= '0' && abbr[i] <= '9') {
            let j = i;
            while (j < abbr.length && abbr[j] >= '0' && abbr[j] <= '9') {
                j++;
            }
            const str = abbr.slice(i, j);
            if (str[0] === '0') {return false} // !!! cannot have leading 0s, even a single 0 is not allowed !!!!
            const num = Number.parseInt(str, 10);
            list.push(num);
            i = j; // !!!! this update !!!!
        } else {
            list.push(abbr[i]);
            i++;
        }
    }
    let j = 0;
    for (let el of list) {
        if (Number.isInteger(el)) {
            j = j + el;
        } else {
            if (j >= word.length || word[j] !== el) {
                return false;
            }
            j++;
        }
    }
    return j === word.length;
};

1124 18. Two Sum III - Data structure design

/**
* Initialize your data structure here.
*/
var TwoSum = function() {
    this.map = new Map();
};

/**
* Add the number to an internal data structure..
* @param {number} number
* @return {void}
*/
TwoSum.prototype.add = function(number) {
    const count = this.map.get(number) || 0;
    this.map.set(number, count + 1);
};

/**
* Find if there exists any pair of numbers which sum is equal to the value.
* @param {number} value
* @return {boolean}
*/
TwoSum.prototype.find = function(value) {
    console.log(this.map)
    for (let [number, count] of this.map.entries()) {
        const target = value - number;
        if (this.map.has(target)) {
            if (target !== number || this.map.get(number) > 1) { // !!!! if it is false, you cannot return early because
                // you still have other entries to be tested
                return true;
            }
        }
    }
    return false;
};

/**
* Your TwoSum object will be instantiated and called as such:
* var obj = Object.create(TwoSum).createNew()
* obj.add(number)
* var param_2 = obj.find(value)
*/