中级算法

作者: 井润 | 来源:发表于2019-12-17 23:53 被阅读0次

这是Fcc中的终极算法的部分

01|范围内求值

function sumAll(arr) {
var min,max,temp=0;
min=Math.min(arr[0],arr[1]);
max=Math.max(arr[0],arr[1]);
  for(var i=min;i<=max;i++){
    temp+=i;
  }
  return temp;
}

sumAll([1, 4]);

题解二:

function sumAll(arr){
   var sum=0;
    for(var i=Math.min([...arr]);i<Math.max([...arr]);i++){
        sum+=i;
    }
    return sum;
}

02|区别两个数组

解法一

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

    function onlyInFirst(first, second) {
        // Looping through an array to find elements that don't exist in another array
        for (var i=0;i<first.length;i++) {
            if (second.indexOf(first[i]) === -1) {
                newArr.push(first[i]);
            }
        }
    }

    onlyInFirst(arr1, arr2);
    onlyInFirst(arr2, arr1);

    return newArr;
}

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

解法二

  function diffArray(arr1, arr2) {
      return arr1
        .concat(arr2)
        .filter(
            item => !arr1.includes(item) || !arr2.includes(item)
        )
    }

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

解法三

function diffArray(arr1,arr2){
    return arr1.filter(e1=>!arr2.includes(e1)).concat(arr2.filter(e1=>!arr1.includes(e1)))
}

解法四(高级解法)

function diffArray(arr1,arr2){
    return [
        ...diff(arr1,arr2),
        ...diff(arr2,arr1)
    ]
    function diff(a,b){
        return a.filter(item=> b.indexOf(item) === -1);
    }
}

03|瞄准和消灭

function destryer(arr){
    var arrDel=[];
    for(var i=0;i<arguments.length;i++){
        arrDel.push(arguments[i]);
    }
    return arr.filter( item=> arrDel.indexOf(item)<0)

    return arr;
}

解法二:

function destryer(arr){
    const destryer=(arr,..args)=>arr.filter(i => !args.includes(i));
}

解法三:

function destroyer(arr) {
  var args = Array.from(arguments).slice(1);
  return arr.filter(function(val) {
    return !args.includes(val);
  });
}

04|罗密欧与朱丽叶

在这道题目中，我们要写一个函数，它接收两个参数：第一个参数是对象数组，第二个参数是一个对象。我们需要从对象数组中找出与第二个参数相等或包含第二个参数的所有对象，并以对象数组的形式返回。其中，相等的意思是原数组中的对象与第二个参数中对象的所有键值对完全相等；包含的意思是只要第二个参数中对象的所有键存在于原数组对象中，且它们对应的值相同即可。

function whatIsInAName(conllection,source){
    var srckeys=Object.keys(source);
    return collection.filter(function(obj){
        for(var i=0;i<srcKeys.length;i++){
            if(!obj.hasOwnProperty(srcKeys[i])||obj[srcKeys[i]]!==source[srcKeys[i]]){
        return false;
            }
        }
        return true;
    })
}

解法二:

function whatIsInAName(collection,source){
    var srcKeys=Object.Keys(source);
    return collection.filter(function(key){
        return obj.hasOwnProperty(key)&& obj[key] === source[key];
    })
}

解法三

function whatIsInAName(collection, source) {
  var srcKeys = Object.keys(source);
  return collection.filter(function (obj) {
    return srcKeys
      .map(function(key) {
        return obj.hasOwnProperty(key) && obj[key] === source[key];
      })
      .reduce(function(a, b) {
        return a && b;
      });
  });
}

05|短线连接格式

在这道题目中，我们需要写一个函数，把一个字符串转换为“短线连接格式”。短线连接格式的意思是，所有字母都是小写，且用-连接。比如，对于Hello World，应该转换为hello-world；对于I love_Javascript-VeryMuch，应该转换为i-love-javascript-very-much。

解法一:

function spinalCase(str) {
  var regex = /\s+|_+/g;
  str = str.replace(/([a-z])([A-Z])/g, '$1 $2');
  return str.replace(regex, '-').toLowerCase();
}
spinalCase('This Is Spinal Tap');

解法二:

function spinalCase(str) {
  str = str.replace(/([a-z])([A-Z])/g, '$1 $2');
  return str.toLowerCase().split(/(?:_| )+/) .join('-');
}
spinalCase('This Is Spinal Tap');

解法三:

function spinalCase(str) {
  return str.split(/\s|_|(?=[A-Z])/).join('-').toLowerCase()
}

06|儿童黑化

在这道题目中，我们需要写一个函数，把传入的字符串翻译成“儿童黑话”。

儿童黑话的基本转换规则很简单，只需要把一个英文单词的第一个辅音字母或第一组辅音从移到单词的结尾，并在后面加上ay即可。在英语中，字母 a、e、i、o、u 为元音，其余的字母均为辅音。辅音从的意思是连续的多个辅音字母。

额外地，如果单词本身是以元音开头的，那只需要在结尾加上way。

在本题中，传入的单词一定会是英文单词，且所有字母均为小写

解法一:

function translatePigLatin(str) {
  var pigLatin = '';
  var regex = /[aeiou]/gi;
  if (str[0].match(regex)) {
    pigLatin = str + 'way';
  } else if(str.match(regex) === null) {
    pigLatin = str + 'ay';
  } else {
    var vowelIndice = str.indexOf(str.match(regex)[0]);
    pigLatin = str.substr(vowelIndice) + str.substr(0, vowelIndice) + 'ay';
  }
    return pigLatin;
}
translatePigLatin("consonant");

解法二:

function translatePigLatin(str) {
  function check(obj) {
      return ['a','i','u','e','o'].indexOf(str.charAt(obj)) == -1 ? check(obj + 1) : obj;
  }
    return str.substr(check(0)).concat((check(0) === 0 ? 'w' : str.substr(0, check(0))) + 'ay');
}
translatePigLatin("consonant");

解法三:

function translatePigLatin(str) {
    var strArr = [];
    var tmpChar;

    function isConsonant(char) {
        return !/[aeiou]/.test(char);
    }

    if (!isConsonant(str.charAt(0)))
        return str + "way";
    else
        strArr = str.split("");


    while (isConsonant(strArr[0])) {
        tmpChar = strArr.shift();
        strArr.push(tmpChar);
    }
 return strArr.join("")+"ay";
}

translatePigLatin("consonant");

07|搜索和替换

在这道题目中，我们需要写一个字符串的搜索与替换函数，它的返回值为完成替换后的新字符串。

这个函数接收的第一个参数为待替换的句子。

第二个参数为句中需要被替换的单词。

第三个参数为替换后的单词。

function myReplace(str, before, after) {

  var index = str.indexOf(before);
  if (str[index] === str[index].toUpperCase()) {
    after = after.charAt(0).toUpperCase() + after.slice(1);
  }
  str = str.replace(before, after);
  return str;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

解法二:

function myReplace(str, before, after) {
  var re = new RegExp(before,"gi");
  if(/[A-Z]/.test(before[0])){
    after = after.charAt(0).toUpperCase()+after.slice(1);
     }
  var  newStr =  str.replace(re,after);
 return newStr;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

解法三:

String.prototype.capitalize =  String.prototype.capitalize ||
    function() {
        return this[0].toUpperCase() + this.slice(1);
    };

const Util = (function () {
    function textCase(str, tCase) {
        if(tCase) {
            return setCase(str, tCase);
        } else {
            return getCase(str);
        }

        function setCase(str, tCase) {
            switch(tCase) {
                case "uppercase": return str.toUpperCase();
                case "lowercase": return str.toLowerCase();
                case "capitalized": return str.capitalize();
                default: return str;
            }
        }

        function getCase(str) {
            if (str === str.toUpperCase()) { return "uppercase"; }
            if (str === str.toLowerCase()) { return "lowercase"; }
            if (str === str.capitalize()) { return "capitalized"; }
            return "normal";
        }
    }
    return {
        textCase
    };
})();

function myReplace(str, before, after) {
    const { textCase } = Util;
    const regex = new RegExp(before, 'gi');
    const replacingStr = textCase(after, textCase(before));
    return str.replace(regex, replacingStr);
}

08|DNA配对

在这道题目中，我们需要写一个函数，为 DNA 中的碱基配对。这个函数只接收一个表示碱基的字符串为参数，最后返回完成配对的二维数组。

碱基对由一对碱基组成。碱基有四种，分别为 A（腺嘌呤）、T（胸腺嘧啶）、G（鸟嘌呤）和 C（胞嘧啶）。配对原则是：A 与 T 配对，C 与 G 配对。我们需要根据这个原则对传入的所有碱基进行配对。

对于每个传入的碱基，我们应采用数组的形式展示配对结果。其中，传入的碱基需要作为数组的第一个元素出现。最终返回的数组中应当包含参数中每一个碱基的配对结果。

比如，传入的参数是 GCG，那么函数的返回值应为 [["G", "C"], ["C","G"],["G", "C"]]

function pairElement(str) {
    var paired = [];
    var search = function(char) {
        switch (char) {
            case 'A':
                paired.push(['A', 'T']);
                break;
            case 'T':
                paired.push(['T', 'A']);
                break;
            case 'C':
                paired.push(['C', 'G']);
                break;
            case 'G':
                paired.push(['G', 'C']);
                break;
        }
    };

    for (var i = 0; i < str.length; i++) {
        search(str[i]);
    }
    return paired;
}
pairElement("GCG");

解法二:

function pairElement(str) {
    var pairs = {
        "A": "T",
        "T": "A",
        "C": "G",
        "G": "C"
    }
    var arr = str.split("");
    return arr.map(x => [x,pairs[x]]);
}
pairElement("GCG");

09|丢失的字母

在这道题目中，我们需要写一个函数，找到传入的字符串里缺失的字母并返回它。

判断缺失的依据是字母顺序，比如 abcdfg 中缺失了 e。而 abcdef 中就没有字母缺失，此时我们需要返回undefined。

解法一:

function fearNotLetter(str) {
  for(var i = 0; i < str.length; i++) {
    var code = str.charCodeAt(i);
    if (code !== str.charCodeAt(0) + i) {
      return String.fromCharCode(code - 1);
    }  
  }
  return undefined;
}
fearNotLetter("abce");

解法二:

function fearNotLetter(str) {
  var compare = str.charCodeAt(0), missing;
  str.split('').map(function(letter,index) {
    if (str.charCodeAt(index) == compare) {
      ++compare;
    } else {
      missing = String.fromCharCode(compare);
    }
  });

  return missing;
}

解法三:

function fearNotLetter(str) {
  for (let i = 1; i < str.length; ++i) {
    if (str.charCodeAt(i) - str.charCodeAt(i-1) > 1) {
      return String.fromCharCode(str.charCodeAt(i - 1) + 1);
    }
  }
}

解法四:

function fearNotLetter(str) {
  var allChars = '';
  var notChars = new RegExp('[^'+str+']','g');
  for (var i = 0; allChars[allChars.length-1] !== str[str.length-1] ; i++)
    allChars += String.fromCharCode(str[0].charCodeAt(0) + i);
  return allChars.match(notChars) ? allChars.match(notChars).join('') : undefined;
}

fearNotLetter("abce");

10|集合排序

在这道题目中，我们需要写一个函数，它接收两个或多个数组为参数。我们需要对这些数组中所有元素进行去除重复元素的处理，并以数组的形式返回去重结果。

需要注意的是，结果数组中的元素顺序必须与其传入的顺序保持一致。

如有疑问，请先浏览下方的测试用例。

解法一:

function uniteUnique(arr1, arr2, arr3) {

  var finalArray = [];
    for (var i = 0; i < arguments.length; i++) {
    var arrayArguments = arguments[i];
      for (var j = 0; j < arrayArguments.length; j++) {
      var indexValue = arrayArguments[j];

      if (finalArray.indexOf(indexValue) < 0) {
        finalArray.push(indexValue);
      }
    }
  }

  return finalArray;
}

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

解法二:

function uniteUnique(arr) {
  var args = [...arguments];
  var result = [];
  for(var i = 0; i < args.length; i++) {
    for(var j = 0; j < args[i].length; j++) {
       if(!result.includes(args[i][j])) {
        result.push(args[i][j]);
      }
    }
  }
  return result;
}
uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);

解法三:

function uniteUnique(arr1, arr2, arr3) {
 var newArr;
  var args = Array.prototype.slice.call(arguments);
  newArr = args.reduce(function(arrA,arrB){
    return arrA.concat(arrB.filter(function(i){
      return arrA.indexOf(i) === -1;
    }));
  });
   return newArr;                    
}
uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);

解法四:

function uniteUnique() {
  var concatArr = [];
  var i = 0;
  while (arguments[i]){
    concatArr = concatArr.concat(arguments[i]); i++;
  }
  uniqueArray = concatArr.filter(function(item, pos) {
    return concatArr.indexOf(item) == pos;
  });
  return uniqueArray;
}
uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);

11|转换HTML实体

在这道题目中，我们需要写一个转换 HTML entity 的函数。需要转换的 HTML entity 有&、<、>、"（双引号）和'（单引号）。转换的规则你可以在 W3C 官网找到。

解法一:

function convertHTML(str) {
  str = str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,"&apos;");
return str;
}

convertHTML("Dolce & Gabbana");

解法二:

function convertHTML(str) {
    htmlEntities={
        '&':'&amp;',
        '<':'&lt;',
        '>':'&gt;',
        '"':'&quot;',
        '\'':"&apos;"
    };
    return str.split('').map(entity => htmlEntities[entity] || entity).join('');
}
convertHTML("Dolce & Gabbana");

12|斐波那契数组中奇数之和

在这道题目中，我们需要写一个函数，参数为一个正整数num。它的作用是计算斐波那契数列中，小于或等于num的奇数之和。

斐波那契数列中，第一和第二个数字都是 1，后面的每个数字由之前两数相加得出。斐波那契数列的前六个数字分别为：1、1、2、3、5、8。

比如，sumFibs(10)应该返回10。因为斐波那契数列中，比10小的数字只有 1、1、3、5。

解法一:

function sumFibs(num) {
    var prevNumber = 0;
    var currNumber = 1;
    var result = 0;
    while (currNumber <= num) {
        if (currNumber % 2 !== 0) {
            result += currNumber;
        }
        currNumber += prevNumber;
        prevNumber = currNumber - prevNumber;
    }
    return result;
}

sumFibs(4);

解法二:

function sumFibs(num) {
    if (num < 0) return -1;
    if (num === 0 || num === 1) return 1;

    const arrFib = [1, 1];
    let nextFib = 0;
    
    while((nextFib = arrFib[0] + arrFib[1]) <= num) {
        arrFib.unshift(nextFib);
    }
    return arrFib.reduce((acc, curr) => {
        return acc + curr * (curr % 2);
    });
}

sumFibs(4);

13|所有的素数之和

在这道题目中，我们需要写一个函数，它接收一个数字参数num，返回值为不大于这个数字的所有质数之和。

质数是大于 1 且仅可以被 1 和自己整除的数。比如，2 就是一个质数，因为它只可以被 1 和 2（它本身）整除。

注意，传入函数的num不一定是质数。

解法一:

function sumPrimes(num) {
  var res = 0;
  function getPrimes(max) {
    var sieve = [];
    var i;
    var j;
    var primes = [];
    for (i = 2; i <= max; ++i) {
      if (!sieve[i]) {
        primes.push(i);
        for (j = i << 1; j <= max; j += i) {
          sieve[j] = true;
        }
      }
    }
    return primes;
  }
  var primes = getPrimes(num);
  for (var p = 0; p < primes.length; p++) {
    res += primes[p];
  }
  return res;
}
sumPrimes(10);

解法二:

function sumPrimes(num) {
  function isPrime(number){
      for (i = 2; i <= number; i++){
          if(number % i === 0 && number!= i){
                     return false;
          }
       }
      return true;
  }
  if (num === 1){
    return 0;
  }
  if(isPrime(num) === false){
    return sumPrimes(num - 1);
  }
  if(isPrime(num) === true){
    return num + sumPrimes(num - 1);
  }
}
sumPrimes(10);

解法三:

function sumPrimes(num) {
    let arr = Array.from({length: num+1}, (v, k) => k).slice(2); 
    let onlyPrimes = arr.filter( (n) => { 
    let m = n-1;
    while (m > 1 && m >= Math.sqrt(n)) { 
      if ((n % m) === 0) 
        return false;
        m--;
    }
      return true;
  });
  return onlyPrimes.reduce((a,b) => a+b); 
}
sumPrimes(977);

14|最小公倍数

在这道题目中，我们需要写一个函数，它接收一个包含两个数字的数组参数arr，它的返回值为这两个数字范围内所有数字（包含这两个数字）的最小公倍数。

注意，较小数不一定总是出现在数组的第一个元素。

比如，传入[1, 3]，那么函数的返回结果应为 1、2、3 的最小公倍数，即为 6。

解法一:

function smallestCommons(arr) {
  arr.sort(function(a, b) {
    return b - a;
  });

  var newArr = [];
  for (var i = arr[0]; i >= arr[1]; i--) {
    newArr.push(i);
  }
var quot = 0;
  var loop = 1;
  var n;
  do {
    quot = newArr[0] * loop * newArr[1];
    for (n = 2; n < newArr.length; n++) {
      if (quot % newArr[n] !== 0) {
        break;
      }
    }
    loop++;
  } while (n !== newArr.length);

  return quot;
}
smallestCommons([1,5]);

解法二:

function smallestCommons(arr) {
    var range = [];
    for (var i = Math.max(arr[0], arr[1]); i >= Math.min(arr[0], arr[1]); i--) {
    range.push(i);
    }
    var lcm = range[0];
    for (i = 1; i < range.length; i++) {
    var GCD = gcd(lcm, range[i]);
    lcm = (lcm * range[i]) / GCD;
    }
    return lcm;
    function gcd(x, y) {    // Implements the Euclidean Algorithm
    if (y === 0)
        return x;
    else
        return gcd(y, x%y);
    }
}
smallestCommons([1,5]);

解法三:

function smallestCommons(arr) {
  let min = Math.min.apply(null, arr);
  let max = Math.max.apply(null, arr);

  let smallestCommon = lcm(min, min + 1);

  while(min < max) {
    min++;
    smallestCommon = lcm(smallestCommon, min);
  }

  return smallestCommon;
}

function gcd(a, b) {
  while (b > 0) {
    let tmp = a;
    a = b;
    b = tmp % b;
  }
  return a;
}
function lcm(a, b) {
  return (a * b / gcd(a, b));
}
smallestCommons([1,5]);

15|放弃

在这道题目中，我们需要写一个函数，它接收两个参数，分别为一个数组arr以及一个函数func。我们需要从数组的第一个元素开始，用func来检查数组的每项。函数最终的返回值也是一个数组，它由原数组中第一个使得func为true的元素及其之后的所有元素组成。

如果数组中的所有元素都不能让func为true，则返回空数组[]。

解法一:

function dropElements(arr, func) {
  var times = arr.length;
  for (var i = 0; i < times; i++) {
    if (func(arr[0])) {
      break;
    } else {
      arr.shift();
    }
  }
  return arr;
}
dropElements([1, 2, 3, 4], function(n) {return n >= 3;})

解法二:

function dropElements(arr, func) {
  return arr.slice(arr.findIndex(func) >= 0 ? arr.findIndex(func): arr.length, arr.length);
}
dropElements([1, 2, 3, 4], function(n) {return n >= 3;});

解法三:

function dropElements(arr, func) {
  while(arr.length > 0 && !func(arr[0])) {
    arr.shift();
  }
  return arr;
}
dropElements([1, 2, 3, 4], function(n) {return n >= 3;});

16|扁平化

在这道题目中，我们需要写一个数组扁平化的函数。

注意，你写的函数应该能够处理数组多级嵌套的情况。比如，[1, [2], [3, [4]]]在扁平化处理后的结果应为[1, 2, 3, 4]。

function steamrollArray(arr) {
  var flattenedArray = [];
  var flatten = function(arg) {
    if (!Array.isArray(arg)) {
      flattenedArray.push(arg);
    } else {
      for (var a in arg) {
        flatten(arg[a]);
      }
    }
  };

  arr.forEach(flatten);
  return flattenedArray;
}

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

解法二:

    function steamrollArray(arr) {
      let flat = [].concat(...arr);
      return flat.some(Array.isArray) ? steamrollArray(flat) : flat;
    }

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

解法三:

function steamrollArray(arr) {
  return arr.toString()
    .replace(',,', ',')       
    .split(',')              
    .map(function(v) {
      if (v == '[object Object]') { 
        return {};
      } else if (isNaN(v)) {        
        return v;
      } else {
        return parseInt(v);        
      }
    });
}

17|二进制转换

在这道题目中，我们需要写一个把二进制输入转换成英文句子的函数。

传入函数的二进制字符串会用空格作为分隔符。

解法一:

function binaryAgent(str) {
      biString = str.split(' ');
      uniString = [];

    /*using the radix (or base) parameter in parseInt, we can convert the binary
      number to a decimal number while simultaneously converting to a char*/

      for(i=0;i < biString.length;i++){
        uniString.push(String.fromCharCode(parseInt(biString[i], 2)));
      }

      // we then simply join the string
      return uniString.join('');
    }

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

解法二:

    function binaryAgent(str) {
      return String.fromCharCode(...str.split(" ").map(function(char){ return parseInt(char, 2); }));
    }

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

18|真假值判断

在这道题目中，我们需要写一个函数，它接收两个参数。第一个参数为对象数组collection，第二个参数为一个字符串pre，代表对象的一个键（key）。我们需要检查对象数组中每个对象的pre属性对应的值是否都为 “真”（truthy）。如果是，则返回true，否则返回false。

JavaScript 中，如果一个值在 Boolean 的上下文中（比如if语句）可以被执行为true，那么这个值就被认为是truthy的。

解法一:

function truthCheck(collection, pre) {
 
  var counter = 0;
  for (var c in collection) {
    if (collection[c].hasOwnProperty(pre) && Boolean(collection[c][pre])) {
      counter++;
    }
  }
return counter == collection.length;
}

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

解法二:

function truthCheck(collection, pre) {
  return collection.every(obj => obj[pre]);
}

解法三:

function truthCheck(collection, pre) {
  return collection.every(function (element) {
    return element.hasOwnProperty(pre) && Boolean(element[pre]);
  });
}

19|可选参数

在这道题目中，我们需要写一个求和的函数，但它接收的参数数量不定。如果传入了两个参数，那么直接返回两数之和即可。如果只传入一个参数，那我们应该返回另一个函数用来接收下一个参数，然后求出两数之和。

比如，addTogether(2, 3)应该返回5。而addTogether(2)应该返回一个函数。

然后我们调用这个返回的函数，并给它传入另一个用于求和的值：

var sumTwoAnd = addTogether(2);

sumTwoAnd(3)此时应返回5。

只要其中任何一个参数不是数字，那我们就应返回undefined。

解法一:

 function addTogether() {
      var checkNum = function(num) {
        if (typeof num !== 'number') {
          return undefined;
        } else
          return num;
      };

      if (arguments.length > 1) {
        var a = checkNum(arguments[0]);
        var b = checkNum(arguments[1]);
        if (a === undefined || b === undefined) {
          return undefined;
        } else {
          return a + b;
        }
      } else {
        var c = arguments[0];
       if (checkNum(c)) {
          return function(arg2) {
            if (c === undefined || checkNum(arg2) === undefined) {
              return undefined;
            } else {
              return c + arg2;
            }
          };
        }
      }
    }

    addTogether(2,3);

解法二:

 function addTogether() {
      var args = new Array(arguments.length);
      for(var i = 0; i < args.length; ++i) {
          args[i] = arguments[i];
        }
     if(args.length == 2){
        if(typeof args[0] !== 'number' || typeof args[1] !=='number' ){
          return undefined;
          }
        return args[0]+args[1];
       }
     if(args.length == 1){
         a= args[0];
        if(typeof a!=='number'){
            return undefined;
          }
        else{
           return function(b){
             if(typeof b !=='number'){
               return undefined;
               }
             else
               return a+b;
              };
          }
        }
    }

    addTogether(2,3);

解法三:

    function addTogether() {
      var args = Array.from(arguments);
      return args.some(n => typeof n !== 'number') ? 
        undefined: 
        args.length > 1 ?
          args.reduce((acc, n) => acc += n, 0):
          (n) => typeof n === "number" ? 
            n + args[0]:
            undefined;
    }
   addTogether(2,3);

20|构造一个person类

在这道题目中，我们需要写一个构造器（constructor）函数。它只接收一个字符串参数firstAndLast，这个参数代表一个英文名的全名（姓和名）。这个构造函数创建出的实例需要具有以下方法：

getFirstName() getLastName() getFullName() setFirstName(first) setLastName(last) setFullName(firstAndLast)

这些方法应当可以通过构造函数创建出的实例调用。

你可以点击 “运行测试”，然后就可以在底下的控制台中看到每个测试用例执行的情况。

var Person = function(firstAndLast) {
  var fullName = firstAndLast;

  this.getFirstName = function() {
    return fullName.split(" ")[0];
  };

  this.getLastName = function() {
    return fullName.split(" ")[1];
  };

  this.getFullName = function() {
    return fullName;
  };

  this.setFirstName = function(name) {
    fullName = name + " " + fullName.split(" ")[1];
  };

  this.setLastName = function(name) {
    fullName = fullName.split(" ")[0] + " " + name;
  };

  this.setFullName = function(name) {
    fullName = name;
  };
};

var bob = new Person('Bob Ross');
bob.getFullName();

21|绘制碎片图

在这道题目中，我们需要写一个计算天体轨道周期的函数，它接收一个对象数组参数arr，对象中包含表示天体名称的name属性，及表示轨道半长轴的avgAlt属性。就像这样：{name: 'name', avgAlt: avgAlt}。

这个函数的返回值也是一个对象数组，应保留原对象中的name属性和值，然后根据avgAlt属性的值求出轨道周期（单位是秒），并赋值给orbitalPeriod属性。返回值中不应保留原数据中的avgAlt属性及其对应的值。

你可以在这条维基百科的链接中找到轨道周期的计算公式。

轨道周期的计算以地球为基准（即环绕地球的轨道周期），计算结果应取整到最接近的整数。

地球的半径是 6367.4447 千米，地球的 GM 值为 398600.4418 km3s-2。

function orbitalPeriod(arr) {
  var GM = 398600.4418;
  var earthRadius = 6367.4447;
  var a = 2 * Math.PI;
  var newArr = [];
  var getOrbPeriod = function(obj) {
    var c = Math.pow(earthRadius + obj.avgAlt, 3);
    var b = Math.sqrt(c / GM);
    var orbPeriod = Math.round(a * b);
    delete obj.avgAlt;
    obj.orbitalPeriod = orbPeriod;
    return obj;
  };

  for (var elem in arr) {
    newArr.push(getOrbPeriod(arr[elem]));
  }

  return newArr;
}

// test here
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);

第二题:

function orbitalPeriod(arr) {
  var GM = 398600.4418;
  var earthRadius = 6367.4447;
  for(var prop in arr) {
    var orbitalPer = Math.round(2 * Math.PI * Math.sqrt(Math.pow(arr[prop].avgAlt + earthRadius, 3) / GM));
    delete arr[prop].avgAlt;
    arr[prop].orbitalPeriod = orbitalPer;
  }

  return arr;
}

// test here
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);

第三题:

function orbitalPeriod(arr) {
  var GM = 398600.4418;
  var earthRadius = 6367.4447;
arr.forEach(function(item) {
    var tmp = Math.round(2 * Math.PI * Math.sqrt(Math.pow(earthRadius + item.avgAlt, 3) / GM));
    delete item.avgAlt;
    item.orbitalPeriod = tmp;
  });
  return arr;
}
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);

中级算法

01|范围内求值

02|区别两个数组

03|瞄准和消灭

04|罗密欧与朱丽叶

05|短线连接格式

06|儿童黑化

07|搜索和替换

08|DNA配对

09|丢失的字母

10|集合排序

11|转换HTML实体

12|斐波那契数组中奇数之和

13|所有的素数之和

14|最小公倍数

15|放弃

16|扁平化

17|二进制转换

18|真假值判断

19|可选参数

20|构造一个person类

21|绘制碎片图

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读