FreeCodeCamp 高级算法（个人向）

freecodecamp 高级算法地址戳这里。

freecodecamp的初级和中级算法，基本给个思路就能完成，而高级算法稍微麻烦了一点，所以我会把自己的解答思路写清楚，如果有错误或者更好的解法，欢迎留言。

Validate US Telephone Numbers

如果传入字符串是一个有效的美国电话号码，则返回 true.

简单来说，美国号码的规则就是，国家代码（必须为1），然后就是3,3,4的数字组合，前三个数字可以用括号包起来。另外就是间隔使用空格或者“-”。

因为输入值肯定是字符串，规则也较多，所以考虑用正则做。

先贴代码：

function telephoneCheck(str) {
  // Good luck!
  var reg=/^(1\s?)?\(?\d{3}\)?(\s|-)?\d{3}(\s|-)?\d{4}/;   //正则规则
 
  var index1=str.indexOf("(");
  var index2=str.indexOf(")");   //查询到两个括号
 
  if( (index1!=-1 && index2!=-1) || (index1==-1 && index2==-1) ){   //存在双括号或者没有括号
    if( index2!=index1 && index2-index1!=4 ){  //如果存在双括号，且序号间的字符有3个
      return false;
    }
    var str2=str.replace(/[\(\)\s-]/g,"");  //将括号和空格和“-”全局替换成空，便于统计数字长度
    if( str2.length==11 && str2.substr(0,1)!=1 ){
      return false;
    }
 
  }else{
      return false;
  }
 
  return reg.test(str);
}
 
telephoneCheck("27576227382");

当首次尝试直接匹配号码的时候我们发现不行，因为我们没办法同时匹配到双括号，正则规则存在一些盲点，这些盲点首先就是双括号的问题，再有就是长度问题，对于超出长度的字符我们没有匹配验证的能力，这就需要我们用js进行一些弥补。

我的做法，首先验证是否有双括号，同时有或者同时没有皆可；如果只有一个，返回false。接着在同时有或者同时没有双括号里面追加两个判断，如果有双括号，那么两个括号之间的字符一定是三个，否则返回false，如果确实返回3个，那我们也不用进行过多的判断，因为正则里已经写好了。接着就是通过replace将一切干扰元素去掉，验证一下字符串的长度有没有超出11；当长度为11时，第一个数字是不是1。完成了这些用来完善的判断，最后进行一下正则的匹配就可以了。

Symmetric Difference

创建一个函数，接受两个或多个数组，返回所给数组的 对等差分(symmetric difference) (△ or ⊕)数组

输入的数组可能会是多个，而题目的要求是按顺序两两处理。也就是说，我们把前两个数组各自独有的元素组成新数组后，再和第三个数组进行处理，以此类推，最终会返回一个数组。这种模式让我们想到了数组的reduce方法，前两个处理出一个结果，处理出的结果再和下一个进行处理，直到最后得到一个结果。

所以主体函数的最后只要使用reduce就可以了，那么目前的问题就是解决两个数组之间如何消去所有的相同元素，然后返回一个排好序的新数组。因为一个数组当中都可能存在重复的元素，如果只是两个数组都删除相同的，可能还会删不干净。

我的思路是这样的，既然我们的目标只有值，而不在乎数量，所以一个开始就可以对两个数组分别进行一次去重，然后就是两个数组删除一个相同元素然后拼接排序。我这里呢，偷了个懒，用的还是去重的函数，等于省了一个函数。

function sym(args) {
  var arrs=[];
  for(var a of arguments){
    arrs.push(a);
  }
  var res=arrs.reduce(function(a,b){
    a=del(a);
    b=del(b);  //数组分别处理
    var arr=a.concat(b);
    return del(arr,true);  //拼接成一个大数组后，再进行一次处理
  });
 
 return res;
}
 
function del(arr,flag){   //排序and去重   flag为true表示删干净，否则留一个
  var start,end;
  arr.sort(function(a,b){  //数组由小到大排序
    return a-b;
  });
  for(var i=0;i<arr.length;i++){
    if(arr[i]==arr[i+1]){  //发现重复
      start=(start===undefined)?i:start;  //start为重复的起始位置
      end=i+1;           //end为重复的结束位置
    }else{
      if( end && end==i ){  //如果存在重复，即end有值，按照flag对数组进行处理。
        if( flag ){
          arr.splice(start,end-start+1);
          i=i-(end-start+1);
        }else{
          arr.splice(start,end-start);
          i=i-(end-start);
        }
        start=undefined;  //没有重复了，start要还原
      }
    }
  }
 
  return arr;
 
}
sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);

Exact Change

设计一个收银程序 checkCashRegister() ，其把购买价格(price)作为第一个参数 , 付款金额 (cash)作为第二个参数, 和收银机中零钱 (cid) 作为第三个参数.

输入为实际付款，商品价格，和零钱的余额。然后返回值有三种，如果找不开返回"Insufficient Funds"；如果正好找开，余额空了，返回"Closed"；其余则返回找零的数组。我的思路可能偏繁琐一点，它给的余额是每种面值的总价值，比如20元它会显示60，那么实际上是20元的有3张。所以如果要找5块，20元的这个60其实没有办法找开。于是我建了一个对象，用来管理余额，存储每种货币的面额和数量。之后就是比对需要找零的钱是否大于等于面值，如果大于等于，就看该面值的数量是否足够，足够则找零，更新找零的数额。重复这个步骤，直到找开，或者找不开。

代码如下：

function checkCashRegister(price, cash, cid) {
  var change=[];   //储存结果
  var cid_obj={    //存储值和数量
    "ONE HUNDRED":{val:100},
    "TWENTY":{val:20},
    "TEN":{val:10},
    "FIVE":{val:5},
    "ONE":{val:1},
    "QUARTER":{val:0.25},
    "DIME":{val:0.1},
    "NICKEL":{val:0.05},
    "PENNY":{val:0.01}
  };
 
  for(var a of cid){
    cid_obj[a[0]].num=Math.ceil(a[1]/cid_obj[a[0]].val); //更新不同货币的数量
  }
 
  if( price==cash ){
    return "Closed";
  }else{
    var cha=cash-price;  //需要找零的钱
    for(let k of Object.keys(cid_obj)){
      var count=0;
      while( cha>=cid_obj[k].val && cid_obj[k].num!==0 ){ //没有完成找零且当前零钱可以找零
          cha=(cha-cid_obj[k].val).toFixed(2); //这里需要四舍五入成2位小数，不然会有计算误差
          cid_obj[k].num--;
          count++;
          if( cid_obj[k].num===0 || cha<cid_obj[k].val ){   //如果没零钱了
            change.push([k,cid_obj[k].val*count]);
            break;
          }
 
      }
    }
 
    if( cha==0 ){
      if( cid_obj["PENNY"].num==0 ){  //偷懒的做法
        return "Closed";
      }
      return change;
    }else{
      return "Insufficient Funds";
    }
 
  }
 
}
 
checkCashRegister(19.50, 20.00, [["PENNY", 0.50], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]);

Inventory Update

依照一个存着新进货物的二维数组，更新存着现有库存(在arr1 中)的二维数组. 如果货物已存在则更新数量 . 如果没有对应货物则把其加入到数组中，更新最新的数量. 返回当前的库存数组，且按货物名称的字母顺序排列。

这个题目比较简单，如果没有就添加一个数组元素，如果有就更新一下对应的数量。稍微麻烦点的是按字母顺序排序，我是使用了sort方法，内部用了循环的方式，逐个比对。

代码如下：

function updateInventory(arr1, arr2) {
    // All inventory must be accounted for or you're fired!
    var arr=[];
    outer:for(let x of arr2){    //更新数组
      for(let y of arr1){
        if(x[1]==y[1]){
          y[0]+=x[0];
          continue outer;
        }
      }
      arr.push(x);   //arr2独有的放进arr
    }
 
    return arr.concat(arr1).sort(function(a,b){  //排序
      var index=0;
      var char_a,char_b;
      do{
        char_a=a[1].charCodeAt(index);
        char_b=b[1].charCodeAt(index);
        index++;
      }while( char_a==char_b );
 
      return char_a-char_b;
    });
}
 
// Example inventory lists
var curInv = [
    [21, "Bowling Ball"],
    [2, "Dirty Sock"],
    [1, "Hair Pin"],
    [5, "Microphone"]
];
 
var newInv = [
    [2, "Hair Pin"],
    [3, "Half-Eaten Apple"],
    [67, "Bowling Ball"],
    [7, "Toothpaste"]
];
 
updateInventory(curInv, newInv);

No repeats please

例如, aab 应该返回 2 因为它总共有6中排列 (aab, aab, aba,aba, baa, baa), 但是只有两个 (aba and aba)没有连续重复的字符 (在本例中是 a)。

这个题目是我觉得最有意思的一个题目，我算法比较烂，所以一开始很懵逼，全排列算法，不会啊！于是就是百度了一下，找到了下面的两种方法，这两种方法也是最后实现算法的基础。

两种都是递归，但思路不一样，第一种是交换法，先看代码：

function swap(arr,i,j) {
    if(i!=j) {
        var temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}
var count=0;
function perm(arr) {
    (function fn(n) { //为第n个位置选择元素
        for(var i=n;i<arr.length;i++) {
            swap(arr,i,n);
            if(n+1<arr.length-1) //判断数组中剩余的待全排列的元素是否大于1个
                fn(n+1); //从第n+1个下标进行全排列
            else
                console.log(++count+" "+arr); //显示一组结果
            swap(arr,i,n);
        }
    })(0);
}
perm(["01","02","03","04"]); 

这里明确一下各部分的职能，swap函数，用于交换数组中两个序号的值，单纯的交换函数；count变量，计数器；perm函数，是全排列的入口函数，这里的话是调用递归函数fn。如果把fn函数单独拿到外面定义，然后perm函数内部写fn(0)，其实也是一样的。

那么最后的重点就是fn函数。它的思路其实不算太难理解，你可以把fn后面接收的参数n当做一个箭头，它标记了一个数组序号。因为是递归，其实每一步所做的事情都是一样的，所以我们只要考虑它这一步做了什么就可以了。

我们从fn(0)开始看，它从n开始遍历，然后进行了交换，也就说这一步其实是在为n这个位置选一个值，而且只在n序号之后选，这样不会影响前面已经确定的值。选好之后，递归结束了么？没有，我们只选了一个值，所以它进行了一个判断，如果当前标记的序号不是倒数第二个，就为下一个序号选一个值。之所以是倒二，是因为倒一不需要进行任何判断，它只可能有一个值，所以确定了倒二，倒一也是确定的，整个排列也就确定了，所以在确定了一种排列之后，显示结果。

那么问题来了，为什么输出结果之后要再次用swap函数交换一次。这是因为arr是唯一的数组，我们的每次交换都是直接对它进行操作，我们需要保证我们通过循环给位置n交换别的值时，arr还是我们认为的arr,n的原始值应该不变,这样每次的交换才有意义，如果我们不回滚，arr数组里的元素就会变得乱七八糟。

以三个元素排列说一下过程，a,b,c三个元素，首先fn(0),然后通过循环交换了一个值(循环的第一个值是自己，也就是不交换)；接着fn(1),也交换了一个值；发现序号1已经是倒二，输出一条结果，然后回滚，再次给序号1的位置交换一个值，再次输出一个值。继续回滚，然后发现序号1的位置已经循环完了。也就是说fn(1)已经执行完毕，而fn(1)是在fn(0)里的，那么继续执行fn(0)后续的代码，序号为0的位置回滚复原，然后给序号为0的位置通过循环交换一个新值，再次fn(1)。不断的重复，直到fn(0)循环完毕，结束。

交换法理解的难点就是n的意义，还有swap的作用，理解了这两点其实后面就顺畅了。

下面看另一种方法，这种方法就好理解多了，暂时叫它抓取法。

代码如下：

var count=0;
function perm(arr) {
    (function fn(source, result) {
        if (source.length == 0)
            console.log(++count+" "+result);
        else
            for (var i = 0; i < source.length; i++)
                fn(source.slice(0, i).concat(source.slice(i + 1)), result.concat(source[i]));
    })(arr, []);
}
perm(["01", "02", "03", "04"]);

count是计数器；fn是递归函数，它接收两个参数，一个是source（抓取池），另一个是result（排列结果）。

输出条件很简单，当抓取池没有可以取的元素时，说明已经排列完成，输出一个结果。否则呢，就通过循环抓取池，抓取一个值放进result数组。不断重复这个步骤，直到所有循环结束。

fn(source.slice(0, i).concat(source.slice(i + 1)), result.concat(source[i]));  

之所以用上面的方式是因为，slice方法会生成新的数组，不会对原数组造成影响；而result使用concat则是因为concat也会生成一个新的数组，而我们需要的参数就是两个数组。我们常用的push方法，也可以在末尾添加元素，不过它的返回值是数组长度。

全排列算法已经搞定，那么回过头来讲这个题目，这个题目有两种做法，一种比较朴素一点，每获得一个结果，我们判断一次是否符合题目要求，符合则计数器++，最后返回计数器的值。这种做法相当于列出所有的可能性，然后对每个结果字符串进行遍历，比对相邻序号的字符是否一样。想想就是个大工程，代码如下：

var permAlone=(function() {
  var count;   //计数器
  function judge(arr) {  //判断是否符合要求
      for(let i=0,l=arr.length;i<l-1;i++){
          if( arr[i]==arr[i+1] ){
            return;
          }
      }
      count++;
  }
  function fn(source, result) {
    if (source.length == 0){
      judge(result);
    }else{
       for (var i = 0; i < source.length; i++){
         fn(source.slice(0, i).concat(source.slice(i + 1)), result.concat(source[i]));
       }
    }
 
  }
  return function(str){
    var start=new Date();
    var arr=str.split("");
    count=0;
    fn(arr, []);
    console.log(new Date()-start+"ms");
    return count;
  };
 
})();
 
permAlone('abcdefa');

第二种方法呢，实在安排每个位置的时候，就进行判断，看这个结果是否符合要求，如果不符合就跳过，我在代码里加了验证运算速度的代码，可以比对一下两种方法在面对较长字符串时候的运行效率。

这里我用交换法，抓取法的话，应该比交换法还要简单一点。

代码如下：

var permAlone=(function(){
  var count;   //计数器
 
  function swap(arr,i,j) {    //交换
      if(i!=j) {
          var temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp;
      }
  }
  function fn(n,arr) { //为第n个位置选择元素
        for(var i=n;i<arr.length;i++) {
            swap(arr,i,n);
            if( arr[n]==arr[n-1] ){ //和前一个元素比对，是否相等，只有前面的元素是固定不变的
              swap(arr,i,n); //跳过前先复原
              continue;
            }  
 
            if(n<arr.length-1){  //判断条件这里需要改一下，只有当n为最后一个时才输出
              fn(n+1,arr); //为序号n+1的位置选取值
            }else{
              if( arr[n]!=arr[n-1] ){
                count++; //计数
              }
            }
            swap(arr,i,n);
        }
  }
 
  return function(str){
    var start=new Date();
    var arr=str.split("");
    count=0;   //计数器归零
    fn(0,arr);
    console.log(new Date()-start+"ms");
    return count;
  };
 
})();
 
permAlone('abcdefa');

Friendly Date Ranges

把常见的日期格式如：YYYY-MM-DD 转换成一种更易读的格式。

易读格式应该是用月份名称代替月份数字，用序数词代替数字来表示天 (1st 代替 1).

记住不要显示那些可以被推测出来的信息: 如果一个日期区间里结束日期与开始日期相差小于一年，则结束日期就不用写年份了。月份开始和结束日期如果在同一个月，则结束日期月份就不用写了。

另外, 如果开始日期年份是当前年份，且结束日期与开始日期小于一年，则开始日期的年份也不用写。

这个题目只要细心点就可以了，我的思路就是把月份数组通过闭包缓存起来，然后通过三元判断，将值确定好，最终的结果用字符串拼接的方式呈现把值拼起来就好。

var makeFriendlyDates=(function() {
  var mounth=["January","February","March","April","May","June","July","August","September","October","November","December"];
  var nth=["st","nd","rd","th"];
  var now_year=new Date().getFullYear();  //以上皆为缓存
 
  function num(x,max){   //处理数字
    x=(x<max)?x:max;
    return --x;
  }
 
  function judge(str1,str2){   //判断两个时间戳是否小于一年
    var cha=new Date(str2)-new Date(str1);
    if( cha/1000/3600/24<365 ){
      return true;
    }else{
      return false;
    }
  }
 
  return function(arr){
    var res=[];
    var time_start=arr[0].split("-");
    var time_end=arr[1].split("-");
 
    var end_year=( judge(arr[0],arr[1]) )?"":", "+time_end[0];
    var end_mounth=(time_start[0]==time_end[0] && time_end[1]==time_start[1])?"":mounth[time_end[1]-1]+" ";
    var end_day=parseInt(time_end[2]);
 
    if( arr[0]==arr[1] ){   //结束时间和开始时间一样的话
      return [mounth[time_end[1]-1]+" "+end_day+nth[num(end_day,4)]+", "+time_end[0] ];
    }
 
    var start_year=( judge(arr[0],arr[1]) && time_start[0]==now_year )?"":", "+time_start[0];
    var start_mounth=mounth[time_start[1]-1]+" ";
    var start_day=parseInt(time_start[2]);
    
    var res_start=start_mounth+start_day+nth[num(start_day,4)]+start_year;
    res.push(res_start);
    var res_end=end_mounth+end_day+nth[num(end_day,4)]+end_year;
    res.push(res_end);
 
    return res;
  };
 
})();
 
makeFriendlyDates(["2022-09-05", "2023-09-05"]);

Make a Person

用下面给定的方法构造一个对象.

方法有 getFirstName(), getLastName(), getFullName(), setFirstName(first), setLastName(last), and setFullName(firstAndLast).

所有有参数的方法只接受一个字符串参数。

这个题目挺好玩，我一开始直接用prototype做，然后挂了，它有个验证是：

Object.keys(bob).length 应该返回 6

所以最后我必须用上闭包去满足它这个要求。

代码如下：

var Person = (function() {
    var name;     //name闭包了
    return function(firstAndLast){
      name=firstAndLast;
      this.getFullName=function(){
        return name;
      };
      this.getLastName=function(){
        var arr=name.split(" ");
        return arr[1];
      };
      this.getFirstName=function(){
        var arr=name.split(" ");
        return arr[0];
      };
      this.setFirstName=function(first){
        var arr=name.split(" ");
        arr[0]=first;
        return name=arr.join(" ");
      };
      this.setLastName=function(last){
        var arr=name.split(" ");
        arr[1]=last;
        return name=arr.join(" ");
      };
      this.setFullName=function(firstAndLast){
        return name=firstAndLast;
      };
    };
})();
 
var bob = new Person('Bob Ross');
bob.getFullName();

Map the Debris

返回一个数组，其内容是把原数组中对应元素的平均海拔转换成其对应的轨道周期。

地球半径是 6367.4447 kilometers, 地球的GM值是 398600.4418, 圆周率为Math.PI。

题目倒是不难，只要找到公式，然后注意一下单位就可以，长度单位都是km，周期单位为s

var orbitalPeriod=(function() {
  //  r^3=G*m2*T^2/(4*pi^2)   m2是地球质量  G为6.67×10-11  r为轨道半径，到球心的距离
  var GM = 398600.4418;     //地球质量和G的乘积
  var earthRadius = 6367.4447;  //km
  var calculate=function(r){   //计算函数
    var top=4*Math.pow(Math.PI,2)*Math.pow((r+earthRadius),3);
    var res=Math.pow( (top/GM),0.5);
    return Math.round(res);
  };
  return function(arr){
    var res=[];
    for(let a of arr){
      let obj={};
      obj["name"]=a["name"];
      obj["orbitalPeriod"]=calculate(a["avgAlt"]);
      res.push(obj);
    }
    return res;
  };
})();
 
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);

Pairwise

找到你的另一半

举个例子：有一个能力数组[7,9,11,13,15]，按照最佳组合值为20来计算，只有7+13和9+11两种组合。而7在数组的索引为0，13在数组的索引为3，9在数组的索引为1，11在数组的索引为2。

所以我们说函数：pairwise([7,9,11,13,15],20) 的返回值应该是0+3+1+2的和，即6。

也许是受全排列那道题目的影响，我第一反应就是递归，因为每一个步骤都是相同的。每个元素都要在自己后面的元素中寻找匹配的。唯一需要注意的是，找到的序号需要缓存起来，如果这个序号已经在缓存中，就跳过，不需要进行匹配。

代码如下：

var pairwise=(function() {
  var res=[];  //放序号的缓存
  function judge(arr,val){
    for(let a of arr){
      if( a==val ){
        return true;
      }
    }
    return false;
  }
 
  function fn(n,arr,arg){   //递归函数
    for(let i=n,l=arr.length;i<l;i++){
      if( judge(res,i) || judge(res,n) ){
        continue;
      }
      if( n!=i && arr[n]+arr[i]==arg ){
          res=res.concat(n,i);
          break;
      }
    }
    if( n!=arr.length-1 ){
       fn(n+1,arr,arg);
    }
  }
 
  return function(arr, arg){
    res=[];
    if( arr.length==0 ){
      return 0;
    }
    fn(0,arr,arg);
    return res.reduce(function(a,b){
      return a+b;
    });
  };
})();
 
pairwise([1, 1, 1], 2);

最后

以上就是高级算法所有题目，如果有错误或者更好的做法，欢迎讨论。对代码有不理解的地方也欢迎提问。