算法学习

程序开发中降低算法复杂度的核心方法论

第一步，暴力解法。在没有任何时间、空间约束下，完成代码任务的开发。
第二步，无效操作处理。将代码中的无效计算、无效存储剔除，降低时间或空间复杂度。
第三步，时空转换。设计合理数据结构，完成时间复杂度向空间复杂度的转移。

 

算法题目

假设有任意多张面额为 2 元、3 元、7 元的货币，现要用它们凑出 100 元，求总共有多少种可能性。

function calculate () {
  const res = []

  const a = 100 / 7
  const b = 100 / 3
  for (let i = 0; i < a; i++) {
    for (let j = 0; j < b; j++) {
      if ((100 - i * 7 - j * 3) > 0 && (100 - i * 7 - j * 3) % 2 === 0) {
        const c = (100 - i * 7 - j * 3) / 2 
        res.push([i, j, c])
      }
    }
  }

  return res
}

获取一个数组中多个字符串的最长公共前缀。

var arr = ['flsight', 'flsds', 'flsds', 'fls']

var getPrefix = function (arr){
  var miniLength = Math.min.apply(null, arr.map(item => item.length))
  
  var result = ''
  
  for (let i = 0; i < miniLength; i++) {
     var single = arr.map(item => item[i])
     var superone = Array.from(new Set(single))   
       if (superone.length === 1) result += superone[0]
  }
  
  return result
}

console.log(getPrefix(arr))

 将[1,2,3]转为{0:1, 1:2, 2:3}

var arr = [1,2,3]
var reducer = (target, item, index) => {
  return Object.assign(target, {[index]: item})
}

console.log(arr.reduce(reducer, {}))

使用最少的钱币张数来兑换零钱 

function LeastCoinsChange (coins) {
  debugger
  var coins = coins
  var cache = {}

  this.makeChange = function (money) {
    var self = this
    if (!money) return []
    if (cache[money]) return cache[money]

    var leastCoins = [], newLeast, newMoney;
    for (var i = 0; i < coins.length; i++) {
      var coin = coins[i]
      newMoney = money - coin
      if (newMoney >= 0) {
        newLeast = self.makeChange(newMoney)
      }
      if (newMoney >= 0 &&
       (newLeast.length < leastCoins.length - 1 || !leastCoins.length) &&
       (newLeast.length || !newMoney)) {
        leastCoins = [coin].concat(newLeast)
        console.log(`面额 ${money}  ===  新的最少硬币${leastCoins}`)
      }
    }

    cache[money] = leastCoins
    return cache[money]
  }
}

var leastCoinsChange = new LeastCoinsChange([1,5,10,25])
console.log(leastCoinsChange.makeChange(35))