先端アルゴリズムの問題

function matchStr(str) {
    const strAray = str.split('');
    let stack = [];
    const match={
        '{':'}',
        '(':')',
        '[':']',
    };
    for (var i = 0; i < strAray.length; i++) {
        if (['{', '[', '('].includes(strAray[i])) {
            stack.push(strAray[i])
        } else {
            if(match[stack.pop()]!==strAray[i]){
                return false
            }
        }
    }
    return true
}

f(1,2,3,4,5) => 15
f(1)(2)(3,4,5) => 15
f(1)(2)(3,4,5) => 15
f(1,2)(3,4,5) => 15
f(1)(2)(3)(4)(5) => 15

//      
function foo(a, b) {
    console.log(a + b)
}

var bar = foo.bind(null, 2);
bar(3) // 5

//   
function foo(a, b, c, d, e) {
    console.log(a + b + c + d + e)
}

const obj = Object.create(null);
let count = 0;
function add() {
    const arg = Array.from(arguments);
    const length = arg.length;
    if (arg.length + count < 5) {
        count += arg.length;
        return add.bind(obj, ...arg)
    } else {
        foo.call(obj, ...arg)
        count = 0
    }
}

//    
var obj = {
    a: { a1: '122', a2: 123 },
    b: { b1: new Date(), b2: function () { console.log('b2') } },
    c: { c1: /\d+/, c2: true, c3: false },
    d: { d1: Symbol(1), d2: null, d3: undefined }
}

function deepClone(obj) {
    if (typeof obj !== 'object') return obj;
    if (obj === null) return null;
    if (obj.constructor === Date) return new Date(obj);
    if (obj.constructor === RegExp) return new RegExp(obj);
    var newObj = new obj.constructor();
    for (var key in obj) {  //         x in obj       true
        if (obj.hasOwnProperty(key)) {
            if (typeof obj[key] !== 'object') {
                newObj[key] = obj[key];
            } else {
                newObj[key] = deepClone(obj[key])
            }
        }
    }
    return newObj;
}

if (a == 1 && a == 2 && a == 3) {
    console.log('ok')
}

//   1
var a = {
    i: 0,
    toString() {
        return ++this.i
    }
}

//   2
var b = 0;
Object.defineProperty(window, 'a', {
    get: () => {
        b++;
        return b;
    }
});

//   3
var a = [1, 2, 3];
a.toString = a.shift

//      
const x = [1, 2, 3, [4, 5, [6, 7]]];

// method1
const y = x.flat(Infinity);

// method2
const z = x.toString().split(',');
const z1 = JSON.stringify(x).replace(/[\[\]]/g, '').split(',');

// method3
function flat(x) {
    if (!Array.isArray(x)) return x;
    const y = [];
    for (let i = 0; i < x.length; i++) {
        if (Array.isArray(x[i])) {
            y.push(...flat(x[i]))
        } else {
            y.push(x[i])
        }
    }
    return y;
}

function calc(num) {
    const max = Math.ceil(num / 2);
    // 1 ~ num-1
    function plus(x, y) {
        if (y > num) {
            return ['error']
        }
        if (y == num) {
            return [x];
        }
        return [x].concat(plus(x + 1, x + 1 + y))
    }
    let arr = [];
    for (var i = 1; i <= max; i++) {
        const res = plus(i, i);
        if (res[res.length - 1] !== 'error') {
            arr.push(res)
        }
    }
    return arr;
}