fcc的中级算法题

核心提示：这是网上开源编程学习项目FCC的javascript中级编程题（Intermediate Algorithm Scripting(50 hours)），一共20题。建议时间是50个小时，对于刚入门的人来说，操作是有些难度了。

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

---

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

简单地说，就是两个数之间的连续自然数列求和问题。项数可以用Math.abs()方法求出。

function sumAll(arr) {
  var sum=(arr[1]+arr[0])*(Math.abs(arr[1]-arr[0])+1)/2;
  return sum;
}

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

思路：用indexOf方法判断某个元素是否在数组中，如果不在（返回-1），则把这个元素加到新数组内。

function diff(arr1, arr2) {
  var newArr = [];

  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;
}

这段代码有一定的重复，可以在第一次遍历的时候把重复检查的数组项cut掉。

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

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

基本上，罗马数字的规则我看了很久。方法就是把每个位数进行独自的判断。方法引自网上。

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);

另外一个好点的思路是：

function convert(num) { if(num<=0) return  null; var luoma=[['','I','II','III',"IV","V","VI","VII","VIII","IX"], ['','X','XX','XXX','XL','L','LX','LXX','LXXX','XC'], ['','C','CC','CCC','CD','D','DC','DCC','DCCC','CM']] ; var s=''; s= 'M'.repeat( Math.floor(num/1000)); num =num %1000; s+=luoma[2][Math.floor(num/100)]; num=num%100; s+=luoma[1][Math.floor(num/10)]; num=num%10; s+=luoma[0][num]; return s; }

var table = {1:"I", 4:"IV", 5:"V", 9:"IX", 10:"X", 40:"XL", 50:"L",90:"XC", 100:"C",400:"CD", 500: "D", 900:"CM", 1000:"M"};
var keys = Object.keys(table);
function convertToRoman(num) { if (num === 0) return; if (table.hasOwnProperty(num)) { return table[num]; } else { var temp = keys.filter((x) => x < num); return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1]); } }; console.log(convertToRoman(97));

var table = {1:"I", 4:"IV", 5:"V", 9:"IX", 10:"X", 40:"XL", 50:"L",90:"XC", 100:"C",400:"CD", 500: "D", 900:"CM", 1000:"M"};
var keys = Object.keys(table); //拿到对应的阿拉伯数字
function convertToRoman(num) { if (num === 0) return; //如果是0直接退出
if (table.hasOwnProperty(num)) { //要是阿拉伯数字跟参数一样
return table[num]; // 那就直接从表里放回相应罗马数字
} else {
var temp = keys.filter(function (x) { x < num });
//循环一遍阿拉伯数字表，把比 num 参数小的返回来给 temp 变量
// 比如 num 是97， 那就 temp 就是 [1,4,5,9,10,40,50,90]
return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1]);
//接着返回一个 table 最后一个元素，也就是 table[90], 也就是 'XC'
//然后再执行一次这个函数（递归），并给它 num - 90 为参数，也就是 7
//然后从头再走一遍
/* var temp = keys.filter(function (x) { x < num }); 现在这个 temp 数组是 [1, 4, 5], */
//继续递归变成 return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1])
//上面这句实际上就变成 return 'XC' + 'V' + convertToRoman(7 - 5)  //然后继续递归，直到最后 num 变成 0， 递归结束。得出结果 XCVII(90,5,1,1) } };

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

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

思路：说的非常拗口，可见这个翻译者水平是非常垃圾的。

用到的是Object.key方法。接下来就只是遍历。

function where(collection, source) {
  var arr = [];
  var arrSource=Object.keys(source);//把source的属性转化为数组

  // What's in a name?
  var i='',j=0;
  for(i in collection){//循环collection的元素
    var count=0;

    for(j=0;j<arrSource.length;j++){//针对source的属性进行循环，查找这个collection元素中是否有指定的source的属性
      if(collection[i][arrSource[j]]&&source[arrSource[j]]==collection[i][arrSource[j]]){
        count++;
      }
    }
    //判断：如果完全包含，这个collection的元素就被允许添加到里边。
    if(count==arrSource.length){
       arr.push(collection[i]);
    }
  }
  return arr;
}

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

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

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

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

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

function myReplace(str, before, after) {
  var i=0;
  var arr=str.split(' ');

  for(i=0;i<arr.length;i++){
    if(arr[i]==before){
      if(arr[i].toLowerCase()!=arr[i]){
        after=after.replace(after.charAt(0),after.charAt(0).toUpperCase());
      }//大小写转换，首字母大写
      arr.splice(i,1,after);//替换
    }
  }
  str=arr.join(' ');
  console.log(str);
  return str;
}

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

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

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

这其实是所谓儿童黑话游戏，

function translate(str) {
  var str2=str;
  var i=0;
  var consonant_cluster='';
  while(str2==str){
    switch(str[i]){
      case 'a':
      case 'e':
      case 'i':
      case 'o':
      case 'u':

        str=str+consonant_cluster;
        switch(consonant_cluster){
          case '':
            str=str+'way';
            break;
          default:
            str=str+'ay';
        }

        str=str.substring(consonant_cluster.length);
        break;
      default:
        consonant_cluster+=str[i];
        i+=1;
    }
  }
  return str;

}

后来翻看人家网站的源码，发现是用正则来写的

function translate(str) {
  str = str.replace(/\b([aeiou][a-z]*)\b/gi, "$1way"); // 表示，如果开头为aeiou，那么尾部加上way
  str = str.replace(/\b([bcdfghjklmnpqrstvwxy]+)([a-z]*)\b/gi, "$2$1ay"); // 如果开头为辅音，第二部分——第一部分——ay
  return str;
}

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

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

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

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

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

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

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

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

思路：

（1）如果传进来的不是一个按顺序来的字母队列，需要给他转成键码，排序，再转化为字符串。这段是题目之外的要求。

（2）接下来查找字符串排序后在a-z中的索引，然后根据索引用substring切割出来，用以比较（strCompare）

（3）遍历这个数组，找到没有的，

首先得实现字母排序。

function fearNotLetter(str) {
  var arrCover=[];

  for(var i=0;i<str.length;i++){
    arrCover.push(str[i].charCodeAt());
  }//转化为键码
  arrCover.sort(function(a,b){
    return a-b;
  });//重新排序
  str='';//清空
  for(i=0;i<arrCover.length;i++){
    str+=(String.fromCharCode(arrCover[i]));
  }//把转化出来的数组重新给字符串

  //获取索引
  var strAll='abcdefghijklmnopqrstuvwxyz';
  var indexOver=strAll.indexOf(str.charAt(str.length-1));
  var indexStart=strAll.indexOf(str.charAt(0));
  //切割出用以比较的字符串
  var strCompare=strAll.substring(indexStart,indexOver+1);
  var newStr='';

  if(strCompare==str){
    return undefined;
  }
  for(i=0;i<strCompare.length;i++){
    if(str.indexOf(strCompare[i])==-1){
      newStr+=strAll[i];
    }
  }
  console.log(newStr);
  return newStr;

}

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

基本布尔类型即 true 和 false。

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

}

boo(true);

好像没什么好说的。

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

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

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

思路，既然原来的第一个参数是以原来的排序为准的，那就直接让原来的数组加上桥接的数段。用concat方法。

function unite(arr1, arr2, arr3) {
  var newArr=[];
  for(var i=1;i<arguments.length;i++){
    for(var j=0;j<arguments[i].length;j++){
      if(arguments[0].indexOf(arguments[i][j])==-1){
        newArr.push(arguments[i][j]);
      }
    }
  }
  newArr=arguments[0].concat(newArr);
  console.log(newArr);
  return newArr;
}

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

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

参考资料：html实体

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('');
  console.log(str);
  return str;
}
convert('Stuff in "quotation marks"')

或许用正则会好些。

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

spinalCase("This Is Spinal Tap") 应该返回 "this-is-spinal-tap"。

spinalCase("thisIsSpinalTap") 应该返回 "this-is-spinal-tap"。

spinalCase("The_Andy_Griffith_Show") 应该返回 "the-andy-griffith-show"。

spinalCase("Teletubbies say Eh-oh") 应该返回 "teletubbies-say-eh-oh"。

思路：陷阱很多，总之是一步一步来，不能急躁。

function spinalCase(str) {
  str=str.replace(/([A-Z]+)/g,' $1');//在大写字母前面加个空格。用$来选择小括号
  str=str.replace(/\s+|_+/g,'-');//空格全部替换为-

  //以下是修bug
  if(str[0]=='-'){
    str=str.substring(1);
  }//去掉可能大写开头前面的-
  str=str.replace(/--/g,'-');//把中段的--（两个）替换为一个-。(因为下划线+大写导致生成了两个-)
  str=str.toLowerCase();//转换小写

  return str;
}

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

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

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

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

参考文档：博客园，Issue

方案1

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(400);

方案2：

//斐波拉契数列中奇数的求和函数：根据参数n索引生成内容。
//根据索引值n返回一个数组，第一个是斐波拉契最后一个数
//第二个是该数列奇数元素的的和。
function fib(n) {
    var a = 1, b = 1;
    var arr=[1,1];
    var tmp=0;

    for(var i=3; i<=n; i++){
        tmp = b;
        b = a + b;
        arr.push(b);
        a = tmp;
    }//构造斐波拉契数组

    var sum=0;
    for(i=0;i<arr.length;i++){
      if(arr[i]%2!==0){
        sum+=arr[i];
      }
    }//这个数组中arr奇数求和
    return [arr[arr.length-1],sum];
}

function sumFibs(num){
  var k=3;
  while(fib(k)[0]<=num){
    k++;
  }
  return fib(k-1)[1];
}

sumFibs(75024);

思路写在了comment里。

总的来说陷阱不多，关键是判断循环边界。

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

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

给定的数不一定是质数。

sumPrimes(10) 应该返回一个数字。

sumPrimes(10) 应该返回 17。

sumPrimes(977) 应该返回 73156。

思路，这里用的是筛法。所谓筛法是运用已有最开始的质数判断。是质数的放到数组中。下个数再进行判断。

function sumPrimes(num) {
  var arr=[2];
  var sum=0;
  for(var i=2;i<=num;i++){
    var bCheck=true;//假定为真
    for(var j=0;j<arr.length;j++){//循环数组
      if(i%arr[j]==0){//如果可以被质数整除
        bCheck=false;//判定为false
        break;//退出循环，用不着继续判断了。
      }
    }
    if(bCheck){
      arr.push(i);
    }
  }
  console.log(arr)
  for(var k=0;k<arr.length;k++){
    sum+=arr[k];
  }//求和
  return sum;
}

sumPrimes(977);

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

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

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

smallestCommons([1, 5]) 应该返回一个数字。

smallestCommons([1, 5]) 应该返回 60。

smallestCommons([5, 1]) 应该返回 60。

smallestCommons([1, 13]) 应该返回 360360。

思路：

（1）在此之前要了解欧拉算法求最大公约数。

简单的说，求两个数的最大公约数，用大数对小数求模，如果能被整除，则小数是这两个数的最大公约数。

如果不能整除，就用小数对余数再次求模，循环此过程直到返回能除尽的那个除数。就是最大公约数。

比如20和15，用20除以15余数为5，然后用15除以余数5，能够整除，所以返回出来的除数5为这两个数的最大公约数。

（2）有了最大公约数，就可以求最小公倍数。

最小公倍数的求法是：彼此之间的乘积除以最大公约数。

因为是求几个连续自然数之间的公倍数，所以，求出前两个最小公倍数之后，用这个最小公倍数和下一个值比较。然后就得出了新的最小公倍数。主要用的是递归的思想。

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]

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

find([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }) 应该返回 8。

find([1, 3, 5, 9], function(num) { return num % 2 === 0; }) 应该返回 undefined。

这题相比前面的简单很多了。注意：用break强制跳出循环。

function find(arr, func) {
  var num = 0;
  for(var i=0;i<arr.length;i++){
    if(func(arr[i])===true){
      num=arr[i];
      break;
    }
  }
  if(num===0){
    return undefined;
  }
  return num;
}

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

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

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

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

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

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

• Arguments object

• Array.shift()

• Array.slice()

这题翻译者好像高潮了，写了一大串lol卖队友的合理性。看篇幅还以为很难。

还是一个比较简单的思路：遍历这个数组，然后用func判断返回的是布尔值，根据布尔值插入一个占位的字符串‘false’。待循环结束之后用filter过滤掉就行了。

function drop(arr, func) {
  // Drop them elements.
  for(var i=0;i<arr.length;i++){
    if(func(arr[i])===false){
      arr.splice(i,1,'false');
    }else{
      break;
    }
  }
  arr=arr.filter(function(a){
    return a!='false';
  });
  console.log(arr);
  return arr;
}

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

teamroller([[["a"]], [["b"]]]) 应该返回 ["a", "b"]。

steamroller([1, [2], [3, [[4]]]]) 应该返回 [1, 2, 3, 4]。

steamroller([1, [], [3, [[4]]]]) 应该返回 [1, 3, 4]。

steamroller([1, {}, [3, [[4]]]]) 应该返回 [1, {}, 3, 4]。

思路：还是用递归的办法。判断数组用isArray。算是递归方法的简单实例。

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

  fun(arr);
  console.log(newArr);
  return newArr;
}

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

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

先写一个二进制字符串转化为十进制字符串的函数：parseInt

把10进制编码转换为字符用String.fromCharCode()方法。

function binaryAgent(str) {
  var arr=str.split(' ');
  var arr10=[];
  var newStr='';
  for(var i=0;i<arr.length;i++){
    arr10.push(parseInt(arr[i],2));
  }

  for(var j=0;j<arr10.length;j++){
    newStr+=String.fromCharCode(arr10[j]);
  }
  return newStr;
}

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

有了这个思路可以用map方法来实现更加精简的语句

所谓一行的写法：

return str.split(' ').map(function(a){return String.fromCharCode(parseInt(a,2))}).join('');

19.所有的东西都是真的！

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

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

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

every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex") 应该返回 true。

every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex") 应该返回 false。

every([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age") 应该返回 false。

every([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat") 应该返回 false

every([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat") 应该返回 true

every([{"single": "yes"}], "single") 应该返回 true

every([{"single": ""}, {"single": "double"}], "single") 应该返回 false

every([{"single": "double"}, {"single": undefined}], "single") 应该返回 false

every([{"single": "double"}, {"single": NaN}], "single") 应该返回 false

思路：这个看起来很复杂，其实只要做个json的for-in循环，就可以实现。

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

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

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

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

var sumTwoAnd = add(2);

sumTwoAnd(3) 返回 5。

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

思路：这个其实就是call()方法。jquery的链式操作就是这样实现的。

函数链式操作原理：返回函数本身。当然也可以返回一个别的函数。

function show(str){
    alert(str);
    return show;//关键
}
show('abc')('bcd')；

上述代码将弹出两个框，abc，和bcd。只要你想，可以无限地写下去。

你可以返回一个函数，那么下次操作时，得到的就是这个函数。

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

题目来源：

FCC中文网：https://www.freecodecamp.cn/

参考资料：

[1]《javascript高级程设计》第5,7章。 

[2] MOZILLA开发者社区：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript 

[3] 感谢gitter中文聊天室热心的网友