初中级算法

实现数组的 find 方法

let arr = [
  {id: 1, name: "张三"},
  {id: 2, name: "张三"},
  {id: 3, name: "张三"},
  {id: 4, name: "张三"},
]

Array.prototype.myFind = function(callback) {
  for (let i in arr) {
    if (callback(arr[i])) {
      return arr[i]
    }
  }
}

arr.myFind(function(item, index) {
  return item.id === 3
})

颠倒字符串方法

 - 1. 先将字符串转化为数组 split()
 - 2. 使用数组的 reverse() 颠倒
 - 3. 使用 join() 将数组转化为字符串

	function reverseString(str) {
      return str.split("").reverse().join("");
    }
    console.log(reverseString("hello word!"));   

阶乘函数

• 一定要判断 num 为 0 的情况 0的阶乘为 1

      function factorialize(num) {
        if (num === 0) {
          num = 1;
          return num;
        }
        let oldNum = num;
        let i;
        for (i = 1; i < oldNum; i++) {
          num *= i;
        }
        return num;
      }
      console.log(factorialize(5));

回文算法

• 1.先将原始字符串去除多余空格 及标点符号

function palindrome(str) {
  let newStr = str.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\<|\.|\>|\/|\?]/g, "");
  let strArr = newStr.toLowerCase().split("");
  let i;
  for (i = 0; i < strArr.length; i++) {
  	if (strArr[i] === strArr[strArr.length - 1 - i]) {
      if (strArr.length - 1 - i - i === 0 || strArr.length - 1 - i - i === 1) {
        return true;
      }
    } else {
      return false;
    }
  }
}
console.log(palindrome("a l m o s t o m l a"));
      // a l m o s t o m l a
      // 0 1 2 3 4 5 6 7 8 9

求素数

• 1 不是素数, 素数又叫做质数: 除了1和它本身外不能被任何树整除

    let arr = []
    let i
    for (i = 1; i < 100; i++) {
      arr.push(i)
    }
    function get_primes(arr) {
      return arr.filter(value => {
        if (value <= 1) {
          return false
        }
        for (let i = 2; i <= Math.sqrt(value); i++) {
          if (value % i === 0) {
            return false
          }
        }
        return true
      })
    }
    console.log(get_primes(arr))

数组去重

• filter
• indexOf

	let arr = [1, 3, 4, 5, 5, 3, 4, 2]
    let array = arr.filter((item, index, arr) => {
      return arr.indexOf(item) === index
      // console.log(arr.indexOf(item), index) 
    })
    console.log(array)

数组去除干扰项

	let arr = ["1", "2", "", undefined, null, " "]
    let array = arr.filter(item => {
      return item && item.trim()
    })
    console.log(array)

将数组每一项首字母大写其余小写

	function normalize(arr) {
      return arr.map((item) => {
        let s = item.toLowerCase()  注意: 不能和下面一起写, 有bug
        return s.replace(s[0], s[0].toUpperCase())
      })
    }
    console.log(normalize(['adam', "lqqwq", 'lbarT', "LISA", "sasa"]))

将字符串中单词首字母大写其余小写

	function titleCase(str) {
      // 1. 先全部小写
      let newStr = str.toLowerCase().split(" ");
      let retStr = [];
      newStr.forEach((item) => {
        let itemStr = item.split("");
        itemStr[0] = itemStr[0].toUpperCase();
        retStr.push(itemStr.join(""));
      });
      return retStr.join(" ");   
    }
    console.log(titleCase("I'm a littlE tea pot"));

…扩展运算符

	function foo(a, b, ...rest) { 
      if (rest.length === 0) { // rest = [3, 2, 2]
        return 0
      }
      return rest.reduce((prev, value) => {
        return prev + value
      })
    }
    console.log(foo(1,3,3,2,2)
	
	通过 arguments 实现
    function foo1(a,b) {
      var i, rest = []
      if (arguments.length > 2) {
        for (i = 2; i < arguments.length; i++) {
          rest.push(arguments[i])
        }
      }
      console.log(rest)
    }
    foo1(1,2,2,3,1,2)

返回句子中最长单词的长度

   function findLongestWord(str) {
     let MAX = 0;
     str.split(" ").forEach(function (item) {
       if (item.length > MAX) {
         MAX = item.length;
       }
     });
       return MAX;
   }
   console.log(findLongestWord("The quick brown fox jumped over the lazy dog"));

Array.prototype.sort() 排序

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

   function largestOfFour(arr) {
     let i;
     let retArr = [];
     for (i = 0; i < arr.length; i++) {
       let newArr = arr[i].sort((a, b) => {
         return a - b;
       });
       retArr.push(newArr[newArr.length - 1]);
     }
     return retArr;
   }
   console.log(largestOfFour([
          [4, 5, 1, 3],
          [13, 27, 18, 26],
          [32, 35, 37, 39],
          [1000, 1001, 857, 1],
        ]));

检索字符串 lastIndexOf()

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

   function confirmEnding(str, target) {
     if (str.lastIndexOf(target) === str.length - target.length) {
       return true;
     } else {
       return false;
     }
   }
   console.log(confirmEnding("He has to give me a new name", "name"));     

字符串拼接

• 循环拼接一个指定的字符串 num次，如果num是一个负数,则返回一个空字符串。

	function repeat(str, num) {
      if (num < 0) {
        return "";
      }
      let i;
      let newStr = "";
      for (i = 0; i < num; i++) {
        newStr += str;
      }
      return newStr;
    }
    console.log(repeat("abc", 3));

字符串截取算法

• 如果字符串的长度比给定的参数num长，则把多余的部分用…来表示。
• 切记，插入到字符串尾部的三个点号也会计入字符串的长度。
• 然而，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。
• slice() 提取字符串的某个部分并在新字符串中返回被提取的部分。
• 该方法设置两个参数：起始索引（开始位置），终止索引（结束位置）。

	function truncate(str, num) {
      if (str.length > num && num > 3) {
        return str.slice(0, num - 3) + "...";
      }
      if (str.length > num && num <= 3) {
        return str.slice(0, num) + "...";
      }
      return str;
    }
    console.log(truncate("A-tisket a-tasket A green and yellow basket", 3));

数组截取

• slice() :字符串和数组都有的方法: 截取方法
• 编写一个函数,把一个数组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) {
        let newArr = [];
        let i;
        for (i = 0; i < arr.length / size; i++) {
          newArr.push(arr.slice(size * i, size * (i + 1)));
        }
        return newArr;
      }
      console.log(chunk(["a", "b", "c", "d", "f"], 2));

	  // 返回一个数组被截断n个元素后还剩余的元素，从索引0开始截断。
      function slasher(arr, howMany) {
        arr.splice(0, howMany);
        return arr;
      }
      console.log(slasher([1, 2, 3], 2));

数组查询算法

• 如果数组第一个字符串元素包含了第二个字符串元素的所有字符，则函数返回true。
• 举例，[“hello”, “Hello”]应该返回true，因为在忽略大小写的情况下，
• 第二个字符串的所有字符都可以在第一个字符串找到。
• [“hello”, “hey”]应该返回false，因为字符串"hello"并不包含字符"y"。
• [“Alien”, “line”]应该返回true，因为"line"中所有字符都可以在"Alien"找到。

      function mutation(arr) {
        let i, j;
        let newArr = [];
        let firstStr = "";
        let lastStr = "";
        for (i = 0; i < arr.length; i++) {
          newArr.push(arr[i].toLowerCase());
        }
        firstStr = newArr[0];
        lastStr = newArr[1];
        // 将 lastStr 字串转化成为数组
        let lastArr = lastStr.split("");
        for (j = 0; j < lastArr.length; j++) {
          if (firstStr.indexOf(lastArr[j]) === -1) {
            return false;
          }
        }
        return true;
      }
      console.log(mutation(["Hello", "hEy"]));

      /**
      删除数组中特定值算法挑战
    */
      // 删除数组中的所有的假值。
      // 在JavaScript中，假值有false、null、0、""、undefined 和 NaN。
      function bouncer(arr) {
        return arr.filter((item) => {
          return Boolean(item);
        });
      }
      console.log(bouncer([7, "ate", "", false, 9, undefined, NaN, 0, "0"]));

      /**
      去除数组中任意多个值算法挑战
    */
      // 实现一个 destroyer 函数，第一个参数是初始数组，后跟一个或多个参数。
      // 从初始数组中删除与这些参数具有相同值的所有元素。
      function destroyer(arr) {
        let i;
        for (i = 1; i < arguments.length; i++) {
          arr = arr.filter((item) => {
            return item !== arguments[i];
          });
        }
        return arr;
        // let i, j
        // for (i = 1; i < arguments.length; i++) {
        //   for (j = 0; j < arguments[0].length; j++) {
        //     if (arguments[i] === arguments[0][j]) {
        //       arguments[0].splice(j, 1)
        //     }
        //   }
        // }
        // return arguments[0]
      }
      console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

      /**
      数组排序并插入值算法挑战
    */
      // 先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。
      // 举例：where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]
      // 后变成[1,1.5,2,3,4]，而1.5对应的索引值就是1。
      // 同理，where([20,3,5], 19) 应该返回 2。因为数组会先排序为 [3,5,20]，
      // 19插入到数组[3,5,20]后变成[3,5,19,20]，而19对应的索引值就是2。
      function where(arr, num) {
        arr[arr.length] = num;
        arr.sort(function (a, b) {
          return a - b;
        });
        return arr.indexOf(num);
      }
      console.log(where([1, 2, 3, 4, 5], 1.5));

      /**
      位移密码算法挑战
    */
      function rot13(str) {
        var start = "A".charCodeAt(0);
        var end = "Z".charCodeAt(0);
        var objstr = "";

        var strs = str.split(" ");
        for (var i = 0; i < strs.length; i++) {
          for (var j = 0; j < strs[i].length; j++) {
            if (
              strs[i].charCodeAt(j) >= start &&
              strs[i].charCodeAt(j) <= end
            ) {
              if (
                strs[i].charCodeAt(j) - 13 >= start &&
                strs[i].charCodeAt(j) - 13 <= end
              ) {
                objstr += String.fromCharCode(strs[i].charCodeAt(j) - 13);
              } else {
                objstr += String.fromCharCode(strs[i].charCodeAt(j) + 13);
              }
            } else {
              objstr += strs[i][j];
            }
          }
          objstr += " ";
        }
        return objstr.substr(0, objstr.length - 1);
      }
      rot13("SERR PBQR PNZC");

      

      // 删除数组(第一个参数)的元素，从左边开始，直到回调函数（第二个参数）return true就停止。
      // 第二个参数任意值
      // function(n) {return n === 1} 或者 n > 3
      function drop(arr, func) {
        let i,
          j = 0;
        for (i = 0; i < arr.length; i++) {
          if (func(arr[i])) {
            arr.splice(0, i);
            return arr;
          }
          j++;
          if (j === arr.length && !func(arr[arr.length - 1])) {
            return (arr = []);
          }
        }
      }
      console.log(
        drop([1, 2, 3, 4], function (n) {return n > 5})
      );

      /**
      数组平铺算法挑战
    */
      // 对嵌套的数组进行平铺嵌套数组。你必须考虑到不同层级的嵌套。
      // 例如: steamroller([[["a"]], [["b"]]]) 应该返回 ["a", "b"]。
      // steamroller([1, [2], [3, [[4]]]]) 应该返回 [1, 2, 3, 4]。
      // steamroller([1, [], [3, [[4]]]]) 应该返回 [1, 3, 4]。
      // steamroller([1, {}, [3, [[4]]]]) 应该返回 [1, {}, 3, 4]。
      function steamroller(arr) {
        let newArr = [];
        function diGui(array) {
          let i;
          for (i = 0; i < array.length; i++) {
            if (Array.isArray(array[i])) {
              // console.log(array[i])
              diGui(array[i]);
            } else {
              newArr.push(array[i]);
            }
          }
        }
        diGui(arr);
        return newArr;
      }
      console.log(steamroller([1, [2], [3, [[4]]]]));
      // steamroller([1, [2], [3, [[4]]]]);

      /**
      数组去重算法挑战
    */
      // 例如: unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应该返回 [1, 3, 2, 5, 4]。
      // unite([1, 3, 2], [1, [5]], [2, [4]]) 应该返回 [1, 3, 2, [5], [4]]。
      // unite([1, 2, 3], [5, 2, 1]) 应该返回 [1, 2, 3, 5]。
      // unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]) 应该返回 [1, 2, 3, 5, 4, 6, 7, 8]。
      function unite(arr1, arr2, arr3) {

        let args = Array.from(arguments)
        let arr = args.reduce((prev, item) => {
          return prev.concat(item)
        })
        //  reduce 函数设置初始化值, prev 为初始化值
        // 不设置初始化值, prev 为数组第一项的值
        // 数组迭代方法基本上都有 item, index, arr 这个参数
        return arr.filter((item, index, arr) => {
          return arr.indexOf(item) === index
          // console.log(arr.indexOf(item) === index, index, arr.indexOf(item))
        })
        // let array1 = arguments[0];
        // let newArr = []
        // // 先判断一下 arr1 中是否有重复元素, 有就删除
        // for (let i = 0; i < array1.length - 1; i++) {
        //   for (let j = i + 1; j < array1.length; j++) {
        //     if (array1[i] === array1[j]) {
        //       array1.splice(j, 1)
        //     }
        //   }
        // }
        // for (let i = 1; i < arguments.length; i++) {
        //   for (let j = 0; j < arguments[i].length; j++) {
        //     console.log(arguments[i][j])
        //     func(arguments[i][j])
        //   }
        // }
        // function func(n) {
        //   newArr = array1.filter(item => {
        //     return item === n
        //   })
        //   if (newArr.length === 0) {
        //     array1.push(n)
        //   }
        // }
        // return array1
      }
      console.log(unite([1, 3, 1, 2], [5, 2, 1, 4], [2, 1]));

      /**
        字符串连接算法挑战
      */
      // 将字符串转换为 spinal case。Spinal case 是   
      // all-lowercase-words-joined-by-dashes 这种形式的，
      // 也就是以连字符连接所有小写单词。
      // 例如: spinalCase("This Is Spinal Tap") 应该返回 "this-is-spinal-tap"。
      // spinalCase("thisIsSpinalTap") 应该返回 "this-is-spinal-tap"。
      // spinalCase("The_Andy_Griffith_Show") 应该返回 "the-andy-griffith-show"。
      // spinalCase("Teletubbies say Eh-oh") 应该返回 "teletubbies-say-eh-oh"。
      function spinalCase(str) {
        
        // console.log(str.replace(/[A-Z]/g, "-"))
        // return str;
      }

      console.log(spinalCase('ThisIs Spinal Tap1'))

      /**
        数组验证算法挑战
      */
      // 写一个 function，它查找数组（第一个参数）并返回
      // 数组中第一个通过某种方法（第二个参数）验证的元素。
      function find(arr, func) {
        let num = 0;
        return num = arr.filter(item => {
          return func(item)
        })[0]
      }

      console.log(find([1, 2, 3, 4], function(num){ return num % 2 === 0; }))