fcc中级算法题

1 Sum All Numbers in a Range 

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

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

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

这是一些对你有帮助的资源:

• Math.max()

• Math.min()

• Array.reduce()

function sumAll(arr) {
  var newarr = [];
  if(arr[0] > arr[1]){
    arr.sort(function(a,b){
      return a - b;
    });
  }
  console.log(arr);
  for(var i = arr[0]; i <= arr[1]; i++){
    newarr.push(i);    
  }
  var sum = newarr.reduce(function(x,y){
    return x + y;
  });
  return sum;
}

sumAll([1, 4]);

 

2 Diff Two Arrays

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

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

这是一些对你有帮助的资源:

• Comparison Operators

• Array.slice()

• Array.filter()

• Array.indexOf()

• Array.concat()

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

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

 

3 Roman Numeral Converter 

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

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

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

这是一些对你有帮助的资源:

• Roman Numerals

• Array.splice()

• Array.indexOf()

• Array.join()

function convert(num) {
  var alpha = [ 'I', 'V', 'X', 'L', 'C', 'D', 'M' ], roman = "", bit = 0;
        while (num > 0){  
            var tempnum = num % 10;
            switch (tempnum){  
                case 3:{   
                    roman = alpha[bit] + roman;  
                    tempnum--;
                }  
                case 2:{  
                    roman = alpha[bit] + roman;  
                    tempnum--;
                }  
                case 1:{  
                    roman = alpha[bit] + roman;  
                    break;  
                }  
                case 4:{  
                    roman = alpha[bit + 1] + roman;
                    roman = alpha[bit] + roman;  
                    break;  
                }  
                case 8:{  
                    roman = alpha[bit] + roman; 
                    tempnum--;
                }  
                case 7:{  
                    roman = alpha[bit] + roman; 
                    tempnum--;
                }  
                case 6:{  
                    roman = alpha[bit] + roman;  
                    tempnum--;
                }  
                case 5:{  
                    roman = alpha[bit + 1] + roman;  
                    break;  
                }  
                case 9:{ 
                    roman = alpha[bit + 2] + roman; 
                    roman = alpha[bit] + roman; 
                    break;  
                }  
                default:{  
                    break;  
                }  
            }  
            bit += 2;  
            num = Math.floor(num / 10);  
        }  
        return roman;
}

convert(36);

 

4 Where art thou 

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

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

如果你被难住了，记得使用 Read-Search-Ask编写你自己的代码。

这是一些对你有帮助的资源:

• Global Object

• Object.hasOwnProperty()

• Object.keys()

function where(collection, source) {
  var arr = [];
  // What's in a name?
  
  var sou = Object.keys(source);
  for(var i in collection){
    var count = 0;
    for(var j = 0; j < sou.length; j++){
      if(collection[i][sou[j]] && source[sou[j]] == collection[i][sou[j]]){
        count++;
      }
    }
    if(count == sou.length){
      arr.push(collection[i]);
    }
  }
  
  return arr;
}

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

 

5 Search and Replace 

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

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

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

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

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

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

这是一些对你有帮助的资源:

• Array.splice()

• String.replace()

• Array.join()

function myReplace(str, before, after) {
  var newstr = str.split(' ');
  for(var i = 0; i < newstr.length; i++){
    if(newstr[i] == before){
      if(newstr[i].toLowerCase() != newstr[i]){
        after = after.replace(after.charAt(0),after.charAt(0).toUpperCase());
      }
      newstr.splice(i,1,after);
    }
  }
  newstr = newstr.join(' ');
  return newstr;
}

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

 

6 Pig Latin

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

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

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

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

这是一些对你有帮助的资源:

• Array.indexOf()

• Array.push()

• Array.join()

• String.substr()

• String.split()

function translate(str) {
  str = str.split('');
  if(str[0] == 'a' || str[0] == 'o' || str[0] == 'e' || str[0] == 'i' || str[0] == 'u'){
     str.push('way');
     str = str.join('');
     return str;
  }else{
    for(var i = 0; i < str.length; i++){
      if(str[i] == 'a' || str[i] == 'o' || str[i] == 'e' || str[i] == 'i' || str[i] == 'u'){
        var back = str.splice(0,i);
        back = back.join('');
        str.push(back,'ay');
        str = str.join('');
        return str;
      }
    }
  }
}

translate("consonant");

 

7 DNA Pairing

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

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

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

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

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

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

这是一些对你有帮助的资源:

• Array.push()

• String.split()

function pair(str) {
  var newstr = '';
  var arr = [];
  for(var i = 0; i < str.length; i++){
    switch(str[i]){
      case 'A':
        newstr += 'T';
        break;
      case 'T':
        newstr += 'A';
        break;
      case 'C':
        newstr += 'G';
        break;
      case 'G':
        newstr += 'C';
        break;
    }
    arr.push([str[i],newstr[i]]);
  }
  return arr;
}

pair("GCG");

 

8 Missing letters

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

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

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

这是一些对你有帮助的资源:

• String.charCodeAt()

• String.fromCharCode()

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

fearNotLetter("abce");

 

9 Boo who 

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

基本布尔类型即 true 和 false。

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

这是一些对你有帮助的资源:

• Boolean Objects

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

boo(null);

 

10 Sorted Union

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

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

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

请参照下面验证判断中的例子。

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

这是一些对你有帮助的资源:

• Arguments object

• Array.reduce()

function unite(arr1, arr2, arr3) {
  var arr = Array.prototype.slice.call(arguments);
  var newarr = [];
  var endarr = [];
  for(var i = 0; i < arr.length; i++){
    for(var j = 0; j < arr[i].length; j++){
       newarr.push(arr[i][j]);
    }
  }
  for(var k = 0; k < newarr.length; k++){
    if(newarr.indexOf(newarr[k]) == k){
      endarr.push(newarr[k]);
    } 
  }
  return endarr;
}

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

 

11 Convert HTML Entities 

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

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

这是一些对你有帮助的资源:

• RegExp

• HTML Entities

function convert(str) {
  // :)
  var i=0;
  var arr=str.split("");

  for(i=0;i<arr.length;i++){
    switch(arr[i]){
      case '&':
        arr.splice(i,1,'&amp;');
        break;
      case '>':
        arr.splice(i,1,'&gt;');
        break;
      case '<':
        arr.splice(i,1,'&lt;');
        break;
      case "'":
        arr.splice(i,1,'&apos;');
        break;
      case '"':
        arr.splice(i,1,'&quot;');
        break;
    }
  }
  str=arr.join('');
  return str;
}
convert("Dolce & Gabbana");

 

12 Spinal Tap Case

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

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

这是一些对你有帮助的资源:

• RegExp

• String.replace()

function spinalCase(str) {
  // "It's such a fine line between stupid, and clever."
  // --David St. Hubbins
  str = str.replace(/([A-Z]+)/g,' $1');
  str = str.replace(/\s+|_+/g,'-');
  if(str[0] == '-'){
    str = str.substring(1);
  }
  str = str.replace(/--/g,'-');
  str = str.toLowerCase();
  return str;
}

spinalCase('This Is Spinal Tap');

 

13 Sum All Odd Fibonacci Numbers 

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

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

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

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

参考文档：博客园，Issue

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

这是一些对你有帮助的资源:

• Remainder

var sumFibs = function() {
    var cache = [1, 1];
    return function (n) {
        if (n >= cache.length) {
            for (var i = cache.length; i < n ; i++) {
                cache[i] = cache[i - 2] + cache[i - 1];
            }
        }
        var arr = cache.filter(function(val){
           return val % 2 !== 0 && val <= n;
         });
        return arr.reduce(function(pre,next){
          return pre + next;
        });
    };

}();

sumFibs(4);

 

14 Sum All Primes

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

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

给定的数不一定是质数。

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

这是一些对你有帮助的资源:

• For Loops

• Array.push()

function sumPrimes(num) {
  var arr = [2];
  var sum = 0;
  for(var i = 2; i <= num; i++){
    var pri = true;
    for(var j = 0; j < arr.length; j++){
      if(i % arr[j] === 0){
        pri = false;
        break;
      }
    }
    if(pri){
      arr.push(i);
    }
  }
  for(var k = 0; k < arr.length; k++){
    sum += arr[k];
  }
  return sum;
}

sumPrimes(10);

 

15 Smallest Common Multiple

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

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

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

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

这是一些对你有帮助的资源:

• Smallest Common Multiple

function smallestCommons(arr) {
   arr = arr.sort(function(a,b){
    return a-b;
  });
  function fun(m,n){
    if(m % n === 0) return n;
    return fun(n, m % n);
  }
  var num = arr[0];
  for(var i = arr[0] + 1; i <= arr[1]; i++){
    num *= i / fun(num,i);
  }
  return num;
}


smallestCommons([1,5]);

 

16 Finders Keepers

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

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

这是一些对你有帮助的资源:

• Array.filter()

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

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

 

17 Drop it 

队友该卖就卖，千万别舍不得。

当你的队伍被敌人包围时，你选择拯救谁、抛弃谁非常重要，如果选择错误就会造成团灭。

如果是AD或AP，优先拯救。

因为AD和AP是队伍输出的核心。

其次应该拯救打野。

因为打野死了对面就可以无所顾虑地打龙。

最后才是辅助或上单。

因为辅助和上单都是肉，死了也不会对团队造成毁灭性影响，该卖就卖。

但真实中的团战远比这要复杂，你的队伍很可能会被敌人分割成2个或3个部分。

当你救了一个重要的人时，很可能其他队友也会因此获救。

举个例子：

辅助和AD经常是在一起的，打野和中单在一起，上单经常一个人。

你救了AD，辅助也经常因此获救。

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

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

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

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

这是一些对你有帮助的资源:

• Arguments object

• Array.shift()

• Array.slice()

 

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

drop([1, 2, 3], function(n) {return n < 3; });

 

18 Steamroller

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

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

这是一些对你有帮助的资源:

• Array.isArray()

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

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

 

19 Binary Agents 

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

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

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

这是一些对你有帮助的资源:

• String.charCodeAt()

• String.fromCharCode()

function binaryAgent(str) {
  var arr = str.split(' ');
  var newarr = [];
  var news = [];
  var newstr = '';
  for(var i = 0; i < arr.length; i++){
    newarr.push(parseInt(arr[i],2));
  }
  for(var j = 0; j < newarr.length; j++){
    news.push(String.fromCharCode(newarr[j]));
  }
  newstr = news.join('');
  return newstr;
}

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

 

20 Everything Be True

所有的东西都是真的！

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

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

提示：你可以有多种实现方式，最简洁的方式莫过于Array.prototype.every()。

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

 

function every(collection, pre) {
  // Is everyone being true?
  var bCheck = true;
  for(var i in collection){
    if(!collection[i][pre]){
      bCheck = false;
    }
  }
  return bCheck;
}

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

 

21 Arguments Optional

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

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

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

var sumTwoAnd = add(2);

sumTwoAnd(3) 返回 5。

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

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

这是一些对你有帮助的资源:

• Closures

• Arguments object

function add(x) {
  if(typeof x == 'number' && typeof arguments[1] == 'number' && arguments.length == 2){
    return arguments[0] + arguments[1];
  }else if(typeof x == 'number' && arguments.length == 1){
    return function(y){
      if(typeof y == 'number' && arguments.length == 1){
        return x + y;
      }
    };
  }else{
    return undefined;
  }
}

add(2,3);