//程序运行完成时一定要有输出语句，本工具才能正确展示运行结果。 
console.log("Hello JSRUN!   \n\n         - from NodeJS .");

/**
 * 选择排序
 * @param {number[]} nums
 * @return {number[]}
 */
var sortArray1 = function(nums) {
  for (let i = 0; i < nums.length; i++) {
      let min = Infinity;
      let minIndex;
      for (j = i; j < nums.length; j++) {
          if (nums[j] < min) {
              min = nums[j]
              minIndex = j;
          }
      }
      [nums[i], nums[minIndex]] = [nums[minIndex], nums[i]];
  }
  return nums;
};

/**
 * 插入排序
 * @param {number[]} nums
 * @return {number[]}
 */
var sortArray2 = function(nums) {
  for (let i = 1; i < nums.length; i++) {
      let temp = nums[i];
      let j = i - 1;
      for (; j >= 0; j--) {
          if (temp >= nums[j]) break;
          nums[j + 1] = nums[j]
      }
      nums[j + 1] = temp;
  }
  return nums;
};

/**
 * 冒泡排序
 * @param {number[]} nums
 * @return {number[]}
 */
var sortArray3 = function(nums) {
    for (let i = nums.length - 1; i >= 0 ; i--) {
        for (let j = 0; j < i; j++) {
            if (nums[j] > nums[j + 1]) {
                [nums[j], nums[j + 1]] = [nums[j + 1], nums[j]]
            }
        }
    }
    return nums;
};

/**
 * 快速排序
 * @param {number[]} nums
 * @return {number[]}
 */
var sortArray4 = function(nums) {
    if (nums.length < 2) return nums;
    return  quickSort(nums, 0, nums.length - 1);
};

function quickSort(nums, left, right) {
    if (left >= right) return;
    let pivotIndex = partition(nums, left, right)
    quickSort(nums, left, pivotIndex - 1)
    quickSort(nums, pivotIndex + 1, right)
    return nums;
}

function partition (nums, left, right) {
    let pivot = right;
    let leftIndex = left;
    for (let i = left; i < right; i++) {
        if (nums[i] < nums[pivot]) {
            [nums[leftIndex], nums[i]] = [nums[i], nums[leftIndex]];
            leftIndex++;
        }
    }
    [nums[leftIndex], nums[pivot]] = [nums[pivot], nums[leftIndex]];
    return leftIndex;
}


/**
 * 归并排序
 * @param {number[]} nums
 * @return {number[]}
 */
var sortArray5 = function(nums) {
    return mergeSort(nums, 0, nums.length - 1)
};

function mergeSort(nums, left, right) {
    if (left >= right) return nums;
    let mid = (left + right) >> 1;
    mergeSort(nums, left, mid)
    mergeSort(nums, mid + 1, right)
    return merge(nums, left, mid, right)
}

function merge(nums, left, mid, right) {
    let ans = [];
    let c = 0, i = left, j = mid + 1;
    while (i <= mid && j <= right) {
        if (nums[i] < nums[j]) {
            ans[c++] = nums[i++];
        } else {
            ans[c++] = nums[j++]
        }
    }
    while (i <= mid) {
        ans[c++] = nums[i++];
    }
    while (j <= right) {
        ans[c++] = nums[j++];
    }
    for (let i = 0; i < ans.length; i++) {
        nums[i + left] = ans[i];
    }
    return nums;
}

const arr = [2,4,7,2,8,4]
console.log(sortArray1(arr))
console.log(sortArray2(arr))
console.log(sortArray3(arr))
console.log(sortArray4(arr))
console.log(sortArray5(arr))

// 返回数组内n个随机数且不重复的整数，且整数范围是[2， 32]
function fn(n) {
    var arr = []
    while(arr.length !== n) {
        var m = parseInt(Math.random() * 31 + 2)
        if(!arr.includes(m)) {
            arr.push(m)
        }
    }
    return arr
}
console.log(fn(30))

// // 规则1
// var obj = {
//     a: 3,
//     b: 4,
//     fun: function () {
//         var a = 5;
//         return function () {
//             console.log(this.a)
//         }
//     }
// }
// var a = 6;
// // this = window
// obj.fun()(); // a = 6

// //规则2
// var obj1 = {
//     a: 3,
//     b: 4,
//     fun: (function () {
//         var a = 5;
//         return function () {
//             console.log(this.a)
//         }
//     })()
// }
// // this = obj1
// obj1.fun(); // a = 3

// // 规则3
// function fun1(fn) {
//     console.log(arguments)
//     arguments[0](3, 4)
// }
// function fun2() {
//     console.log(this.length)
//     console.log(arguments.length) // 2
// }
// // fun2里边的this = fun1实际参数列表
// fun1(fun2, 5, 6, 7, 8) // 5

// // 面试题1
// function Foo() {
//     function getName() {
//         console.log(1)
//     }
//     return this
// }
// Foo.getName = function () {
//     console.log(2)
// }
// Foo.prototype.getName = function () {
//     console.log(3)
// }
// // 覆盖
// var getName = function () {
//     console.log(4)
// }
// // 先生成getName，函数的声明优先提升，然后声明定义
// function getName() {
//     console.log(5)
// }
// getName() // 4
// // 符合规则1，函数直接运行this = window。相当于window.getName()，因为getName() = 4
// console.log(Foo)
// Foo().getName() // 4

// // 先执行new Foo()构造函数, new优先级非常高
// // 考点：原型链查找，对象能够沿着原型链访问自己构造函数的prototype上的属性/方法
// new Foo().getName() // 3

// // 先执行Foo.getName()，是普通函数，不是构造函数
// new Foo.getName() //2

// // 先执行构造函数new Foo().getName() = 3，然后使用new执行普通函数
// new new Foo().getName() //3

// // 面试题2
// function getLength() {
//     // 因为函数是getLangth.call(this.length)，下面小的length函数是这个getLangth函数的this
//     // 记住：函数的length和是形参列表的长度，arguments.length是实参列表的长度。
//     // arguments.callee表示函数本身，arguments.callee。length也是形参列表的长度
//     return this.length
// }
// function foo() {
//     this.length = 1
//     return (function() {
//         var length = 2
//         return {
//             length: function(a, b, c) {
//                 return this.arr.length
//             },
//             arr: [1, 2, 3, 4],
//             info: function() {
//                 // 以this.length作为this调用getLength函数
//                 return getLength.call(this.length)
//             }
//         }
//     })()
// }
// // foo()规则1，this = window，对象.info()规则2，this = 对象本身。
// var result = foo().info()
// console.log(result) // 3，length函数的三个参数长度

// // 面试题3
// function fun() {
//     var a = 1
//     this.a = 2
//     function fn() {
//         return this.a
//     }
//     fn.a = 3
//     return fn
// }
// console.log(fun()()) // 2

// // 面试题4
// function fun() { }
// console.log(typeof fun) // function
// // 注意：A instanceof B判断方法，看A的原型链上有没有B的prototype
// console.log(fun instanceof Function) // true
// console.log(fun instanceof Object) // true

// // 面试题4
// var a = 1
// var obj = {
//     a: 2,
//     getA: function() {
//         return this.a
//     }
// }
// var getA = obj.getA
// getA() // 1

// // 面试题5
// var obj = {
//     a: 1,
//     b: 2,
//     c: [{
//         a: 3,
//         b: 4,
//         c: fn
//     }]
// }
// function fn() {
//     console.log(this.a)
// }
// var a = 5
// obj.c[0].c()


// function getLength() {
//     console.log(arguments.length)
// }
// var arr = [1, 2, 3, 4, 5, 6]
// // 写一条语句输出6
// getLength(...arr)
// getLength.apply(this, arr)
// getLength.call(this, ...arr)

// var number = 2
// var obj = {
//     number: 4,
//     fn1: (function() {
//         this.number *= 2
//         // number 是局部变量，此时number变量声明但没有赋值，所以number为NaN
//         number = number * 2
//         // 变量声明的提升
//         var number = 3
//         return function() {
//             this.number *= 2
//             number *= 3
//             console.log(number)
//         }
//     })
// }
// console.log(number)
// var fn1 = obj.fn1
// fn1()
// console.log(number)
// obj.fn1()
// console.log(number)
// // console.log(window.number)
// console.log(obj.number)

// var arr = [1, 1, 2, 3, 4, 5, 5, "5"]
// function uniq(arr) {
//     let result = []
//     for (let i = 0; i < arr.length; i++) {
//         if (!result.includes(arr[i])) {
//             result.push(arr[i])
//         }
//     }
//     return result
// }
// console.log(uniq(arr))

// // 冒泡排序，记住arr.length - 1和arr.length - 1 - i就没问题
// // 现在这个函数不是纯函数，不是pure的，我们改变了传入到它内部的参数值
// var arr = [1, 10, 2, 3, 4, 5, 0, 30]
// function bubbleSort(arr) {
//     for (let i = 0; i < arr.length - 1; i++) {
//         for (let j = 0; j < arr.length - 1 - i; j++) {
//             if (arr[j] > arr[j + 1]) {
//                 var temp = arr[j]
//                 arr[j] = arr[j + 1]
//                 arr[j + 1] = temp
//             }
//         }
//     }
// }
// bubbleSort(arr)
// console.log(arr)

// //快速排序（二分法排序），效率高于冒泡排序
// function quickSort(arr) {
//     // 停止递归的条件
//     if (arr.length <= 1) {
//         return arr
//     }
//     // 设置标杆
//     const pivot = arr[0]
//     // 比标杆大的
//     let bigger = []
//     // 比标杆小的
//     let smaller = []
//     for (let a of arr) {
//         if (a > pivot) {
//             bigger.push(a)
//         } else {
//             smaller.push(a)
//         }
//     }
//     return quickSort(smaller).concat(pivot, quickSort(bigger))
// }
// console.log((arr))

// //数组扁平化
// var arr = [0, [1, 2, 3], [4, [[[[5, 6], 7, 8]]], 9], 10]
// function flattenArray(arr) {
//     var _arr = []
//     for (let i = 0; i < arr.length; i++) {
//         // 判断是不是数组，IE6/7使用鸭式辩型（Object.prototype.toString.call(arr)）== "[object Array]" && "push" in arr)
//         if (!Array.isArray(arr[i])) {
//             _arr.push(arr[i])
//         } else {
//             _arr = _arr.concat(flattenArray(arr[i]))
//         }
//     }
//     return _arr
// }
// console.log(flattenArray(arr))

// 函数柯里化: 例如需要4个参数，如果少传一个实参就会返回一个函数，这个函数有原来函数的功能，但是虚位以待，等待随时传入第四个实参
// function curry(fn){
//     return function(){
//         // 备份实参
//         var args = arguments
//         return function(){
//             return fn(...args, ...arguments)
//         }
//     }
// }
// function fun(a, b, c, d) {
//     return a + b + c + d
// }
// fun = curry(fun)
// var fn = fun(1, 2, 3)
// console.log(fn(45))

// //浅克隆
// let arr = [1, 2, 3, [4, 5, 6]]
// let _arr = []
// for(let a of arr){
//     _arr.push(a)
// }
// console.log(arr == _arr)  // false
// console.log(arr[1] == _arr[1]) // true

// //深克隆
// var arr = [1, 2, 3, [4, 5, 6]]
// console.log(arr)
// function deepClone(v) {
//     if(typeof v == "string" || typeof v == "number" || typeof v == "boolean" || typeof v == "undefined"){
//         return v
//     } else if(Array.isArray(v)) {
//         let _arr = []
//         for(let a of arr) {
//             _arr.push(deepClone(a))
//         }
//         return _arr
//     } else if(typeof v == "object") {
//         let obj = {}
//         for(let val in v){
//             obj[val] = deepClone(v[val])
//         }
//         return obj
//     }
// }
// var arr2 = deepClone(arr)
// console.log(arr2)
// console.log(arr[1] == arr2[1]) // false

let params = {
    d: 9,
    i: 15,
    s: 3,
    c: 15
}
// ['i','c']

let params2 = {
    d: 9,
    i: 20,
    s: 3,
    c: 10
}
// ['i']

// function test(params) {
//     let max = Math.max(...Object.values(params))
//     return Object.keys(params).filter(key => params[key] === max)
// }
// console.log(test(params))

// console.log(test(params2))


function maxKeys(obj) {
    let a = [];
    for (var i in obj) {
        let v = obj[i]; // 9
        a[v] || (a[v] = []);
        a[v].push(i);
        
        console.log(v); // 9,15,3,15
        console.log(a[v] || (a[v] = []))
        console.log(a[v])
    }
    console.log('\n',a)
    return a.pop();
}

console.log(maxKeys(params))

let arr = [1, 2, 3, 4]
// 仿写 findIndex，

Array.prototype.findIndex2 = function (func) {
    let len = this.length;
    for (var i = 0; i < len; i++) {
        if (func(arr[i], i, this)) {
            return i;
        }
    }
}
let i = arr.findIndex2((e) => e > 1)
console.log(arr[i], '大于1')