查漏补缺（九）---程序篇

函数

1. 题目：输入一个字符串,返回该字符串出现最多的字母

function strMax(str){
    
	let obj={
    };
	for(let i=0;i<str.length;i++){
    
		let k = str.charAt(i);
		if(obj[k]){
    
			obj[k]++;
		}else{
    
			obj[k]=1;
		}
	}
	let a = 0;
	let temp = null;
	for(let j in obj){
    
		if(obj[j]>a){
    
			a=obj[j];
			temp=j;
		}
	}
	return temp;
}

strMax('hello world')

2. 题目：编写查询函数返回数字字符串中最大的公共前缀字符串

function longStr(str){
    
	const string = str[0];
	let result = '';
	if(str.length == 0){
    
		return result;
	}
	for(let i=0;i<string.length;i++){
    
		for(let j=1;j<str.length;j++){
    
			if(f[i] !== str[j][i]){
    
				return result;
			}
		}
		result += f[i];
	}
	return result;
}
longStr(['lee','les','levis'])

3. 题目：给你一个数组，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用替换。完成所有替换操作后，请你返回这个数组。

function getNewArr(arr){
    
	let result = arr.map((item, index)=>{
    
		if(index === arr.length-1){
    
			return -1;
		}else{
    
			let rest = arr.slice(index+1);
			let max = Math.max(...rest);
			return max;
		}
	})
	return result;
}

4. 题目：对象数组去重

const hash = {
    };
function arrFilter(array){
    
	const newArr = array.reduce((prev, cur)=>{
    
		hash[cur.fieldName] ? '' : hash[cur.fieldName] = true && prev.push(cur);
		return prev;
	},[])
}

reduce方法

arr.reduce((preValue, curValue, index, arr)=>{
	pre：初始值，计算后的返回值
	cur:：当前元素
	index：当前索引
	arr：原数组
	...
},init)

reduce方法求数组中的最大值

const value = arr.reduce((pre, cur)=>{
    
	return (pre>cur) ? pre : cur;
})

5. 莱布尼兹公式求圆周率π

function cal(n){
    
	let sum = 0;
	let item = 1;
	for(let i=1;i<=n;i++){
    
	//把每一项计算出来，然后相加
		item *= i/(2*i+1);
		sum += item;
	}
	return (sum+1)*2;
}

6. 寻找100以内的质数

outer: for(let i=2;i<=100;i++){
    
//内层循环从2开始，如果能够整除说明不是质数
	for(let j=2;j<i;j++){
    
		if(i%j==0){
    
			continue outer;
		}
	}
	console.log(i);
}

7. 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。假设数组中无重复元素。

//方法一
function searchValue(arr, target){
    
	let index = 0;
    for(let i=0;i<arr.length;i++){
    
    	if(arr[i] === target){
     
        	return index = i
        }
    }
    if(!index){
    
    	arr.push(target)
        arr.sort(function(a, b){
    
        	return a-b
        })
    }
//indexOf可以查找数组
     index = arr.indexOf(target)
     return index
}
//方法二
function getTargetIndex(list,target){
    
        if(!list.includes(target)){
    
            list.push(target)
        }
        list.sort((a,b) => {
    
            return a - b
        })
        return list.indexOf(target)
}