常见的算法处理方式

/*
给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，
例如不会出现像 3a 或 2[4] 的输入。
*/

const decodeString = (s) => {
    const reg = /(\d+\[\w+\])/;
    if(!reg.test(s)) {
        return s;
    }
    const val = /(\d+)\[(\w+)\])/.exec(s);
    if(val && val?.length > 0) {
        const num = parseInt(val[1], 10);
        const value = val[2];
        let str = '';
        for(let i = 0; i < num; i++) {
            str += value;
        }
        s = s.replace(reg, str);
    }
    if(reg.test(s)){
        return decodeString(s);
    }
    return s;
};
// console.log('3[a]2[bc]'.split(/\d\[/g))
console.log(decodeString('3[a]2[bc]'));
console.log(decodeString('3[a2[c]]'));
console.log(decodeString('12[abc]3[cd]ef'));
console.log(decodeString('abc3[cd]xyz'));

实现一个函数 fetchWithConcurrency(urls, maxConcurrency)，
该函数接收一个 URL 数组 urls 和一个最大并发数 maxConcurrency，

返回所有请求的结果。要求在任何时刻，最多只能有 maxConcurrency 个请求同时进行。
*/

const urls = Array.from({ length: 20 }, 
  (_, i) => `https://jsonplaceholder.typicode.com/todos/${i + 1}`);
const fetchWithConcurrency = (urls, maxConcurrency) => {
  if(urls.length === 0) {
      return Promise.resolve([]);
  }
  return new Promise((resolve, reject) => {
      let result = [];
      let count = 0;
      let index = 0;
      const len = urls.length;
      const reqNum = Math.min(len, maxConcurrency);
      const request = async () => {
          if(count >= len) {
              return;
          }
          const i = index;
          const url = urls[index++];
          const resp = await fetch(url);
          result[i] = resp;
          count++;
          
          if(count === len) {
              resolve(result);
          }
          request();
      }
      for(let i = 0; i < reqNum; i++) {
          // const url = urls.shift();
          request();
      }
  });
};

console.log('res', fetchWithConcurrency(urls, 5));

实现一个抢红包功能，每个人抢到的金额随机，函数splitRedEnvelope，入参为总金额和人数

每个人至少领到1分钱。
*/

const splitRedEnvelope = (totalAmount, numPeople) => {
  const minNum = 1;
  let resultArr = new Array(numPeople).fill(1); // 初始化每个人的红包金额为1
  if(totalAmount < numPeople) {
      console.log('金额不够分配，清重新输入');
      return false;
  }
  let rangeAmount = totalAmount - numPeople; // 剩余可分配金额

  for(let i = 0; i < numPeople; i++) {
      // let maxNum = rangeAmount - (numPeople - 1 - i);
      if(rangeAmount > 0) {
          let num = Math.floor(Math.random() * rangeAmount);
          if(i == numPeople - 1) {
              num = rangeAmount;
          }
          resultArr[i] = num + minNum;
          rangeAmount -= num;
      }
      
  }
  return resultArr;
};

console.log('res', splitRedEnvelope(100, 18));

promise.all) 核心思路

①接收一个 Promise 实例的数组或具有 Iterator 接口的对象作为参数
②这个方法返回一个新的 promise 对象，
③遍历传入的参数，用Promise.resolve()将参数"包一层"，使其变成一个promise对象
④参数所有回调成功才是成功，返回值数组与参数顺序一致
⑤参数数组其中一个失败，则触发失败状态，第一个触发失败的 Promise 错误信息作为 Promise.all 的错误信息。
2）实现代码
一般来说，Promise.all 用来处理多个并发请求，也是为了页面数据构造的方便，将一个页面所用到的在不同接口的数据一起请求过来，不过，如果其中一个接口失败了，多个请求也就失败了，页面可能啥也出不来，这就看当前页面的耦合程度了

function promiseAll(promises) {
  return new Promise(function(resolve, reject) {
    if(!Array.isArray(promises)){
        throw new TypeError(`argument must be a array`)
    }
    var resolvedCounter = 0;
    var promiseNum = promises.length;
    var resolvedResult = [];
    for (let i = 0; i < promiseNum; i++) {
      Promise.resolve(promises[i]).then(value=>{
        resolvedCounter++;
        resolvedResult[i] = value;
        if (resolvedCounter == promiseNum) {
            return resolve(resolvedResult)
          }
      },error=>{
        return reject(error)
      })
    }
  })
}

// test
let p1 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        resolve(1)
    }, 1000)
})
let p2 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        resolve(2)
    }, 2000)
})
let p3 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        resolve(3)
    }, 3000)
})
promiseAll([p3, p1, p2]).then(res => {
    console.log(res) // [3, 1, 2]
})

// 买卖股票时机-leetcode

function maxProfit(prices: number[]): number {
  let maxProfit = 0
  let minPrice = Number.MAX_VALUE
  for (let i = 0; i < prices.length; i++) {
    minPrice = Math.min(minPrice, prices[i])
    maxProfit = Math.max(maxProfit, prices[i] - minPrice)
  }
  return maxProfit
}

console.log(maxProfit([7, 1, 5, 3, 6, 4]))