前端算法题

    //判断是否为回文
    function ifhuiwen(str) {
        return str == str.split('').reverse().join('')
    }
    ifhuiwen("mamam")

    //快速排序
    function quickSort(arr) {
        if (arr.length <= 1) {
            return arr;
        } else {
            var povitIndex = Math.floor(arr.length / 2)
            var povit = arr.splice(povitIndex, 1)[0]
            var left = []
            var right = [];
            for (let i = 0; i < arr.length; i++) {
                if (arr[i] > povit) {
                    right.push(arr[i])
                } else {
                    left.push(arr[i])
                }
            }
            return quickSort(left).concat([povit], quickSort(right))
        }
    }
    quickSort([3, 5, 6, 6, 2, 90, 5])
    //深拷贝
function deepCopy(obj){
    //判断是否是简单数据类型，
    if(typeof obj == "object"){
        //复杂数据类型
        var result = obj.constructor == Array ? [] : {};
        for(let i in obj){
            result[i] = typeof obj[i] == "object" ? deepCopy(obj[i]) : obj[i];
        }
    }else {
        //简单数据类型 直接 == 赋值
        var result = obj;
    }
    return result;
}
    //将数字字符串转为金额
    function toRMB(str) {
        var arr = str.split('').reverse()
        var res = []
        for (let i = 0; i < arr.length; i++) {
            res.push(arr[i])
            if ((i + 1) % 3 == 0) {
                res.push(",")
            }
        }
        return res.reverse().join("")
    }
    toRMB("12345678")

    //每隔n个字符就用，隔开
    function splitStr(str, n) {
        var arr = str.split("")
        var res = []
        for (let i = 0; i < arr.length; i++) {
            res.push(arr[i])
            if ((i + 1) % n == 0) {
                res.push(",")
            }
        }
        return res.join("")
    }
    splitStr("3765847595", 4)

    //阶乘 0!=1
    //1.递归方法
    function factoria1(num) {
        if (num <= 1) {
            return 1
        } else {
            return num * factoria(num - 1)
        }
    }
    factoria1(5)
    //2.while方法
    function factoria2(num) {
        var result = 1
        while (num) {
            result *= num;
            num--
        }
        return result;
    }
    factoria2(5)
    //3.for方法
    function factoria3(num) {
        if (num <= 1) {
            return 1
        } else {
            for (let i = num - 1; i >= 1; i--) {
                num *= i
            }
            return num
        }
    }
    factoria3(5)

    //斐波那契数列 f(0)=1 f(1)=1 f(n)=f(n-1)+f(n-2)(n>2且为正整数)
    //1.递归方法
    function f1(n) {
        if (n == 1 || n == 2) {
            return 1
        } else {
            return f(n - 1) + f(n - 2)
        }
    }
    f1(3)
    //2.动态规划方法
    function f2(n) {
        if (n == 1 || n == 2) {
            return 1
        } else {
            let n1 = 1, n2 = 1, sum = 1
            for (let i = 3; i <= n; i++) {
                sum = n1 + n2
                n1 = n2
                n2 = sum
            }
            return sum
        }
    }
    f2(3)

    //清除字符串前后的空格
    function trim(str) {
        if (str && typeof str == "string") {
            return str.replace(/(^\s*)|(\s*)$/g, "")
        }
    }
    trim("  jdg ")

    //统计字符串中字母个数或者统计最多字母数
    function getletterNum(str) {
        var obj = {};
        for (var i = 0; i < str.length; i++) {
            var v = str.charAt(i)
            if (obj[v] && obj[v].value == v) {
                obj[v].count = ++obj[v].count;
            } else {
                obj[v] = {};
                obj[v].count = 1;
                obj[v].value = v;
            }
        }
        return obj
    }
    getletterNum("aaaacg")

    //防抖
    function f1(){}
    function debounce(fn, wait) {
        var timeout = null;
        return function () {
            if (timeout !== null) {
                clearTimeout(timeout);
            }
            timeout = setTimeout(fn, wait);
        }
    }
    debounce(f1,10)

    //节流
    function f1(){}
    function throttle(fn,time){
        var last = 0;
        return function(){
            let that=this;
            let args=arguments
            let now=Date.now()
            if(now-last>=time){
                fn.apply(that,args)
                last=now
            }
        }
    }
    throttle(f1,10)

    //找出句子中最长的单词，并计算他的长度
    function findLongestString(str){
        var arr=str.split(" ")
        arr.sort(function(a,b){
            return b.length-a.length
        })
        var res=[]
        for(let i=0;i<arr.length;i++){
            if(arr[i].length==arr[0].length){
              res.push({value:arr[i],length:arr[0].length})
            }
        }
        return res
    }
    findLongestString("i love yoyo")

    //判断是否以指定字符结尾
    function confirmEnding(str,target){
        var len=target.length;
        var end=str.slice(-len)
        if(end==target){
            return true
        }else{
            return false
        }
    }
    confirmEnding("china",'a')

    //删除数组中所有的假值 false、null、0、""、undefined 和 NaN
    function bouncer(arr) {
        return arr.filter(Boolean);//arr.filter(function (x) { return Boolean(x); });
    }
    bouncer([7, "ate", 0, "", false, 9, NaN, undefined, null]); //[7, "ate", 9]

    //创建原生方法repeatify 给定次数重复字符串
    String.prototype.repeatify=String.prototype.repeatify||function(times){
        var str=''
        for(let i=0;i<times;i++){
             str+=this
        }
        return str
    }
    "hello".repeatify(3)

    //一个数组中间高两边低
    function middleSort(str){
        var num = str.split(',');
        var len = num.length;
        var left = [], right = [];
        for (var i = 0; i < len; i++) {
            if (i < len / 2) {
                left.push(num[i]);
            } else {
                right.push(num[i]);
            }
        }
        left.sort(function (a, b) { return a - b });
        right.sort(function (a, b) { return b - a });
        return left.concat(right).join(',');
    }
    middleSort("1,4,5,23,2,17,24,10000000")
   
    //宣讲会安排
    //一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。 给你每一个项目开始的时间和结束的时间
    //(数组，里面是一个个具体的项目)，你来安排宣讲的日程，要求会议室进行 的宣讲的场次最多。返回这个最多的宣讲场次。
    function getMostCount(obj) {
        if (!obj || obj.length < 1) {
            return;
        };
        obj.sort(sortEndTime);
        let res = 1, now = obj[0].end;
        for (let i = 1; i < obj.length; i++) {
            if (now < obj[i].start) {
                res++;
                now = obj[i].end;
            }
        }
        return res;
    }
    function sortEndTime(obj1, obj2) {
        return obj1.end - obj2.end;
    }
    var obj = [
        { start: 6, end: 8 },
        { start: 7, end: 9 },
        { start: 11, end: 12 },
        { start: 10, end: 14 },
        { start: 16, end: 18 },
        { start: 17.5, end: 21 },
        { start: 15, end: 17 },
        { start: 22, end: 23 }
    ];
    getMostCount(obj);

    //字符串原位反转
    function reverseInPlace(str){
         return str.split(' ').reverse().join(' ').split('').reverse().join('');
    }
    reverseInPlace('I am the good boy');//"I ma eht doog yob"

    //连字符转成驼峰  如get-element-by-id 转为 getElementById
    function toHump(str){
    　　let arr = str.split('-');
    　　for(let i=1; i <arr.length;i++){
            arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
           }
            return arr.join('')
    }
    toHump('get-element-by-id')

    //删除相邻相同的字符串
    function delSrt(str) {
        let res = [], nowStr;
        for (let i = 0; i < str.length; i++) {
            if (str.charAt(i) != nowStr) {
                res.push(str.charAt(i));
                nowStr = str.charAt(i);
            }
        }
        return res.join("");
    }
    delSrt("aabcc11")

    //验证一个数是否是素数
    function isPrime(num) {
        if (num === 2 || num === 3) {
            return true;
        };
        if (num % 2 === 0) {
            return false;
        };
        let divisor = 3, limit = Math.sqrt(num);
        while (limit >= divisor) {
            if (num % divisor === 0) {
                return false;
            }
            else {
                divisor += 2;
            }
        }
        return true;
    }
    isPrime(30); // false
    
    //求最大公约数
    function greatestCommonDivisor(a, b) {
        if (b === 0) {
            return a;
        }else{
            return greatestCommonDivisor(b, a%b);
        }
    };
    
    //排序两个已经排好序的数组
    function mergeSortedArr(a, b) {
        if (!a || !b) {
            return;
        };
        let aEle = a[0], bEle = b[0], i = 1, j = 1, res = [];
        while (aEle || bEle) {
            if ((aEle && !bEle) || aEle <= bEle) {
                res.push(aEle);
                aEle = a[i++];
            }
            else {
                res.push(bEle);
                bEle = b[j++];
            }
        }
        return res;
    }
    mergeSortedArr([2, 5, 6, 9], [1, 2, 3, 29]) // [1,2,2,3,5,6,9,29]
    
    //判断数组中是否有两数之和
    function sumFind(arr, num) {
        if (!arr || arr.length < 2) {
            return;
        };
        let differ = {};
        for (let i = 0; i < arr.length; i++) {
            let subStract = num - arr[i];
            if (differ[subStract]) {
                return true;
            }
            else {
                differ[arr[i]] = true;
            }
        }
        return false;
    }
    sumFind([6, 4, 3, 2, 1, 7], 9) // true
    
    //加油站问题-贪心算法
    //一辆汽车加满油后可行驶n公里。旅途中有若干个加油站。设计一个有效算法，
    //指出应在哪些加油站停靠加油，使沿途加油次数最少。对于给定的n(n <= 5000)和k(k <= 1000)个加油站位置，
    //编程计算最少加油次数。并证明算法能产生一个最优解。
    //要求:
    //输入：第一行有2个正整数n和k，表示汽车加满油后可行驶n公里，且旅途中有k个加油站。
    //接下来的1 行中，有k+1 个整数，表示第k个加油站与第k-1 个加油站之间的距离。第0 个加油站表示出发地，
    //汽车已加满油。第k+1 个加油站表示目的地。
    //输出：输出编程计算出的最少加油次数。如果无法到达目的地，则输出”NoSolution”。
    function greedy(n, k, arr) { // n:加满可以行驶的公里数; k:加油站数量; arr:每个加油站之间的距离数组
        if (n == 0 || k == 0 || arr.length == 0 || arr[0] > n) {
            return "No Solution!"; // arr[0] > n ：如果第一个加油站距离太远，也无法到达
        };
        let res = 0, distance = 0; // res：加油次数;distance：已行驶距离
        for (let i = 0; i <= k; i++) {
            distance += arr[i];
            if (distance > n) { // 已行驶距离 > 加满可以行驶的公里数
                if (arr[i] > n) { // 如果目前加油站和前一个加油站的距离 > 加满可以行驶的公里数，则无法到达
                    return "No Solution!";
                };
                // 可以在上一个加油站加油，行驶到目前的加油站i：
                distance = arr[i];
                res++; // 加油次数+1
            }
        }
        return res;
    }
    let arr = [1, 2, 3, 4, 5, 1, 6, 6];
    greedy(7, 7, arr) // 4
    
    //岛问题：判断有几个岛
    //给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
    //岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
    //此外，你可以假设该网格的四条边均被水包围。
    //输入:
    //11000
    //11000
    //00100
    //00011
    //输出: 3
    //解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。
    function numIslands(grid) {
    	let [num] = [0];
    	if(grid && grid.length){
    		const [maxI,maxJ] = [grid.length-1,grid[0].length-1];
    		let overturn = (i,j) => {
    			if(i < 0 || j < 0 || i > maxI || j > maxJ) return;
    			if(grid[i][j] === '1'){
    				grid[i][j] = '0';
                    overturn(i,j-1);
                    overturn(i,j+1);
                    overturn(i-1,j);
                    overturn(i+1,j);
    			}
    		}
    		for(let i = 0; i < grid.length; i++){
    			for(let j = 0; j < grid[0].length; j++){
    				if(grid[i][j] === '1'){
    					num++;
    					overturn(i,j)
    				}
    			}
    		}
    	}
    	return num;
    }
    let a = [["1","1","0","0","0"],["1","1","0","0","0"],["0","0","1","0","0"],["0","0","0","1","1"]]
    numIslands(a)

    //汉诺塔问题
    //把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，
    //并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。
    //思路：
    //递归解决：把问题转化为规模缩小了的同类问题的子问题;
    //明确递归结束的条件(base case)：n == 1
    //其他过程：from：来源地;to：目的地;help：辅助。
    function hanoiProcess(n, from, to, help) {
        if (n < 1) {
            return;
        }
        if (n == 1) { // 最后一个从from移到to
            console.log("Move 1 from " + from + " to " + to);
        } else {
            hanoiProcess(n - 1, from, help, to); // 前n-1个从from移到help上，可以借助to
            console.log("Move " + n + " from " + from + " to " + to);
            hanoiProcess(n - 1, help, to, from); // 再把n-1个从help移到to，可以借助from
        }
    }
    hanoiProcess(3, "左", "右", "中");
    //结果：
    //Move 1 from 左 to 右
    //Move 2 from 左 to 中
    //Move 1 from 右 to 中
    //Move 3 from 左 to 右
    //Move 1 from 中 to 左
    //Move 2 from 中 to 右
    //Move 1 from 左 to 右
    
    //母牛生母牛问题
    //母牛每年生一只母牛，新出生的母牛成长三年后也能每年生一只母牛，假设不会死。求N年后，母牛的数量。
    //思路：
    //因为新生的母牛，只有等到第四年才能生小母牛。所以前4年，只有原来的一头母牛每年生一头。
    //第五年以后，除了有前一年的牛数量，还有三年前的牛可以生新的小牛。(最近3年内生的牛还不能生)
    function cow(n) {
        if (n < 1) {
            return;
        };
        let count = 0;
        if (n > 4) {
            count = cow(n - 1) + cow(n - 3);
        } else {
            count = n;
        }
        return count;
    }
    let n = 7;
    console.log(n + " 年后，牛的数量是： " + cow(n))   // 7 年后，牛的数量是： 13