FreeCodeCamp——中级算法

昌招

2023-12-01

1、范围内的数字求和

我们会传入一个由两个数字组成的数组。它返回这两个数字间所有数字（包含这两个数字）的总和。
例如，sumAll([4,1]) 应返回 10，因为从 1 到 4（包含 1、4）的所有数字的和是 10

方法一：

function sumAll(arr) {
  let result = 0
  arr.sort(function (a, b) { return a - b })
  for (let i = arr[0]; i <= arr[1]; i++) {
    result += i
  }
  return result
}

sumAll([1, 4]);
console.log(sumAll([1, 4]))

方法二：

function sumAll(arr) {
  let _max = Math.max(arr[0], arr[1]);
  let _min = Math.min(arr[0], arr[1]);
  for (let result = _min + 1; result < _max; result++) {
    arr.push(result);
  }
  return arr.reduce(function (a, b) {
    return a + b
  })
}

sumAll([1, 4]);
console.log(sumAll([1, 4]))

2、数组的对称差

比较两个数组并返回一个新数组，包含所有只在其中一个数组中出现的元素，排除两个数组都存在的元素。换言之，我们需要返回两个数组的对称差。

方法一：

function diffArray(arr1, arr2) {
  var newArr = [];
  newArr = arr1.filter(function (val) {
    return arr2.indexOf(val) == -1;
  }).concat(arr2.filter(function (val) {
    return arr1.indexOf(val) == -1;
  }));
  return newArr;
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
console.log(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]);
console.log(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]))

3、过滤数组元素

你将获得一个初始数组（destroyer 函数中的第一个参数），后跟一个或多个参数。从初始数组中移除所有与后续参数相等的元素
方法一：

function destroyer(arr) {
  let valsToRemove = Object.values(arguments).slice(1)
  return arr.filter(function (val) {
    return !valsToRemove.includes(val);
  });
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3))

方法二：

function destroyer(arr) {
  let valsToRemove = Object.values(arguments).slice(1)
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < valsToRemove.length; j++) {
      if (arr[i] === valsToRemove[j]) {
        delete arr[i];
      }
    }
  }
  return arr.filter(item => item !== null);
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3))

4、找出包含特定键值对的对象

创建一个查看对象数组（第一个参数）的函数，并返回具有匹配的名称和值对的所有对象的数组（第二个参数）。如果要包含在返回的数组中，则源对象的每个名称和值对都必须存在于集合中的对象中。

function whatIsInAName(collection, source) {
  let arr = [];
  let keys = Object.keys(source);
  arr = collection.filter(function (item) {
    for (let i = 0; i < keys.length; i++) {
      if (!item.hasOwnProperty(keys[i]) || item[keys[i]] !== source[keys[i]]) {
        return false;
      }
    }
    return true;
  });
  return arr;
}
whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })
console.log(whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" }));

5、短线连接格式

将字符串转换为短线连接格式。短线连接格式是小写单词全部小写并以破折号分隔。

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

spinalCase('This Is Spinal Tap');
console.log(spinalCase('thisIs Spinal Tap'));

6、儿童黑话

儿童黑话也叫 Pig Latin，是一种英语语言游戏。规则如下：

如果单词以辅音开头，就把第一个辅音字母或第一组辅音簇移到单词的结尾，并在后面加上 ay。
如果单词以元音开头，只需要在结尾加上 way。

function translatePigLatin(str) {
  let consonantRegex = /^[^aeiou]+/;  //以辅音字母开头
  let myConsonants = str.match(consonantRegex);
  return myConsonants !== null
    ? str
      .replace(consonantRegex, "")
      .concat(myConsonants)
      .concat("ay")
    : str.concat("way");
}

translatePigLatin("consonant");
console.log(translatePigLatin("consonant"))

7、搜索与替换

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

这个函数接收的第一个参数为待替换的句子。
第二个参数为句中需要被替换的单词。
第三个参数为替换后的单词。

注意：在更换原始单词时保留原始单词中第一个字符的大小写。即如果传入的第二个参数为 Book，第三个参数为 dog，那么替换后的结果应为 Dog

function myReplace(str, before, after) {
  let reg = /^[A-Z]/
  if (reg.test(before[0])) {
    after = after.replace(after[0], after[0].toUpperCase())
  } else {
    after = after.replace(after[0], after[0].toLowerCase())
  }
  str = str.replace(before, after);
  return str;
}

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

8、DNA 配对

给出的 DNA 链上缺少配对元素。请基于每个字符，获取与其配对的元素，并将结果作为二维数组返回。

DNA 的碱基对有两种形式：一种是 A 与 T，一种是 C 与 G。请为参数中给出的每个字符配对相应的碱基。

例如，传入 GCG 时，应返回 [[“G”, “C”], [“C”,“G”], [“G”, “C”]]。

function pairElement(str) {
  let arr = str.split('');
  let pair = '';
  return arr.map(function (item) {
    switch (item) {
      case 'C':
        pair = 'G';
        break;
      case 'G':
        pair = 'C';
        break;
      case 'A':
        pair = 'T';
        break;
      case 'T':
        pair = 'A';
        break;
    }
    return [item, pair];
  });
}

pairElement("GCG");
console.log(pairElement("GCGA"))

9、寻找缺失的字母

在这道题目中，我们需要写一个函数，找出传入的字符串里缺失的字母并返回它。
如果所有字母都在传入的字符串范围内，返回 undefined。

function fearNotLetter(str) {
  for (let i = 0; i < str.length; i++) {
    let result = str.charCodeAt(i);
    if (result !== str.charCodeAt(0) + i) {
      return String.fromCharCode(result - 1);
    }
  }
  return undefined;
}
fearNotLetter("abce");
console.log(fearNotLetter("abcdefghjklmno"))

10、集合排序

编写一个带有两个或更多数组的函数，并按原始提供的数组的顺序返回一个新的唯一值数组。

去重后的数字应按其出现在参数中的原始顺序排序，最终数组不应按数字大小进行排序。

function uniteUnique(arr) {
  let newArr = Array.prototype.slice.call(arguments).reduce(function (a, b) {
    return a.concat(b);
  }, []);
  let set = new Set(newArr)
  let result = [...set]
  return result;
}
uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);
console.log(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]))

11、转换 HTML 字符实体

请将字符串中的 &、<、>、"（双引号）和 '（单引号）转换为相应的 HTML 字符实体。

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

12、质数求和

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

请完成 sumPrimes 方法，使其返回小于等于传入参数数字的所有质数之和。

function sumPrimes(num) {

  function isPrime(num) {
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i == 0)
        return false;
    }
    return true;
  }

  let sum = 0;
  for (let i = 2; i <= num; i++) {
    if (isPrime(i))
      sum += i;
  }
  return sum;
}
sumPrimes(10);
console.log(sumPrimes(10))

13、找出数字范围内的最小公倍数

找到给定参数的最小公倍数，可以被这两个参数整除，也可以被指定范围内的所有整数整除。

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

例如，如果给定 1 和 3，找到 1 和 3 的最小公倍数，也可以被 1 到 3 之间的所有数字整除。这里的答案将是 6。

function smallestCommons(arr) {
  const [min, max] = arr.sort((a, b) => a - b);
  let upperBound = 1;
  //先找出min到max之间的数（包括min和max）相乘得到数，这个数可以证明能被min到max之间的所有数字整除，且是他们的公倍数
  for (let i = min; i <= max; i++) {
    upperBound *= i;
  }
  for (let multiple = max; multiple <= upperBound; multiple += max) {
    let divisorCount = 0;
    for (let i = min; i <= max; i++) {
      if (multiple % i === 0) {
        divisorCount += 1;
      }
    }
    //判断max前面的所有数字是否都能整除
    if (divisorCount === max - min + 1) {
      return multiple;
    }
  }
}

smallestCommons([1, 5]);
console.log(smallestCommons([1, 5]))

14、根据参数删除数组元素

给定数组 arr，从数组的第一个元素开始，用函数 func 来检查数组的每个元素是否返回 true。如果返回 false，就把这个元素删除。持续执行删除操作，直到某个元素传入 func 时返回 true 为止。

然后在条件满足后返回数组的其余部分，否则， arr 应作为空数组返回。
感觉题目描述有毛病

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

15、数组扁平化

嵌套数组扁平化成一维数组。必须考虑到各种深度的嵌套层级

function steamrollArray(arr) {
  // return arr.flat(3); //最快最方便的方法
  const flat = [].concat(...arr);
  return flat.some(Array.isArray) ? steamrollArray(flat) : flat;
}

steamrollArray([1, [2], [3, [[4]]]]);
console.log(steamrollArray([1, [2], [3, [[4]]]]))

16、翻译二进制字符串

请实现一个函数，把传入的二进制字符串转换成英文句子。

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

function binaryAgent(str) {
  var biString = str.split(" ");
  var uniString = [];
  for (var i = 0; i < biString.length; i++) {
    uniString.push(String.fromCharCode(parseInt(biString[i], 2)));
  }
  return uniString.join("");
}

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

17、一切都是True

检查谓词（第二个参数）在集合（第一个参数）的所有元素是否为 truthy。

换句话说，你将获得一个对象的数组集合。如果数组中的每个对象里，pre 对应属性值均为 truthy，则返回 true。否则，返回 false 。

JavaScript 中，如果一个值在 Boolean 的上下文中的执行结果为 true，那么我们称这个值是 truthy 的。

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

truthCheck([{ name: "Quincy", role: "Founder", isBot: false }, { name: "Naomi", role: "", isBot: false }, { name: "Camperbot", role: "Bot", isBot: true }], "isBot");
console.log(truthCheck([{ name: "Quincy", role: "Founder", isBot: false }, { name: "Naomi", role: "", isBot: false }, { name: "Camperbot", role: "Bot", isBot: true }], "isBot"))

18、可选参数

创建一个将两个参数相加的函数。如果只提供了一个参数，则返回一个需要一个参数并返回总和的函数。
比如，addTogether(2, 3) 应该返回 5。而 addTogether(2) 应该返回一个函数。调用这个返回的函数，为它传入一个值，会返回两个值的总和：
var sumTwoAnd = addTogether(2);
sumTwoAnd(3) 应返回 5。
如果任一参数不是有效数字，则返回 undefined。

function addTogether() {
  const [first, second] = arguments;
  if (typeof (first) !== "number") {
    return undefined;
  } else if (second === undefined) {
    return (second) => addTogether(first, second);
  } else if (typeof (second) !== "number") {
    return undefined;
  }
  return first + second;
}

addTogether(2, 3);
console.log(addTogether(3)(8))

19、创建一个人员对象

用以下方法填充对象构造函数：

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

运行测试以查看每个方法的预期输出。方法接收一个参数，因此必须要有一个参数，并且其类型应该为字符串。这些方法必须是与对象交互的唯一可用方法。

var Person = function (firstAndLast) {
  let 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();
console.log(bob.getFullName())

20、计算轨道周期

在这道题目中，我们需要写一个计算天体轨道周期（单位是秒）的函数。

它接收一个对象数组参数 arr，对象中包含表示天体名称的 name 属性，及表示天体表面平均海拔的 avgAlt 属性。就像这样：{name: ‘name’, avgAlt: avgAlt}。

function orbitalPeriod(arr) {
  const GM = 398600.4418;
  const earthRadius = 6367.4447;
  const newArr = [];
  for (let elem in arr) {
    const orbitalPer = Math.round(
      2 * Math.PI * Math.sqrt(Math.pow(arr[elem].avgAlt + earthRadius, 3) / GM)
    );
    newArr.push({ name: arr[elem].name, orbitalPeriod: orbitalPer });
  }

  return newArr;
}

orbitalPeriod([{ name: "sputnik", avgAlt: 35873.5553 }]);
console.log(orbitalPeriod([{ name: "iss", avgAlt: 413.6 }, { name: "hubble", avgAlt: 556.7 }, { name: "moon", avgAlt: 378632.553 }]))