FreeCodeCamp 中级算法（个人向）

freecodecamp 中级算法地址戳这里

Sum All Numbers in a Range

我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。

 function sumAll(arr) {
   arr.sort(function(a,b){
     return a-b;
   });
   var a=arr[0];
   var sum=arr[0];
   while( a<arr[1] ){
     a++;
     sum+=a;
   }
   return sum;
 }

 sumAll([1, 4]);

Diff Two Arrays

比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。

 function diff(arr1, arr2) {
   var newArr = [];
   // Same, same; but different.
   var len,long,short;
   if( arr1.length<=arr2.length ){
     len=arr1.length;
     short=arr1;
     long=arr2;
   }else{
     len=arr2.length;
     short=arr2;
     long=arr1;
   }

   for(var i=0;i<len;i++){
     var index=long.indexOf( short[i] );
     if( index==-1 ){
       newArr.push( short[i] );
     }else{
       long.splice(index,1);
     }
   }
   newArr=newArr.concat(long);
   return newArr;
 }

 diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);

Roman Numeral Converter

将给定的数字转换成罗马数字

var convert=(function() {
  //1 5 10 50 100 500 1000
  //I V  X  L  C   D   M
  var arr=[["I","V"],["X","L"],["C","D"],["M"]];  //检索的数组缓存起来

  return function(num){
    var str="";
    var num_arr=String(num).split("");
    for(var i=0,l=num_arr.length;i<l;i++){ //对每一位的数字进行处理
      var x=parseInt( num_arr[i] );
      str+=handle(arr[l-1-i],arr[l-i],x); //传参
    }
    return str;
  };

})();

function handle(arr,big_arr,x){ //这里是对输入的x数字进行处理，arr和big_arr根据传参确定，这里对应的是罗马数字规则
  var res="";
  if( x==0 ){
    return res;
  }

  if( x<=3 ){
      for(var i=0;i<x;i++){
        res+=arr[0];
      }
  }else if( x==4 ){
    res=arr[0]+arr[1];
  }else if( x==9 ){
    res=arr[0]+big_arr[0];
  }else{   //大于等于5但是小于9的
    var cha=x-5;
    res=arr[1];
    for(var i=0;i<cha;i++){
      res+=arr[0];
    }
  }
  return res;
}

convert(36);

Where art thou

写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。

function where(collection, source) {
  var arr = [];
  var target=Object.keys(source);  //数组
  outer:for(var i in collection){
    for(var j in target){
      if( collection[i].hasOwnProperty(target[j])===false || collection[i][target[j]]!=source[target[j]] ){
        continue outer;
      }
    }

    arr.push(collection[i]);

  }
  // What's in a name?
  return arr;
}

where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });

Search and Replace

使用给定的参数对句子执行一次查找和替换，然后返回新句子。

function myReplace(str, before, after) {  //查找替换
  var arr=str.split(" ");
  var index=arr.indexOf(before);
  arr.splice(index,1,change(before,after));

  return arr.join(" ");
}

function change(before,after){   //保证单词大小写不变
  var isLower=judge(before);  //小写返回true
  var change_arr=after.split("");

  change_arr[0]=isLower?change_arr[0].toLowerCase():change_arr[0].toUpperCase();

  return change_arr.join("");
}

function judge(str){
  if( str.substr(0,1).toLowerCase()==str.substr(0,1) ){  //判断首字母大小写
    return true;
  }else{
    return false;
  }
}

myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

Pig Latin

把指定的字符串翻译成 pig latin

常规解法：

function translate(str) { //主体函数
  var num=getnum(str);  //搜索结果
  if ( num==-1 ){
    return "没有元音";
  }else if( num==0 ){
    return str+"way";
  }else{
    return str.substring(num,str.length)+str.substring(0,num)+"ay";
  }
}

function getnum(str){   //搜索str中是否有元音字母
  return search(str,"a","e","i","o","u");
};

function search(){  //搜索是否含有一些字符，有就返回序号，否则返回-1
  var str=[].shift.apply(arguments);
  var n;
  var flag=true;
  for(var i=0,l=arguments.length;i<l;i++){
    var nth=str.indexOf(arguments[i]);
    if( nth>-1 ){
      n=(n==undefined)?nth:(n<nth?n:nth);
      flag=false;
    }
  }
  return flag?-1:n;
};

translate("consonant");

正则解法：

function translate(str){
  var str2=str.replace(/[aeiou]/g,"|");
  var index=str2.indexOf("|");
  if ( index==-1 ){
    return "没有元音";
  }else if( index==0 ){
    return str+"way";
  }else{
    return str.substring(index,str.length)+str.substring(0,index)+"ay";
  }
}

translate("consonant");

DNA Pairing

DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。

function pair(str) {
  var arr=[["A","T"],["C","G"]];
  var result=[];
  var str_arr=str.split("");

  for(var i in str_arr){
    for(var j in arr){
      var index=arr[j].indexOf( str_arr[i] );
      if( index!=-1 ){
        result.push( [str_arr[i],arr[j][1-index]] );
      }
    }
  }
  return result;
}

pair("GCG");

Missing letters

从传递进来的字母序列中找到缺失的字母并返回它。

function fearNotLetter(str) {
  var len=str.length;
  var before,after;
  var res="";
  if( str.charCodeAt(len-1)-str.charCodeAt(0)+1==len ){  //首尾相差的数量正确，返回undefined
    return undefined;
  }
  for(var i=0;i<len;i++){  //遍历字符串的序号
    before=str.charCodeAt(i);
    after=str.charCodeAt(i+1);
    if( after-before>1 ){   //发现相邻不连续
      do{
        res+=String.fromCharCode(before+1);
        before++;
      }while( after-before>1 );

      return res;
    }
  }
}

fearNotLetter("abce");

Boo who

检查一个值是否是基本布尔类型，并返回 true 或 false。

function boo(bool) {
  // What is the new fad diet for ghost developers? The Boolean.
  if( typeof(bool)==="boolean" ){
    return true;
  }else{
    return false;
  }
}

boo(null);

Sorted Union

写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。

function unite() {
  var arr=[];
  for(let i in arguments){
    arr.push( arguments[i] );
  }
  var res=arr.reduce(function(a,b){
    for(var i=0,l=a.length;i<l;i++){
      var index=b.indexOf(a[i]);
      if( index!=-1 ){
        b.splice(index,1);
      }
    }
    return a.concat(b);
  });
  return res;
}

unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);

Convert HTML Entities

将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。

function convert(str) {
  // :)
  var list={
    "&":"&",
    "<":"&lt;",
    ">":"&gt;",
    "\"":"&quot;",
    "\'":"&apos;"
  };
  for(var key in list){
    str=str.replace(new RegExp(key,"g"),list[key]);
  }
  return str;
}

convert("Dolce & Gabbana");

Spinal Tap Case

将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词

function spinalCase(str) {
  // "It's such a fine line between stupid, and clever."
  // --David St. Hubbins
  str=str.replace(/_/g," ");
  var arr=str.split(" ");
  if( arr.length==1 ){
    str=str.replace(/([A-Z])/g," $1");
  }

  str=str.trim().toLowerCase().replace(/[\s]/g,"-");

  return str;
}

spinalCase('thisIsSpinalTap');

个人方法感觉很多地方啰嗦了点，可以进一步改进。

Sum All Odd Fibonacci Numbers

给一个正整数num，返回小于或等于num的斐波纳契奇数之和。

function sumFibs(num) {
  var arr=get(num);  //获取数列
  var res=arr.filter(function(a){   //筛选出奇数
    return a%2!==0;
  }).reduce(function(a,b){   //返回奇数之和
    return a+b;
  });
  return res;
}

function get(num){  //返回一个斐波纳契数列，最后一位小于等于num
  var arr=[1];
  var sum=1;
  var before=0;
  var after=1;
  while( sum<=num ){
    arr.push(sum);
    before=after;
    after=sum;
    sum=before+after;
  }
  return arr;
}
sumFibs(4);

Sum All Primes

求小于等于给定数值的质数之和。

function sumPrimes(num) {
  var res=getarr(num).reduce(function(a,b){
    return a+b;
  });
  return res;
}

function getarr(num){   //返回质数数组
  var arr=[];
  outer:for(var i=2;i<=num;i++){
    for(var j=2;j<i;j++){
      if( i%j===0 ){
        continue outer;
      }
    }

    arr.push(i);
  }
  return arr;
}

sumPrimes(10);

Smallest Common Multiple

找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。

function smallestCommons(arr) {
  var res=make_arr(arr).reduce(function(a,b){  //利用reduce,两两求最小公倍数
    return gcd(a,b);
  });
  return res;
}

function make_arr(arr){ //返回包含给定参数和他们之间连续数字的顺序数组
  arr.sort(function(a,b){
    return a-b;
  });
  var max=arr.pop();
  var num=arr[0];
  while( num<max ){
    num++;
    arr.push(num);
  }
  return arr;

}

function gcd(a,b){  //遍历,获得a,b的最小公倍数
  var max=Math.max(a,b),
      min=Math.min(a,b),
      count;

  for(var i=1;i<=max;i++){
    count=min*i;
    if(count%max===0){
      return count;
    }
  }

}

smallestCommons([1,5]);

Finders Keepers

写一个 function，它浏览数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。

function find(arr, func) {
  return arr.filter(func)[0];
}

find([1, 2, 3, 4], function(num){ return num % 2 === 0; });

Drop it

让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。

function drop(arr, func) {
  // Drop them elements.
  var top=0;
  for(var l=arr.length;top<l;top++){
    if( func(arr[top]) ){
      break;
    }
  }
  return arr.slice(top);
}

drop([1, 2, 3, 4], function(n) {return n >= 3;});

Steamroller

对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。

function steamroller(arr) {
  // I'm a steamroller, baby
  while (arr.some(item => item instanceof Array)) {
    arr = [].concat(...arr);
  }
  return arr;
}

steamroller([1, [2], [3, [[4]]]]);

Binary Agents

传入二进制字符串，翻译成英语句子并返回。

function binaryAgent(str) {
  var arr=str.split(" ");
  for(var i in arr){
    arr[i]=String.fromCharCode( parseInt(arr[i],2) );
  }
  var res=arr.join("");
  return res;
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

Everything Be True

完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。

function every(collection, pre) {
  // Is everyone being true?
  var res=collection.every(function(item){
    return item[pre];
  });
  return res;
}

every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

Arguments Optional

创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。

function add() {
  var arr=[].concat(...arguments);
  if( arr.some(function(ele){
    return typeof ele!="number";
  }) ){    //参数出现非数字类型，返回undefined
    return undefined;
  }
  if( arr.length==2 ){
    return arr[0]+arr[1];
  }
  return function(a){
    if( typeof a != "number" ){  //同上
      return undefined;
    }
    return a+arr[0];
  };
}

add(2)(3);