FreeCodeCamp初级js算法题小结

FreeCodeCamp初级js算法题小结

1.翻转字符串

先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，最后把数组转化成字符串。
你的结果必须得是一个字符串

思路

str.split("").reverse().join("")

2.计算一个整数的阶乘

如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。
阶乘通常简写成 n!
例如: 5! = 1 * 2 * 3 * 4 * 5 = 120

思路

基本方法
  var i=1;
  var product=1;

  for(i=1;i<=num;i++){
    product*=i;
  }
  return product;

优化方法
return num > 1?num * factorialize(num - 1):1;

3.如果给定的字符串是回文，返回true，反之，返回false。

如果一个字符串忽略标点符号、大小写和空格，正着读和反着读一模一样，那么这个字符串就是
注意你需要去掉字符串多余的标点符号和空格，然后把字符串转化成小写来验证此字符串是否为回文。

思路

常用方式
    function palindrome(str) {  
      //去标点符号、大小写和空格
      var arra=str.toLowerCase().replace(/[^A-Za-z0-9]/g,"");  //注意和/\W/g的区别
      //反转
      var arrb=arra.split("").reverse().join("");  
     if(arra==arrb){  
      return true;  
      }  
      else{  
        return false;  
     }  

    }  
    palindrome("0_0 (: /-\ :) 0-0");  

优化方式
function palindrome(str) {
  // Good luck!
  var re = /[\W\s_]/gi;
  str = str.replace(re,"");
  return str.toLowerCase() === str.split("").reverse().join("").toLowerCase();
}

4.找到提供的句子中最长的单词，并计算它的长度。

函数的返回值应该是一个数字。
这个没有用什么生疏的方法，split拆分字符串，然后循环判断最长的String.length；

function findLongestWord(str) {
  var newstr = str.split(" ");
  var max = newstr[0].length;
  for(var i = 0, l = newstr.length; i < l; i++) {
  if (max<newstr[i].length)
    max=newstr[i].length;
} 
//if(max<tmp[i])max=tmp[i]
return max;
}

findLongestWord("The quick brown fox jumped over the lazy dog");

5.确保字符串的每个单词首字母都大写，其余部分小写。

确保字符串的每个单词首字母都大写，其余部分小写。
像’the’和’of’这样的连接符同理。

我的方法
function titleCase(str) {
  var arrystr = str.toLowerCase().split(" ");
  for(var i=0;i<arrystr.length;i++){
    arrystr[i] = arrystr[i].slice(0,1).toUpperCase() + arrystr[i].slice(1);
  }
    return arrystr.join(" ");
}

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


看到的方法
function titleCase(str) {
  var arr=str.split(' ');
  for(i=0;i<arr.length;i++){
    arr2=arr[i].split('');
    arr2[0]=arr2[0].toUpperCase();
    for(j=1;j<arr2.length;j++){
      arr2[j]=arr2[j].toLowerCase();
    }

    arr[i]=arr2.join('');

  }
  var newStr=arr.join(' ');

  return newStr;
}

6.右边大数组中包含了4个小数组，分别找到每个小数组中的最大值，然后把它们串联起来，形成一个新数组。

你可以用for循环来迭代数组，并通过arr[i]的方式来访问数组的每个元素。

我的方法
function largestOfFour(arr) {
  // You can do this!

var max=[];
  for(var k=0;k<arr.length;k++){ 
    max[k] = arr[k][0];
    for(var i=0;i<arr[k].length;i++){
        if(max[k]<arr[k][i]){
        max[k] = arr[k][i];
  }

    }

 }
   return max;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

看到的另一种思路
function largestOfFour(arr) {
  // You can do this!
  var newArr=[];
  for(i=0;i<arr.length;i++){
    arr[i].sort(function(a,b){
      return b-a;
    });

    newArr.push(arr[i][0]);
  }
    return newArr;

}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

7.检查一个字符串(str)是否以指定的字符串(target)结尾。如果是，返回true;如果不是，返回false。

思路：主要是用到了substr() 方法
substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符。

优化的方法
function confirmEnding(str, target) {
  if(str.substr(str.length-target.length)==target){
    return true;
  }else{
    return false;
  }
}

8.重复一个指定的字符串 num次，如果num是一个负数则返回一个空字符串。

优化版思路
function repeat(str, num) {
  // repeat after me
  var str0=str;
  if(num<=0){
    return '';
  }else{
    for(i=0;i<num-1;i++){
      str+=str0;
    }
    return str;
  }
}

9.截断一个字符串！

如果字符串的长度比指定的参数num长，则把多余的部分用…来表示。
切记，插入到字符串尾部的三个点号也会计入字符串的长度。
但是，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。

function truncate(str, num) {
  var l = str.length;
  if(3 < num&& num< l){
    newstr = str.slice(0,(num-3)) + "...";
  } else if(num <= 3){
    newstr = str.slice(0,num) + "...";
  } else if(num >= l){
    newstr = str;
  }
  return newstr;
}

truncate("Absolutely Longer", 2);

10.把一个数组arr按照指定的数组大小size分割成若干个数组块。

例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];
chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]];

我的方法
function chunk(arr, size) {
  var l = arr.length;
  var n = Math.floor(l/size);
  var smallarr = [];
  if(l > size && l%size === 0){
    for(i=0;i<n;i++){
    smallarr[i] = arr.slice(i*size,(i+1)*size); 

    } 

  } else if(l > size && l%size !== 0){
    for(i=0;i<n;i++){
    smallarr[i] =  arr.slice(i*size,(i+1)*size);  
    smallarr[i+1] = arr.slice(-(l%size));  
    } 
  }

  return smallarr;
}
chunk([0, 1, 2, 3, 4, 5], 3);

优化版
function chunk(arr ,size) {
  var newarr=[];
  for(var i=0;i<arr.length;i+=size) {
    newarr.push(arr.slice(i,i+size));
  }
  return newarr;
}

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

11.返回一个数组被截断n个元素后还剩余的元素，截断从索引0开始。

function slasher(arr, howMany) {
  // it doesn't always pay to be first
  if(howMany===0){
    return arr;
  }
  arr=arr.splice(howMany,arr.length-1);
  return arr;

}

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

12.如果数组第一个字符串元素包含了第二个字符串元素的所有字符，函数返回true。

举例，[“hello”, “Hello”]应该返回true，因为在忽略大小写的情况下，第二个字符串的所有字符都可以在第一个字符串找到。
“hello”, “hey”]应该返回false，因为字符串”hello”并不包含字符”y”。

基础的方法
function mutation(arr) {
  var a1=arr[0].toLowerCase();
  var a2=arr[1].toLowerCase();
  if(a1===a2){
    return true;
  }else{
    var count=0;
    for(i=0;i<a2.length;i++){
      for(j=0;j<a1.length;j++){
        if(a2[i]==a1[j]){
          count+=1;
        }
      }
    }
    if(count>=a2.length){
      return true;
    }else{
      return false;
    }
  }  
}

13.删除数组中的所有假值。

在JavaScript中，假值有false、null、0、”“、undefined 和 NaN。

我的方法
function bouncer(arr) {
  function condition(element) {
    if(element)return element;
  }
  return  arr.filter(condition);
}

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

14.实现一个摧毁(destroyer)函数，第一个参数是待摧毁的数组，其余的参数是待摧毁的值。

思路：要逐步判断arr内的每个参数值，满足一样的删除掉即可，但是在循环内删除会破坏结构，所以可以先替换为一个false，然后再来用filter判断返回出真值。

//注意argument.length是参数，array.length是数组
function destroyer(arr) {
  for(i=1;i<arguments.length;i++){
    for(j=0;j<arr.length;j++){
      if(arr[j]==arguments[i]){
        arr.splice(j,1,false);//起始项数，要删除的值数，添加项内容
      }
    }

  }
  arr=arr.filter(function(a){
    return a;
  });
  return arr;
}

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