每日一练---codewars

距离上次发布文章过去了很久，中间其实也没有断开学习，只是都在ipad上面记录了自己的学习过程。现在开始新的算法练习，也是记录下自己每一次能不能有小小的进步

每日一题

题目：recipe为配方是一个对象（{ "cream": 200, "flour": 300, "sugar": 150, "milk": 100, "oil": 100 }），
available是可提供的原材料、暂称为原料，也是一个对象（{ "sugar": 1700, "flour": 20000, "milk": 20000, "oil": 30000, "cream": 5000 }）。
现在需要计算出原材料能根据配方制作出多少的成品
题目难度：5kyu

recipe 是配方 available可提供的原料
首先判断 原料里是否有我们需要的配方 如果没有 就做不出
如果原料都有 那么原料的数量是否大于配方的数量 如果小于
得出需要配方最大的 然后得出与原料的比例 在依次比较 只要有一个不满足 就说明不能满足
这种思路写下去 略微复杂了点 最后越接近实现的脚步 越复杂 所以果断放弃这种方法

function cakes(recipe, available) {
    var count = 0;
    for (var i in recipe) {
        if (!(i in available)) {
            return count
        } else {
            if (recipe[i] > available[i]) {
                return count
            }
        }
    }
    var keyArr = Object.keys(recipe).sort((a, b) => {
        return recipe[b] - recipe[a]
    })
    var flag = Math.floor(available[keyArr[0]] / recipe[keyArr[0]])
    for (var i = 0; i < keyArr.length; i++) {
        var val = Math.floor(available[keyArr[0]] / recipe[keyArr[0]]);
        if (val < 1) {
            count = 0;
            return count;
        }
    }
    for (var i = 0; i < keyArr.length; i++) {
        var val = Math.floor(available[keyArr[0]] / recipe[keyArr[0]]);
        if (val < flag && val >= 1) {
            count = 1;
            return count;
        }
    }
    count = flag;
    console.log(count)
    return count;
}

cakes({ "cream": 200, "flour": 300, "sugar": 150, "milk": 100, "oil": 100 }, { "sugar": 1700, "flour": 20000, "milk": 20000, "oil": 30000, "cream": 5000 });

另一种思路 我把配方 recipe 按照子元素排序 得出一个数组 新建一个对象 然后与原料进行 比较 得出差值 取最小值 如果原料没有该配方 值为0

function cakes(recipe, available) {
    var keyArr = Object.keys(recipe).sort((a, b) => {
        return recipe[b] - recipe[a]
    })
    var obj = {};
    for (var i = 0; i < keyArr.length; i++) {
         obj[keyArr[i]] = available[keyArr[i]] ? Math.floor(available[keyArr[i]] / recipe[keyArr[i]]) : 0
    }
    var newobj = Object.keys(obj).sort((b, a) => {
        return obj[b] - obj[a]
    })
    return obj[newobj[0]];
}

优化 一开始没必要排序 只需要进行取差值就哦尅

function cakes(recipe, available) {
    var obj = {};
    for (var i in recipe) {
        obj[i] = available[i] ? Math.floor(available[i] / recipe[i]) : 0
    }
    var newobj = Object.keys(obj).sort((b, a) => {
        return obj[b] - obj[a]
    })
    console.log(obj[newobj[0]])
    return obj[newobj[0]];
}

继续优化 没有必要在生成一个新的对象 我只需要把所有的差值放进数组 取最小值

function cakes(recipe, available) {
    var arr = []
    for (var i in recipe) {
        arr.push(available[i] ? Math.floor(available[i] / recipe[i]) : 0)
    }
    console.log(newArr
    return Math.min(...arr);
}

继续优化 使用 es6 新语法 进行对象的遍历 一行代码解决 最终版！

function cakes(recipe, available) {
    return Math.min(...(Object.keys(recipe).map(i=>{
        return available[i] ? Math.floor(available[i] / recipe[i]) : 0
    })))
}