FCC Intermediate Algorithm Scripting
这次是FCC上的中级算法题，题目量比较大，但是难题不多。所以简单的部分我就只贴代码，思路就不一一概述了。
1.Sum All Numbers in a Range
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
function sumAll(arr) { return 1; } sumAll([1, 4]) 应该返回 10。 sumAll([4, 1]) 应该返回 10。 sumAll([5, 10]) 应该返回 45。 sumAll([10, 5]) 应该返回 45。
思路：没有用到推荐的方法，直接看成一个等差数列求和。
function sumAll(arr) {
var a = arr[0];
var b = arr[1];
var n = Math.abs(a-b) + 1;
var result = (a+b) * n / 2;
return result;
}
2.Diff Two Arrays
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
function diff(arr1, arr2) { var newArr = []; // Same, same; but different. return newArr; } ["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"] 应该返回 ["pink wool"]。 ["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"] 应该返回 ["diorite", "pink wool"]。 ["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"] 应该返回 []。 [1, 2, 3, 5], [1, 2, 3, 4, 5] 应该返回 [4]。 [1, "calf", 3, "piglet"], [1, "calf", 3, 4] 应该返回 ["piglet", 4]。 [], ["snuffleupagus", "cookie monster", "elmo"] 应该返回 ["snuffleupagus", "cookie monster", "elmo"]。 [1, "calf", 3, "piglet"], [7, "filly"] 应该返回 [1, "calf", 3, "piglet", 7, "filly"]。
思路:这题推荐了很多方法，我的方法可能笨一点，用indexOf相互查找差异,加入到一个新数组并回返回，这样做需要用到2次for循环。后来想到另一个方法，能否先将2个数组合并，在取出没有重复的元素。
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;
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);
3.Roman Numeral Converter
将给定的数字转换成罗马数字。所有返回的 罗马数字 都应该是大写形式。
思路：没有啥思路，解法很多，百度也能找到答案，直接贴其中一个解法吧
function convert(arabic){
var alpha = [ 'I', 'V', 'X', 'L', 'C', 'D', 'M' ], roman = "", bit = 0;
while (arabic > 0){
var tempnum = arabic % 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;
arabic = Math.floor(arabic / 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" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
function where(collection, source) { var arr = []; // What's in a name? return arr; } where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" }) 应该返回 [{ first: "Tybalt", last: "Capulet" }]。 where([{ "a": 1 }, { "a": 1 }, { "a": 1, "b": 2 }], { "a": 1 }) 应该返回 [{ "a": 1 }, { "a": 1 }, { "a": 1, "b": 2 }]。 where([{ "a": 1, "b": 2 }, { "a": 1 }, { "a": 1, "b": 2, "c": 2 }], { "a": 1, "b": 2 }) 应该返回 [{ "a": 1, "b": 2 }, { "a": 1, "b": 2, "c": 2 }]。 where([{ "a": 1, "b": 2 }, { "a": 1 }, { "a": 1, "b": 2, "c": 2 }], { "a": 1, "c": 2 }) 应该返回 [{ "a": 1, "b": 2, "c": 2 }]。
思路：这道题，我认为他是相当有趣，实用性也很高。如果你没能理解究竟是要求你干什么，可以这样转换，假设有这样一个通讯录，它是是一个对象数组，每个对象有很多属性，名字，电话，地址，工作等等，现在给了你一个相应的收索信息，那么你应该在数组中找出他所对应的完整信息。需要注意的一点是，假设，“同名，地址一样，就应该搜索标志性的信息”
方法一：
function where(obj1,obj2){
var arr = [];
for(var i = 0;i < obj1.length;i++){
var flag = true;
for(var key2 in obj2){
if (obj2[key2] !== obj1[i][key2]){
flag = false;
}
}
if(flag){
arr.push(obj1[i]);
}
}
return arr;
}
方法二：
function where(collection, source) {
var arr = [];
var arrSource=Object.keys(source);//把source的属性转化为数组
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;
}
5.Search and Replace
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) { return str; } myReplace("Let us go to the store", "store", "mall") 应该返回 "Let us go to the mall"。 myReplace("He is Sleeping on the couch", "Sleeping", "sitting") 应该返回 "He is Sitting on the couch"。 myReplace("This has a spellngi error", "spellngi", "spelling") 应该返回 "This has a spelling error"。 myReplace("His name is Tom", "Tom", "john") 应该返回 "His name is John"。
思路：找到替换单词，替换前的单词是否为大写，并替换，就是这么简单
function myReplace(str, before, after) {
var re = new RegExp(before);
return str.replace(re,function (){
if (before[0] === before[0].toUpperCase()) {
return after[0].toUpperCase() + after.substr(1).toLowerCase();
}else{
return after;
}
});
}
6.Pig Latin
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
function translate(str) { return str; } translate("california") 应该返回 "aliforniacay"。 translate("paragraphs") 应该返回 "aragraphspay"。 translate("glove") 应该返回 "oveglay"。 translate("algorithm") 应该返回 "algorithmway"。 translate("eight") 应该返回 "eightway"。
思路：最先用了比较笨的办法，因为看到给了那么多提示，觉得很难.首先想到的是判断第一个字母是否元音，是=>拼接，不是=>替换到末尾再拼接。后面想到还是用正则简单粗暴
方法一：
function translate(str) {
if(isVowel(str)){
return str + "way";
}else{
for(var i = 1;i<str.length;i++){
if(isVowel(str[i])){
return str.substr(i,str.length) + str.substr(0,i)+"ay"
}
}
}
}
function isVowel(str1){
if(str1[0] === "a" ||
str1[0] === "e" ||
str1[0] === "i" ||
str1[0] === "o" ||
str1[0] === "u" ){
return true;
}
return false;
}
方法二：
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;
}
7.DNA Pairing
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
function pair(str) { return str; } pair("ATCGA") 应该返回 [["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]。 pair("TTGAG") 应该返回 [["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]。 pair("CTCTA") 应该返回 [["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]。
思路：好像没什么思路，我觉得这类题无非就是告诉你一个你不知道，或者不理解的知识点，然后靠自己理解，转换成代码
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;
}
8.Missing letters
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined
function fearNotLetter(str) { return str; } fearNotLetter("abce") 应该返回 "d"。 fearNotLetter("abcdefghjklmno") 应该返回 "i"。 fearNotLetter("bcd") 应该返回 undefined。 fearNotLetter("yz") 应该返回 undefined。
思路：找缺的字母呗，然后上诉两个方法的改良。
function fearNotLetter(str) {
var firstNumber = str[0].charCodeAt();
var lastNumber = str[str.length-1].charCodeAt();
if (firstNumber == (lastNumber - str.length +1)) {
return undefined;
}
else{
for(var i = 0; i < str.length; i++){
if (str[i].charCodeAt() !== (str[i+1].charCodeAt()-1)) {
return String.fromCharCode((str[i].charCodeAt() + 1))
}
}
}
}
9.Boo who
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
思路：这题，我无言以对。太.....直接给代码就行
function boo(bool) {
// What is the new fad diet for ghost developers? The Boolean.
return (typeof bool=='boolean');
}
boo(null);
10.Sorted Union
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
function unite(arr1, arr2, arr3) { return arr1; } unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应该返回 [1, 3, 2, 5, 4]。 unite([1, 3, 2], [1, [5]], [2, [4]]) 应该返回 [1, 3, 2, [5], [4]]。 unite([1, 2, 3], [5, 2, 1]) 应该返回 [1, 2, 3, 5]。 unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]) 应该返回 [1, 2, 3, 5, 4, 6, 7, 8]。
思路：这个就是求不同，再把这个求出的数组和第三个比较，而且注意有些数组可能是二维的
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;
}
11.Convert HTML Entities
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
function convert(str) { // :) return str; } convert("Dolce & Gabbana") 应该返回 Dolce & Gabbana。 convert("Hamburgers < Pizza < Tacos") 应该返回 Hamburgers < Pizza < Tacos。 convert("Sixty > twelve") 应该返回 Sixty > twelve。 convert('Stuff in "quotation marks"') 应该返回 Stuff in "quotation marks"。 convert("Shindler's List") 应该返回 Shindler's List。 convert("<>") 应该返回 <>。 convert("abc") 应该返回 abc。
思路：正则加替换。
function convert(str) {
return str.replace(/[<>"&']/g,function(match,pos,originalText){
switch(match){
case "<":
return "<";
case ">":
return ">";
case "&":
return "&";
case "\"":
return """;
case "\'":
return "'";
}
});
}
12.Spinal Tap Case
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
function spinalCase(str) { return str; } 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"。
思路：这题有趣，咋一看很简单，就是用正则分组，然后第二种情况略坑，这才是考察的重点。$1,$2
function spinalCase(str) {
var regex = /\s+|_+/g;
// Replace low-upper case to low-space-uppercase
str = str.replace(/([a-z])([A-Z])/g, '$1 $2');
// Replace space and underscore with dashes
return str.replace(regex, '-').toLowerCase();
}
从13题开始，算法和逻辑的重要性开始提现出来，也算是由一个初级者向中级进阶的转变！
13.Sum All Odd Fibonacci Numbers
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。
function sumFibs(num) { return num; } sumFibs(1000) 应该返回 1785。 sumFibs(4000000) 应该返回 4613732。 sumFibs(4) 应该返回 5。 sumFibs(75024) 应该返回 60696。 sumFibs(75025) 应该返回 135721。
思路：这题给了提示，不用先创建一个数组，否则内存会溢出，就在提示我们只把需要的数字求和，而不需要的变继续按斐波纳契数列增加
function sumFibs(num) {
var pre = 0;
var cur = 1;
var result = 0;
while(cur <= num){
if (cur % 2 !== 0) {
result +=cur;
}
var add = cur + pre;
pre = cur;
cur = add;
}
return result;
}
14.Sum All Primes
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
function sumPrimes(num) { return num; } sumPrimes(10) 应该返回 17。 sumPrimes(977) 应该返回 73156。
思路：和上面那题差不多，理解一个概念，转换成相应的逻辑，符合条件=>累加，不符合=>继续循环
function sumPrimes(num){
var result = 0;
i = 0;
for(var n = 1; n <= num ;n++){
for(var m = 2; m <= n-1;m++){
if(n%m === 0){
break;
}
}
if(m === n){
result +=m;
i++;
}
}
return result;
}
15.Smallest Common Multiple
找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
function smallestCommons(arr) { return arr; } smallestCommons([1, 5]) 应该返回 60。 smallestCommons([5, 1]) 应该返回 60。 smallestCommons([1, 13]) 应该返回 360360。
思路：基本数学知识不好的人，确实不适合编程。比如我说我，人在做，天在看，初中数学留祸患。
假设有自然数 a 、b，则
a、b最小公倍数 * a、b最大公约数 = a、b的乘积.所以我们要先求最大公约数，要使用“辗转相除法”！
“”function smallestCommons(arr) {
var min = Math.min(arr[0],arr[1]);
var max = Math.max(arr[0],arr[1]);
var _arr = [];
for(var i = min; i <= max; i++){
_arr.push(i);
}
var gcd = function(a,b){
if(b){
return gcd(b, a % b);
}
return a;
};
return _arr.reduce(function(prev,cur,index,array){
return prev*cur/gcd(prev,cur);
});
}
16.Finders Keepers
写一个 function，它浏览数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。
思路：直接给答案， 因为价值不大
function find(arr, func) {
var result = arr.filter(func);
return result[0];
}
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。
17.Drop it
让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
function drop(arr, func) { // Drop them elements. return arr; } drop([1, 2, 3, 4], function(n) {return n >= 3;}) 应该返回 [3, 4]。 drop([0, 1, 0, 1], function(n) {return n === 1;}) 应该返回 [1, 0, 1]。 drop([1, 2, 3], function(n) {return n > 0;}) 应该返回 [1, 2, 3]。 drop([1, 2, 3, 4], function(n) {return n > 5;}) 应该返回 []。 drop([1, 2, 3, 7, 4], function(n) {return n > 3;}) 应该返回 [7, 4]。 drop([1, 2, 3, 9, 2], function(n) {return n > 2;}) 应该返回 [3, 9, 2]。
思路：废话太多了，简化出来题目意思：找到第一个符合要求的元素，停止某个操作。返回剩下的元素组成的数组。
function drop(arr, func) {
for(var i = 0; i < arr.length; i++){
if(func.apply(this,arr)){
return arr;
break;
}else{
arr.shift(arr[i]);
i--;
if(arr.length ===0) return []
}
}
}
18.Steamroller
对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
function steamroller(arr) { // I'm a steamroller, baby return arr; } steamroller([[["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]。
思路：这题有点丧心病狂，实用性是有，但是不会嵌套多维数组啊。所以很多简单的方法用不上了，比如JSON.parse，和利用switch判断等，只好采用递归了。
function steamroller(arr) {
var newArr = [];
if (Array.isArray(arr)) {
// arr.forEach(function (value) {
// newArr = newArr.concat(steamroller(value));
// });
//上述注释可以替换掉for循环，只是写法不同而已
for(var i = 0;i<arr.length;i++){
newArr = newArr.concat(steamroller(arr[i]))
}
} else {
newArr.push(arr);
}
return newArr;
}
19.Binary Agents
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
思路：就是翻译二级制码转换成英文，题目答案一起贴，没什么好讲的
function binaryAgent(str) {
var arr = str.split(" ");
var newArr = arr.map(function(item,index){
return String.fromCharCode(parseInt(item, 2));
})
return newArr.join("");
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111") 应该返回 "Aren't bonfires fun!?"
binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001") 应该返回 "I love FreeCodeCamp!"
20.Everything Be True
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
function every(collection, pre) { // Is everyone being true? return pre; } 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
思路：好像也没什么可讲的
function every(collection, pre) {
var i='';
var bCheck=true;
for(i in collection){
if(!collection[i][pre]){
bCheck=false;
}
}
return bCheck;
}
21.Arguments Optional
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
function add() { return false; } add(2, 3) 应该返回 5。 add(2)(3) 应该返回 5。 add("http://bit.ly/IqT6zt") 应该返回 undefined。 add(2, "3") 应该返回 undefined。 add(2)([3]) 应该返回 undefined。
思路：已经给了很好的提示了，判断参数个数，以及参数的类型，符合两种情况就累加，不符合返回undefined
function add(arg){
if(arguments.length == 1 && typeof arg ==='number'){
return function(newArg){
if (typeof newArg === "number" ) {
return arg + newArg;
}
};
}
else if((typeof arguments[0] === "number") && (typeof arguments[1] === "number")){
return arguments[0] + arguments[1];
}
}
