每日一练社区——前端个人解题思路

题1：最大子序合

function getMaxArray(arr) {
    if (!arr || !Array.isArray(arr)) {
        return '请输入正确的数据'
    } else if (arr.length == 1) {
        return arr.join()
    } else {
        let arr1 = []; //组合
        let arr2 = []; //组合的总和
        let max_keys = []; //最大值字序
        let max_value = null; //最大值
        for (let i=0; i<arr.length; i++) {
            if (isNaN(arr[i])) break
            arr1.push([arr[i]])
            arr2.push(arr[i])
            if (arr[i] > max_value) {
                max_keys = arr1.at(-1)
                max_value = arr2.at(-1)
            }
            for (let j=i+1; j<arr.length; j++) {
                if (isNaN(arr[j])) break
                let now_key = JSON.parse(JSON.stringify(arr1.at(-1)))
                now_key.push(arr[j])
                arr1.push(now_key)
                let now_value = Number(arr2.at(-1))+Number(arr[j])
                arr2.push(now_value)
                if (now_value > max_value) {
                    max_keys = arr1.at(-1)
                    max_value = arr2.at(-1)
                }
            }
        }
        return '连续子数组' + JSON.stringify(max_keys) + '的和最大，为' + max_value
    }
}

题2：等差数列判断求和

function getEqualArr(str) {
    if (!str || !str.trim() || str.split(' ').length != 3) {
        return '请输入正确的数据'
    }
    let startNum = !isNaN(str.split(' ')[0]) ? Number(str.split(' ')[0]) : null
    let endNum = !isNaN(str.split(' ')[1]) ? Number(str.split(' ')[1]) : null
    let addNum = !isNaN(str.split(' ')[2]) ? Number(str.split(' ')[2]) : null
    if (startNum == null) {
        return '请输入正确的首项'
    } else if (endNum == null) {
        return '请输入正确的末项'
    } else if (addNum == null) {
        return '请输入正确的公差'
    } else if (startNum > endNum) {
        return '首项' + startNum + '需要小于末项' + endNum
    } else if (addNum < 1) {
        return '公差需要大于0'
    } else if ((endNum - startNum) % addNum !== 0) {
        //不构成等差数列
        return -1
    }
    let value = 0;
    for (let i=startNum; i<=endNum; i+=addNum) {
        value += i
    }
    return value
}

题3：醉酒狱卒开门

function getEscapeNum(num,total) {
    // num：轮数 total：牢房总数
    let arr = new Array(total).fill(false,0,total); //初始化数组
    for (let i=0; i<num; i++) {
        for (let j=i; j<arr.length; j=j+i+1) {
            arr[j] = !arr[j]
        }
    }
    return arr.filter(k => k).length
}

题4：数组奇偶重排

function sortArray(arr) {
    if (!arr || !Array.isArray(arr) || arr.length == 0) {
        return '请输入正确的数据'
    }
    return arr.filter(i => i%2 == 1).concat(arr.filter(i => i%2 == 0)).join(' ')
}

题5：计算货车数量

function calculateCarNum(total,limit) {
    limit = limit === 13 ? 12 : limit;
    return parseInt(total / limit) + Number(total % limit > 0 ? 1 : 0)
}

题6：数字出现次数

function getNumCount(max,num) {
    if ((!max && max!==0) || isNaN(max)) return '请输入最大值'
    if ((!num && num!==0) || isNaN(num)) return '请输入要查询的数值'
    let arr = Array.from({ length: max }, (_, index) => index + 1);
    return arr.join('').split('').filter(i => i.toString().indexOf(num) != -1 ).length + '次'
}

题7：水池注水 （做了一部分，感觉思路不对，剩下的再捋捋）

let arr = []; //水池
let steps = []; //已获取的可用步骤
let all_steps = []; //所有可执行的点位
function init(num) { //初始化水池
    arr = []
    for (let i=0; i<num; i++) {
        let item = []
        for (let j=0; j<num; j++) {
            item.push(0)
        }
        arr.push(item)
    }
    console.log('水池初始化完成')
    console.log(JSON.parse(JSON.stringify(arr)))
    createAllStepsPoint()
}
//获取所有可执行的点位
function createAllStepsPoint() {
    for (let x=0; x<arr.length; x++) {
        for (let y=0; y<arr[x].length; y++) {
            all_steps.push(x+''+y)
        }
    }
    steps = []
    //createAllSteps()
}
//生成所有可执行的步骤
function createAllSteps(list = null, index = 0) {
    for (let i=0; i<all_steps.length; i++) {
        if (list) {
            if (list.indexOf(all_steps[i]) != -1) continue
            let newList = JSON.parse(JSON.stringify(list))
            newList.push(all_steps[i])
            if (index == all_steps.length-1) {
                steps.push(newList)
                console.log('已获取所有可执行的步骤' + i)
            } else {
                createAllSteps(newList, index+1)
            }
        } else {
            createAllSteps([all_steps[i]], index+1)
        }
    }
}
function handlePut(x,y) { //手动注入水池
    if (arr.length == 0) {
        return '请先初始化水池'
    } else if (x > arr[0].length) {
        return 'x超过最大值'
    } else if (x > arr.length) {
        return 'y超过最大值'
    } else if (arr[x][y]) {
        return x+','+y+'已注水'
    }
    arr[x][y] = 1
    checkBasicStatus()
}
async function checkBasicStatus() { //遍历检查水池状态
    let reCheck = false
    for (let x=0; x<arr.length; x++) {
        for (let y=0; y<arr[x].length; y++) {
            let state = await getBasidStatus(x,y,arr.length-1,arr[x].length-1)
            if (state) {
                reCheck = true
                break
            }
        }
        if (reCheck) {
            break
        }
    }
    if (reCheck) {
        checkBasicStatus()
    } else {
        console.log('当前水池状态')
        console.log(JSON.parse(JSON.stringify(arr)))
    }
}
function getBasidStatus(x,y,X,Y) { //获取当前位置四周的注水状态
    if (arr[x][y]) return
    let top = y==0 ? null : arr[x][y-1]
    let left = x==0 ? null : arr[x-1][y]
    let right = x==X ? null : arr[x+1][y]
    let bottom = y==Y ? null : arr[x][y+1]
    let basid = [top, left, right, bottom]
    if (basid.filter(i => i).length > 1) {
        arr[x][y] = 1
        return 1
    } else {
        return 0
    }
}

题8：腾讯笔试-求两数和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0]   nums[1] = 2   7 = 9
所以返回 [0, 1]

function getSumIndex(arr, total) {
    if (!arr || !arr.length) return '请输入正确的数组'
    if (total==undefined || isNaN(total)) return '请输入正确的数值'
    for (let i=0; i<arr.length; i++) {
        for (let j=i+1; j<arr.length; j++) {
            if (arr[i] + arr[j] == total) {
                return [i,j]
            }
        }
    }
    return '没有合适的数值'
}

题9：阿里-数据处理（限时半小时）

1、请用您认为最优化的方式，将arr中的type为4的数据过滤出来
2、然后按相同的 name date（按天）合并value（value累加）
3、然后按 value 降序(从大到小)排序
4、最后每行按照 "${name},${本地日期},售出${sum(value)}部" 的格式，如："小米2,2017年06月08日,售出5部", 打印(console.log)出来。 可以使用第三方js库，可以使用es6。

var arr = [

   {name:'小米1', value: 1,  type: 2, date: '2018-06-07T08:00:01.589Z' },

   {name:'锤子T1', value: 1, type: 2, date: '2018-06-07T08:10:01.589Z' },

   {name:'小米2', value: 1, type: 4, date: '2018-06-07T20:00:01.589Z' },

   {name:'小米2', value: 4, type: 4, date: '2018-06-07T20:10:21.189Z' },

   {name:'小米4', value: 1, type: 4, date: '2018-06-07T08:00:01.560Z' },

   {name:'小米4', value: 2, type: 4, date: '2018-06-07T08:10:31.584Z' },

   {name:'小米6', value: 1, type: 3, date: '2018-06-07T08:00:01.589Z' },

   {name:'小米5s',value: 1, type: 4, date: '2018-06-07T08:00:01.589Z' },

   {name:'锤子T2', value: 1, type: 4, date: '2018-06-07T08:00:01.589Z' },

   {name:'锤子T1', value: 4, type: 4, date: '2018-06-07T08:06:01.589Z' },

   {name:'魅蓝note5', value: 1, type: 4, date: '2018-06-07T08:00:01.589Z' },

   {name:'魅蓝note2', value: 5, type: 4, date: '2018-06-02T08:07:01.589Z' },

   {name:'魅蓝note2', value: 6, type: 4, date: '2018-06-07T08:00:01.589Z' },

   {name:'魅蓝note3', value: 1, type: 4, date: '2018-06-05T08:00:01.589Z' },

   {name:'魅蓝note', value: 1, type: 4, date: '2018-06-07T08:00:01.589Z' },

   {name:'oppor9', value: 7, type: 4, date: '2018-06-04T08:04:01.588Z' },

   {name:'华为p9', value: 1, type: 4, date: '2018-06-02T08:00:01.577Z' },

   {name:'华为p9', value: 2, type: 4, date: '2018-06-07T08:00:01.110Z' },

   {name:'华为p10', value: 1, type: 1, date: '2018-06-07T08:00:01.534Z' }

];

function setNormalTime(time) {
    let t = new Date(time)
    let Y = t.getFullYear()
    let M = t.getMonth()+1
    let D = t.getDate()
    return Y + '年' + (M<10 ? '0' : '') + M + '月' + (D<10 ? '0' : '') + D + '日'
}
function outputMessage(arr) {
    let newArr = arr.filter(item => item.type == 4)
    let arr_keys = []
    let arr_values = []
    for (let i=0; i<newArr.length; i++) {
        let name = newArr[i].name
        let date = setNormalTime(newArr [i].date)
        let value = newArr[i].value
        if (arr_keys.indexOf(name+'-'+date) == -1) {
            arr_keys.push(name+'-'+date)
            arr_values.push(value)
        } else {
            arr_values[arr_keys.indexOf(name+'-'+date)].value += value
        }
    }    
    let lastArr = []
    for (let j=0; j<arr_keys.length; j++) {
        lastArr .push({
            name: arr_keys[j].split('-')[0],
            time: arr_keys[j].split('-')[1],
            value: arr_values[j]
        })
    }
    lastArr = lastArr.sort((a,b) => b.value-a.value)
    for (let k in lastArr) {
        console.log(lastArr[k].name+','+lastArr[k].time+',售出'+lastArr[k].value+'部')
    }
}

题10：睡眠函数

请你编写一个异步函数，它接收一个正整数参数 millis ，并休眠 millis 毫秒。要求此函数可以解析任何值。

示例 1：
输入：millis = 100
输出：100
解释：
在 100ms 后此异步函数执行完时返回一个 Promise 对象
let t = Date.now();
sleep(100).then(() => {
  console.log(Date.now() - t); // 100
});

示例 2：
输入：millis = 200
输出：200
解释：在 200ms 后函数执行完时返回一个 Promise 对象

/**
 * @param {number} millis
 * @return {Promise}
 */
async function sleep(millis) {
        return new Promise(resolve => {
            setTimeout(() => {
                    resolve()
            }, millis)
        })
}

let t = Date.now()
sleep(100).then(() => console.log(Date.now() - t)) // 100

题11：老鼠与奶酪

有两只老鼠和 n 块不同类型的奶酪，每块奶酪都只能被其中一只老鼠吃掉。
下标为 i 处的奶酪被吃掉的得分为：
如果第一只老鼠吃掉，则得分为 reward1[i] 。
如果第二只老鼠吃掉，则得分为 reward2[i] 。
给你一个正整数数组 reward1 ，一个正整数数组 reward2 ，和一个非负整数 k 。
请你返回第一只老鼠恰好吃掉 k 块奶酪的情况下，最大 得分为多少。

示例 1：
输入：reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2
输出：15
解释：这个例子中，第一只老鼠吃掉第 2 和 3 块奶酪（下标从 0 开始），第二只老鼠吃掉第 0 和 1 块奶酪。
总得分为 4 + 4 + 3 + 4 = 15 。
15 是最高得分。

示例 2：
输入：reward1 = [1,1], reward2 = [1,1], k = 2
输出：2
解释：这个例子中，第一只老鼠吃掉第 0 和 1 块奶酪（下标从 0 开始），第二只老鼠不吃任何奶酪。
总得分为 1 + 1 = 2 。
2 是最高得分。

/**
 * @param {number[]} reward1
 * @param {number[]} reward2
 * @param {number} k
 * @return {number}
 */
var miceAndCheese = function(reward1, reward2, k) {
    let reward1_index = new Array(k)
    for (let i=0; i<reward1_index.length; i++) {
        for (let j=0; j<reward1.length; j++) {
            if (reward1_index[i]==undefined || (reward1[reward1_index[i]] < reward1[j] && reward1_index.indexOf(j) == -1)) {
                reward1_index[i] = j
            }
        }
    }
    let total = 0
    for (let m=0; m<reward1.length; m++) {
        total += ((reward1_index.indexOf(m) != -1) ? reward1[m] : reward2[m])
    }
    return total
};