//判断是否为回文
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
前端算法题
于 2020-11-28 23:48:39 首次发布