fcc算法中级

发表于 | 分类于 ，

FCC算法中级

范围内数字求和

给出一个含有两个数字的数组，我们需要写一个函数，让它返回这两个数字间所有数字（包含这两个数字）的总和。

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

1
2
3
4
5
6
7
8
9
function sumAll(arr) {
  let sumBetween = 0;
  for (let i = Math.min(...arr); i <= Math.max(...arr); i++) {
    sumBetween += i;
  }
  return sumBetween;
}

sumAll([1, 4]);

区分两个数组

写一个函数，比较两个数组，返回一个新的数组。这个新数组需要包含传入的两个数组所有元素中，仅在其中一个数组里出现的元素。如果某个元素同时出现在两个数组中，则不应包含在返回的数组里。换言之，我们需要返回这两个数组的对称差。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function diffArray(arr1, arr2) {
  var newArr = [];
  // 这是一个党异伐同的过程
  function secondInFirst(first, second){
    for(var i = 0; i < second.length; i++){
      if(first.indexOf(second[i]) === -1){
        newArr.push(second[i])
      }
    }
  }
  secondInFirst(arr1, arr2)
  secondInFirst(arr2, arr1)
  return newArr;
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
1
2
3
4
5
6
function diffArray(arr1, arr2) {
  // 这是一个党异伐同的过程
  return arr1.concat(arr2).filter(item=>arr1.indexOf(item)===-1 || arr2.indexOf(item)===-1);
}

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

瞄准和消灭

传给它的第一个参数是数组，我们称他为初始数组。后续的参数数量是不确定的，可能有一个或多个。你需要做的是，从初始数组中移除所有与后续参数相等的元素，并返回移除元素后的数组。使用...，即“剩余参数”（Rest Parameters）语法

1
2
3
4
5
6
function destroyer(arr, ...arr2) {
  // 删掉那些值
  return arr.filter(item=>!arr2.includes(item));
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

短线连接格式

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

1
2
3
4
5
6
7
function spinalCase(str) {
   return str.split(/\s|_|(?=[A-Z])/)
    .join('-')
    .toLowerCase();
}

spinalCase('This Is Spinal Tap');

儿童黑话

写一个函数，把传入的字符串翻译成“儿童黑话”。

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
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");

搜索和替换

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

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

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

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

注意：
你需要保留被替换单词首字母的大小写格式。即如果传入的第二个参数为 “Book”，第三个参数为 “dog”，那么替换后的结果应为 “Dog”

1
2
3
4
5
6
7
8
9
10
 function myReplace(str, before, after){
     if(/^[A-Z]/.test(before)){
         after = after[0].toUpperCase() + after.substring(1)
     }else{
         after = after[0].toLowerCase() + after.substring(1)
     }
     return str.replace(before, after)  // 不会改变原字符串，会生成新的字符串
 }
var strr = myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
console.log(strr)

DNA 配对

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function pairElement(str) {
    var arr = str.split('')
    var arr2 = []
    for(var i = 0; i < arr.length; i ++){
        switch(arr[i]){
            case 'A': 
                arr2.push(['A','T'])
                break
            case 'T': 
                arr2.push(['T','A'])
                break
            case 'G': 
                arr2.push(['G','C'])
                break
            case 'C': 
                arr2.push(['C','G'])
                break
        }
    }
    return arr2;
}

var arr3 = pairElement("GCG");
console.log(arr3)

丢失的字母

写一个函数，找到传入的字符串里缺失的字母并返回它。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function fearNotLetter(str) {
  var num = str[0].charCodeAt()
  var flag
  for(var i=0,j=1; i < str.length-1; i++, j++){
      if(str[i].charCodeAt() + 1 == str[j].charCodeAt()){
          
      }else{
          flag = String.fromCharCode(str[i].charCodeAt() + 1)
          break
      }
  }
  return flag;
}

fearNotLetter("abce");

集合排序

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

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

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

1
2
3
4
5
function uniteUnique(...arr) {
  return [...new Set(arr.flat())]
}

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

flat()用法

转换HTML

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function convertHTML(str) {
    let arr = str.split('')
    for(let i = 0; i< arr.length; i++){
        switch(arr[i]){
            case "<":
                arr[i] = "&lt;";
                break;
            case "&":
                arr[i] = "&amp;";
                break;
            case ">":
                arr[i] = "&gt;";
                break;
            case '"':
                arr[i] = "&quot;";
                break;
            case "'":
                arr[i] = "&apos;";
                break;
        }
    }
    return arr.join('');
}
  
console.log(convertHTML("Dolce & Gabbana"));

求斐波那契数列奇数和

写一个函数，参数为一个正整数num。它的作用是计算斐波那契数列中，小于或等于num的奇数之和。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function sumFibs(num) {
  let preNum = 0
  let curNum = 1
  let result = 0
  while(curNum <= num){
      if(curNum % 2 !== 0){
          result += curNum
      }
      curNum += preNum
      preNum = curNum - preNum
  }
  return result;
}

sumFibs(4);

对所有素数求和

写一个函数，它接收一个数字参数num，返回值为不大于这个数字的所有质数之和。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function sumPrimes(num) {
    let result = 0
    for(var i = 2; i <= num; i++){
        var flag = 0
        for(var j = 2; j <= Math.sqrt(i); j++){
            if(i % j === 0){
                flag = 1
                break
            }
        } 
        if(flag === 0){
            result += i
        }
    }
    return result;
}

console.log(sumPrimes(10));

最小公倍数

写一个函数，它接收一个包含两个数字的数组参数arr，它的返回值为这两个数字范围内所有数字（包含这两个数字）的最小公倍数。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function smallestCommons(arr) {
    let result = 1
    const [min, max] = arr.sort((a, b)=>a - b)
    for(let j = min; j <= max; j++){
        result *= j
    }

    const geshu = max - min + 1
    for(let i=max; i <= result; i+=5){
        let shijigeshu = 0
        for(let k=min; k <= max; k++){
            if(i % k === 0){
                shijigeshu++
            }
        }
        if(shijigeshu === geshu){
            return i
        }
    }
}
  
  
  console.log(smallestCommons([1,5]));

Bootstrap

1
2
3
4
5
container-fluid	 div适应页面宽度
img-responsive   img适应页面的宽度
text-center      文本居中  例如：h2
btn-block 		 button成为块级元素独占一行
form-control 	 表单元素占满一行