freecodecamp刷题及知识点（基础算法）

freecodecamp刷题及知识点（基础算法）

将摄氏度转换为华氏度
将摄氏度转换为华氏度的计算方式为：摄氏度乘以 9/5 然后加上 32。

输入参数 celsius 代表一个摄氏度的温度。 使用已定义的变量 fahrenheit，并赋值为相应的华氏度的温度值。 根据上述转换公式来进行转换。

function convertToF(celsius) {
  let fahrenheit=celsius*9/5+32;
  return fahrenheit;
}

convertToF(30);

反转字符串
请反转传入函数的字符串。

在反转字符串之前，你可能需要将其切分成包含字符的数组。

函数的返回结果应为字符串。

function reverseString(str) {
  return str.split('').reverse().join('');
}

reverseString("hello");

计算整数的阶乘
返回一个给定整数的阶乘计算结果。

对于整数 n，n 的阶乘就是所有小于等于 n 的正整数的乘积。

阶乘通常用符号 n! 来表示。

例如：5! = 1 * 2 * 3 * 4 * 5 = 120

在这个挑战中，只有非负整数会作为参数传入函数。

function factorialize(num) {
 if(num>=0)
 {
   return digui(num);
 }
}
function digui(n)
{
if(n==1||n==0)
{
  return 1;
}
else 
return n*digui(n-1);
}
factorialize(5);

找出字符串中的最长单词
返回给出的句子中，最长单词的长度。

函数的返回值应是一个数字。

function findLongestWordLength(str) {
  let n=0;  let max=0;
for(let i=0;i<str.length;i++)
{
  if(str[i]!=' ')
  {
    n++;
  }
  if(str[i]==' '||i==str.length-1)
  {
    if(max<n)
    {
      max=n
      }
      n=0;
  }
  }
return max;  
}
findLongestWordLength
("The quick brown fox jumped over the lazy dog");

找出多个数组中的最大数字
请返回一个数组，该数组由参数中每个子数组中的最大数字组成。 为简单起见，给出的数组总会包含 4 个子数组。

function largestOfFour(arr) {
  let maxArr=[];
  let max=0;
  for(let i=0;i<arr.length;i++)
  for(let j=0;j<arr[i].length;j++)
  {
      if(max<arr[i][j])
      {
        max=arr[i][j];
      }
      if(arr[i][j]<0&&max==0)
      {
        max=arr[i][j];
      }
      if(j==arr[i].length-1)
      {
        maxArr.push(max);
        max=0;
      }
  }
  return maxArr;
}

确认结尾
检查字符串（第一个参数 str）是否以给定的目标字符串（第二个参数 target）结束。

这个挑战 可以 用 ES2015 引入的 .endsWith() 方法来解决。但在这个挑战中，请使用 JavaScript 的字符串子串方法。

function confirmEnding(str, target) {
  for(let i=0;i<str.length;i++)
  {
      let newStr=str.substring(str.length-target.length);
      return newStr==target?true:false;
  }
}

confirmEnding("Bastian", "n");

重复输出字符串
将一个给定的字符串 str（第一个参数）重复输出 num（第二个参数）次。 如果 num 不是正数，返回空字符串。 在这个挑战中，请不要使用 JavaScript 内置的 .repeat() 方法。

function repeatStringNumTimes(str, num) {
  let str1=str;
  if(num<=0)
  {
    return "";
  }
  else
  {
    for(let i=0;i<num-1;i++)
    {
        str1=str1+str;
    }
  }
  return str1;
}

repeatStringNumTimes("abc", 3);

截断字符串
如果传入的字符串（第一个参数）的长度大于传入的值（第二个参数），请在这个位置截断它， 并在后面加上 …，然后返回结果。

function truncateString(str, num) {
  if(str.length>num)
  {
      str=str.substring(0,num);
      str=str+"...";
  }
  return str;
}

truncateString("A-tisket a-tasket A green and yellow basket", 8);

按参数过滤数组
请写一个函数来检查数组（第一个参数 arr）中的元素，并返回数组中第一个通过校验测试的元素。 其中，“通过校验测试”指的是对于数组中的一个元素 x，若 func(x) 返回的结果为 true，则校验测试通过。 如果没有元素通过测试，请返回 undefined。

function findElement(arr, func) {
 for(let i=0;i<arr.length;i++)
 {
   if(func(arr[i])==true)
   {
     return arr[i];
   }
 }
}

findElement([1, 2, 3, 4], num => num % 2 === 0);

基本类型布尔值的检查
检查一个值是否是基本类型中的布尔值（boolean）类型。 函数应返回 true 或者 false。

基本类型中的布尔值为 true 或者 false。

function booWho(bool) {
  if(bool===true||bool===false)
  {
    return true;
  }
  else 
  return false;
}

booWho(null);

句中单词首字母大写
请将传入的字符串中，每个单词的第一个字母变成大写并返回。 注意除首字母外，其余的字符都应是小写的。

在这个挑战中，我们还需要将诸如 the 和 of 之类的连接词大写。

function titleCase(str) {
  let newStr=str.split(' ');
  for(let i=0;i<newStr.length;i++)
  {
     newStr[i] = newStr[i].substring(0,1).toUpperCase()
      + newStr[i].substring(1).toLowerCase();
  }
  return newStr.join(' ');
}

titleCase("I'm a little tea pot");

Slice 与 Splice
将第一个数组中的所有元素依次复制到第二个数组中。

请注意，你需要从第二个数组索引值为 n 的地方开始插入。

最后，请返回插入元素后的数组。 作为输入参数的两个数组在函数执行前后应保持不变。

function frankenSplice(arr1, arr2, n) {
  let newArr = arr2.slice(0,arr2.length);
  for (let i = 0; i < arr1.length; i++) {
   newArr.splice(n, 0, arr1[i]);
    n++;
  }
  return newArr;
}
frankenSplice([1, 2, 3], [4, 5, 6], 1);

过滤数组中的假值
从数组中移除所有假值（falsy values）。

JavaScript 中的假值有 false、null、0、""、undefined、NaN。

提示：可以考虑将每个值都转换为布尔值（boolean）。

function bouncer(arr) {
  let arr1=[];
  for(let i=0;i<arr.length;i++)
  {
    if((arr[i]===false||arr[i]===null||
    arr[i]===0||arr[i]===""||arr[i]===undefined||
    Object.is(arr[i],NaN))==false)
    {
      arr1.push(arr[i]);
    }
  }
  return arr1;
}

bouncer([7, "ate", "", false, 9]);

找出元素在排序后数组中的索引
数组（第一个参数）在排序后，将一个值（第二个参数）插入该数组，并使数组保持有序。返回这个新插入元素的最小索引值。 返回值应为一个数字。

function getIndexToIns(arr, num) {
  if(arr.length==0)
  {
    return 0;
  }
  let t=0;
for(let i=0;i<arr.length-1;i++)
for(let j=i+1;j<arr.length;j++)
{
  if(arr[i]>arr[j])
  {
      t=arr[i];
      arr[i]=arr[j];
      arr[j]=t;
  }
}
for(let i=0;i<arr.length;i++)
{
  if(arr[i]<=num)
  { 
     if(arr[i]==num)
  {
    return i;
  }
      if(num<=arr[i+1])
      {
        return i+1;
      }
     if(i==arr.length-1)
      {
        return i+1;
      }
  }
}
}

getIndexToIns([40, 60], 50);

比较字符串
如果数组里的第一个字符串包含了第二个字符串中的所有字母，则返回 true。

function mutation(arr) {
  let t=0;
 let str1=arr[0];
 let str2=arr[1];
 str1=str1.toUpperCase();
 str2=str2.toUpperCase();
 for(let i=0;i<str2.length;i++)
 for(let j=0;j<str1.length;j++)
 {
   if(str1[j]==str2[i])
   {
     t=1;
     break;
   }
   else t=0;
   if(j==str1.length-1&&t==0)
   {
     return false;
   }
 }
 if(t==1)
 return true;
 else return false;
}

mutation(["hello", "hey"]);

分割数组
请编写一个函数，该函数将一个数组（第一个参数）拆分成若干长度为 size（第二个参数）的子数组，并将它们作为二维数组返回。

function chunkArrayInGroups(arr, size) {
let arr2=[];
let max=Math.ceil(arr.length/size);
for(let i=0;i<max;i++)
{
  arr2.push(arr.slice(i*size,i*size+size));
}
return arr2;
}

chunkArrayInGroups(["a", "b", "c", "d"], 2);