FCC 中级算法

中级算法就不详述了，  好好看应该都能看懂= =     ，写程序应该还是要给自己的程序好好备注的    ...

Sum All Numbers in a Range

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

最小的数字并非总在最前面。

function sumAll(arr) {
  var max = Math.max(...arr);
  var min = Math.min(...arr);
  for (var i = min; i <= max; i++) {
    arr[i-min] = i;
  }
  var val = arr.reduce(function(a,b,c,d){
      return a+b;
  });
  return val;
}

 

Diff Two Arrays

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

function diff(arr1, arr2) {
  var newArr = [];
  var newArr1 = [];
  newArr1 = arr1;
  // Same, same; but different.
  for (var i = 0; i < arr2.length; i++) {
    if(arr1.indexOf(arr2[i]) == -1){
     newArr1.unshift(arr2[i]);
    } else {
     newArr.unshift(arr2[i]);
    }
  }

  newArr1 = newArr1.filter(function(a,b,c){
      if(newArr.every(function(d,e,f){
        return d!=a;
      }) === true){
        return true;
      }
  });
  return newArr1;
}

 

Roman Numeral Converter

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

所有返回的 罗马数字 都应该是大写形式。

如果你被难住了，记得使用 Read-Search-Ask尝试与他人结伴编程、编写你自己的代码。

function convert(num){
  var val = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
  var nams = ["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"];
  var str = "";
  val.forEach(function(item , index , array){
        while(num >= item){
          str += nams[index];
          num -= item;
        }
  });
  return str;
}

 

Where art thou

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

例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。

function where(collection, source) {
  var arr = [];
  // What's in a name?
  var arr1 = [];
  var val = 0 ;
  arr = Object.keys(source);
  for(var key in collection){
    var bool = arr.every(function(item,index,array){
        return collection[key].hasOwnProperty(item) && collection[key][item] == source[item];  
    });
    if(bool){
        arr1[val]=collection[key];
        val++;
      }
  }
  return arr1; 
}

 

Search and Replace

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

第一个参数是将要对其执行查找和替换的句子。

第二个参数是将被替换掉的单词（替换前的单词）。

第三个参数用于替换第二个参数（替换后的单词）。

注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。

function myReplace(str, before, after) {
  if(before[0] >= 'A' && before[0] <= 'Z'){
    function firstUpperCase(str) {
  return str.toLowerCase().replace(/^\S/g,function(s){return s.toUpperCase();});
}
   after = firstUpperCase(after);
  }
  var regExp = new RegExp(""+before+"", "g");
  str = str.replace(regExp, after);
  return str;
}

 

Pig Latin

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

Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。

如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。

function translate(str) {

    var temp=[];

    var answer;

    temp=str.split('');//将str分解为单个字符存入数组

    var i=0;

    while(temp[i]!='a'&&temp[i]!='o'&&temp[i]!='i'&&temp[i]!='e'&&temp[i]!='u'){

      i++;//如果不是元音i++，如果是元音推出循环

    }

    answer=str.substr(i);//将str不是元音的部分提出

    answer+=str.substr(0,i);//将str的元音部分加在answer之后

    if(i==0){

      answer+="way";//首字母为元音加 way

    }else{

      answer+="ay";//不是加 ay

    }

    return answer;

}

 

DNA Pairing

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

Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。

在每一个数组中将给定的字母作为第一个碱基返回。

例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]

字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。

function pair(str) {
  var arr = str.split("");
    var pair = '';
    var result = arr.map(function(item,index,array){
        switch(item){
            case 'A':
                pair = 'T';
                break;
            case 'T':
                pair = 'A';
                break;
            case 'C': 
                pair = 'G';
                break;
            case 'G':
                pair = 'C';
                break;
        }
        return [item,pair];
    });
    return result;
}

 

Missing letters

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

如果所有字母都在序列中，返回 undefined。

function fearNotLetter(str) {
  var arr = [];
  for (var i = 0; i < str.length; i++) {
    arr[i] = str.charCodeAt(i);
  }
  for (var i = arr[0]; i < arr[0] + arr.length; i++) {
    if(arr[i - arr[0]] != i) return (String.fromCharCode(i));
  }
  return;
}

 

Boo who

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

基本布尔类型即 true 和 false

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

 

Sorted Union

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

换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。

非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。

function unite() {
  var arr1 = [];
  for (var i = 0; i < arguments.length; i++) {
    arr1[i] = arguments[i];
  }
  var arr = arr1.reduce(function(a , b){
      return a.concat(b);
  });
   arr.forEach(function(item , index , array){
      arr.forEach(function(a , b , c){
          if(item == a && b != index){
              arr.splice(b,1);
          }
      });
  });
  return arr;
}

 

Convert HTML Entities 

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

function convert(str) {
  // :)
  var chars = ["&", "<", ">", '"', "'"];
  var htmls = ["&amp;" , "&lt;" , "&gt;" , "&quot;" , "&apos;"];
  chars.forEach(function(item , index , array){
      var regExp = new RegExp(""+item+"","g");
       str = str.replace(regExp,htmls[index]);
  });
  return str;
}

 

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(/[^A-Za-z]/g,"-");
  str = str.replace((/([a-z])([A-Z])/g),"$1-$2");
  str = str.toLowerCase();
  return str;
}

 

Sum All Odd Fibonacci Numbers

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

斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。

例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。

提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。

function sumFibs(num) {
  var val = 1 ,  val1 =1 ,sum = 1 , temp;
  while(num > 2 && val1 <= num){
    if(val1 % 2 != 0)
    sum +=  val1; 
    temp = val;
    val  = val1;
    val1 = temp + val1;
  }
  return sum;
}

 

Sum All Primes

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

只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。

给定的数不一定是质数。

function sumPrimes(num) {
  var sum = 0;
  for (var i = 2; i <= num; i++) {
      for(j=2 ; j < i ; j++){
        if(i % j == 0)break;
      }
      if(j == i) sum += i;
  }
  return sum;
}

 

Smallest Common Multiple

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

范围是两个数字构成的数组，两个数字不一定按数字顺序排序。

例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。

function smallestCommons(arr) {
  // 求最大公约数
  function gcd(a,b){
    if(a % b === 0)return b;
    else {
      return gcd(b , (a % b));
    }
}
  // 求最小公倍数
  function scm(a,b){
    return (a * b)/(gcd(a , b));
}
  arr = arr.sort(function(a , b){
      return a-b;
  });
  var sum = arr[0];
  for (var i = arr[0]+1; i <= arr[1]; i++) {
    sum = scm(sum , i);
  }
  return sum;
}

 

Finders Keepers 

写一个 function，它遍历数组 arr，并返回数组中第一个满足 func 返回值的元素。举个例子，如果 arr 为 [1, 2, 3]，func 为 function(num) {return num === 2; }，那么 find 的返回值应为 2。

function find(arr, func) {
  for(i = 0; i < arr.length ; i++){

    if(func(arr[i]))return arr[i];
  }
}

 

Drop it

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

第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。

最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。

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

 

Steamroller

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

function steamroller(arr) {
  // I'm a steamroller, baby
  var brr = [];
  function roller(arr1){
  for (var i = 0; i < arr1.length; i++) {
    if(Array.isArray(arr1[i])) roller(arr1[i]);
    else brr.push(arr1[i]);
  }
}
  roller(arr);
  return brr;
}

 

 

Binary Agents

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

二进制字符串是以空格分隔的。

如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程、编写你自己的代码。

function binaryAgent(str) {
  var arr = str.split(" ");
  arr.forEach( function(element, index) {
    // statements
    arr[index] = String.fromCharCode(parseInt(element, 2));
  });
  str = arr.join("");
  return str;
}

 

Everything Be True

所有的东西都是真的！

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

记住：你只能通过中括号来访问对象的变量属性(pre)。

function every(collection, pre) {
  // Is everyone being true?
  pre = collection.every(function(item, index, array) {
    return item.hasOwnProperty(pre) && Boolean(item[pre]);
  });
  return pre;
}

 

Arguments Optional

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

例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。

调用这个有一个参数的返回的 function，返回求和的结果：

var sumTwoAnd = add(2);

sumTwoAnd(3) 返回 5。

function isString(obj) {   //这是个收藏函数（推荐），对于这题没用到 测试传进来的参数是不是字符串
    return obj === obj+''; //原理就是将右边的转成字符串   若obj真是字符串那就相等，若不是那左边不是字符串右边是字符串就会返回false
}  

function isBoolean(obj) {  
    var val = !!obj;    //双非装换成布尔值   原理同上
    return obj === !!obj  ;
}

function isNumber(obj) {  //本题用到的函数   +obj 若是，值不变 若obj不是数字则右边为NaN  NaN与任何值比较都返回false 包括它本身 
    return obj === +obj  ;
} 

function add() {
  var val1 = arguments[0];
  if(arguments.length == 1){
    if(isNumber(val1) == false) return;
    return function(val2) {
      if(isNumber(val2) == false) return;
      return val1 + val2;
    }
  }
  else if(arguments.length == 2) {
    var val2 = arguments[1];
    if(isNumber(val2) == false) return;
    return val1 + val2;
  }
}

 

 

如果两个参数都不是有效的数字，则返回 undefined。