kata的javaScript每日一题算法题

每天给自己学点东西，持续更新。不要求多，用自己的方式去实现然后在去看别人的正解了解自己的不足

2019/8/1

//数组去从
let arrSort = [1,1,2,3,4,2,3,4];
let data = [];
for(let i=0;i<arrSort.length;i++){
if(data.indexOf(arrSort[i])==-1){
data.push(arrSort[i])
}
}

2019/8/2

//求次数出现最多
function findMaxDuplicateChar(str) {
if(str.length == 1) {
return str;
}
let charObj = {};
for(let i=0;i<str.length;i++) {
if(!charObj[str.charAt(i)]) {
charObj[str.charAt(i)] = 1;
}else{
charObj[str.charAt(i)] += 1;
}
}
let maxChar = ‘’,
maxValue = 1;
for(var k in charObj) {
if(charObj[k] >= maxValue) {
maxChar = k;
maxValue = charObj[k];
}
}
return maxChar+’—’+maxValue;
}
const max = findMaxDuplicateChar(‘afjghdfraaaasdena’);
console.log(max,“999”)

2019/8/3

//冒泡排序 从小到大
let arrValue = [1,6,5,11,235,26,100];
function sortarr(arr){
for(let i=0;i<arr.length-1;i++){
for(let j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
let temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
let arr1 = sortarr(arrValue);
console.log(arr1,“999”)

2019/8/4

//随机生成6位字符串
function random(n) {
let str = ‘abcdefghijklmnopqrstuvwxyz9876543210’;
let six = ‘’;
for (let i = 0; i < n; i++) {
console.log(Math.floor(Math.random() * str.length),“Math.random() * str.length”)
console.log(str.charAt(Math.floor(Math.random() * str.length),“Math.random()2222222222”))
six += str.charAt(Math.floor(Math.random() * str.length));
}
return six;
}
console.log(random(6));

2019/8/5

//阶乘
function jiecheng(num){
if(num<1){
return 1;
}else{
return num*jiecheng(num-1)
}
}
// 递加
function dijia(num){
if(num<1){
return 0;
}else{
return num+dijia(num-1);
}
}
console.log(jiecheng(5),“999999”)//120
console.log(dijia(9),“999999”) //45

2019/8/6

按指定分割数组
function chunk(arr, size) {
var new_arr = [];
for(var i=0; i<arr.length; i+=size){
console.log(i,“i+=size11111111111”)
console.log(i+=size,“i+=size”)
new_arr.push(arr.slice(i,i+size));
}
return new_arr;
}
// chunk([“a”, “b”, “c”, “d”,“e”], 2);
console.log(chunk([“a”, “b”, “c”, “d”,“e”], 2))

2019/8/7

//相同某一值数组合并
let arrData = [{a:‘1’,b:“aa”}, {a:‘2’,b:“bb”}, {a:‘3’,b:“cc”}, {a:‘4’,b:“dd”}, {a:‘4’,b:“ee”}, {a:‘4’,b:“ff”}, {a:‘4’,b:“dd”},]
let data1=[];
for (let i = 0; i < arrData.length; i++) {
arrData[i].b = [arrData[i].b]
let flag = false;
for (let j = 0; j < data1.length; j++) {
if (data1[j].a == arrData[i].a) {
data1[j].b = […data1[j].b,…arrData[i].b];
flag = true;
break;
}
}
if (!flag) {
data1.push(arrData[i])
}
}
console.log(data1, ‘data1’)

2019/8/8

  判断传入的是4位或者6位数字返回true或者false。这里注意0000 或者以0开始的
  function validatePIN (pin) {
   //return true or false
    console.log(pin,"0000")
     if(/^[0-9]+$/.test(pin)==true&&(pin.length===4||pin.length==6)){
         return true
   }else {
       return false
   }

}
console.log(validatePIN (‘0900’));

2019/8/9

   看一个纯正数的乘次数；如39； 3*9=27,2*7=14,1*4=4；只能出现3次 我用递归实现 看了别人的之后原来可以如此简单用reduce；reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
   function persistence(num) {

        let m=0;
        if(num<10&&num>=0){
            return 0
        }else{
            let str = num + '';
            function jisuan(num1) {
                m++;
                if(num1<10&&num1>=0){
                    let mm = m-1;m = mm;return m;
                }else{
                    num1 = num1+"";let n=num1.charAt(0);
                    for(let i=0;i<num1.length;i++){
                        n *= num1.charAt(i);
                    }
                    return jisuan(n/num1.charAt(0));
                }
            }
          jisuan(str);
        }
        return m;
    }
      console.log(persistence(39),393939)3
            console.log(persistence(4),393939)0
            console.log(persistence(25),393939)2
            console.log(persistence(999),393939)4

用reduce重写阶乘
function jicheng(n) {
let arr =[];
for(let i = 1;i<=n;i++){
arr.push(i)
}
let abc = arr.reduce((c,t)=>{return c*t})
return abc;
}
console.log(jicheng(5),“9999999999”)//120

2019/8/14

// 在这个小任务中，你会得到一个由空格分隔的数字串，并且必须返回最高和最低的数字。
// 例子：
// highandlow（“1 2 3 4 5”）；//返回“5 1”
// highandlow（“1 2-3 4 5”）；//返回“5-3”
// highandlow（“1 9 3 4 -5”）；//返回“9-5”
function highandlow(str) {
let arr = str.split(’ ').sort(function (a,b) {
return b-a
})
let max = arr[0];
let min = arr[arr.length-1];
return max + ‘—***’+min
}
console.log(highandlow(‘4 5 29 54 4 0 -214 542 -64 1 -3 6 -6’))

2019/8/15

//公共汽车上的人数
// 城市里有一辆公共汽车在行驶，每一个公共汽车站都会有人下车。
// 向您提供整数数组（或元组）的列表（或数组）。每个整数数组有两个项，分别表示在公共汽车站上车的人数（第一项）和下车的人数（第二项）。
// 您的任务是返回在最后一个公共汽车站之后（在最后一个阵列之后）仍在公共汽车上的人数。尽管这是最后一个公共汽车站，但公共汽车并不是空的，有些人还在车上，他们可能睡在那里：d
// 看看测试用例。
// 请记住，测试用例确保总线中的人数始终大于等于0。所以返回的整数不能是负数。
// 第一个整数数组中的第二个值是0，因为总线在第一个总线站是空的。
function number(arr){
let one=0;
arr.forEach((item,index)=>{
one +=(item[0]-item[1]);
})
return one
}
console.log(number([[10,0],[3,5],[5,8]]),“number”)
console.log(number([[3,0],[9,1],[4,10],[12,2],[6,1],[7,10]]),“number”)
console.log(number([[3,0],[9,1],[4,8],[12,2],[6,1],[7,8]]),“number”)

2019/8/20

//2019/8/20
//编写一个算法，它获取一个数组并将所有零移动到末尾，保留其他元素的顺序。
//movezeros（[false，1,0,1,2,0,1,3，“a”]）//返回[false，1,1,2,1,3，“a”，0,0]
movezeros=(arr)=> {
//过滤filter()先===0在拼接！==0；
return arr.filter(v=>v !0).concat(arr.filter(item=>item=0))
}
console.log(movezeros([false,1,0,1,2,0,1,3,‘a’]))
console.log(movezeros([9,0,9,1,2,1,1,3,1,9,0,0,9,0,0,0,0,0,0,0]))
console.log(movezeros([“a”,0,“b”,“c”,“d”,1,1,3,1,9,0,0,9,0,0,0,0,0,0,0]))
console.log(movezeros([1,null,2,false,1,0,0]))
console.log(movezeros([“a”,0,0,0,“b”,null,“c”,“d”,1,false,1,3,[],1,9,0,{},0,9,0,0,0,0,0,0,0]))

2019/8/21

// 说明：
// 给定一个数组（arr）作为参数，完成countsmileys函数，该函数将返回笑脸的总数。
// 笑脸规则：
// -每个笑脸必须包含一对有效的眼睛。眼睛可以营销为：或
// -笑脸可以有鼻子，但不必。鼻子的有效字符是_或
// 每一张笑脸都必须有一张微笑的嘴，这张嘴应该用D或者B来推销。
// 除上述字符外，不允许使用其他字符。
// 有效的笑脸举例：
// ：）：D；-D:。~
// 笑脸无效：
// ；（：>：[]
// 示例案例：
// countsmileys（[’）、’；（’、’；’、’：-d’]）；//应返回2；
// CountsMilleys（[’；d’，’-（’，’-）’，’；~）]；//应返回3；
// countsmileys（[’；]、’[’、’；*’、’$’、’；-d’]）；//应返回1；

    countsmileys=(arr)=>{
        let num=0,A=':',aa=';',B='~',bb='-',C='D',cc=')';
        //傻子解法
        function str(item) {
            if(
                item.indexOf(A+B+C)!==-1||
                item.indexOf(A+bb+C)!==-1||
                item.indexOf(aa+B+C)!==-1||
                item.indexOf(aa+bb+C)!==-1||
                item.indexOf(aa+bb+cc)!==-1||
                item.indexOf(A+bb+cc)!==-1||
                item.indexOf(A+B+cc)!==-1||
                item.indexOf(aa+B+cc)!==-1||
                item.indexOf(aa+C)!==-1||
                item.indexOf(aa+cc)!==-1||
                item.indexOf(A+cc+'')!==-1||
                item.indexOf(A+C)!==-1){
                return true
            }
        }
        for(let i=0;i<arr.length;i++){
            if(str(arr[i])==true){
                num++
            }
        }
        //后面想的正则解法
            let reg = /^[:;][-~]?[D)]$/
        arr.forEach((item,index)=>{
            if(reg.test(item)){
                num++
            }
        })
        return num
    }
  console.log(countsmileys([':)', ';(', ';}', ':-D']))  //2
  console.log(countsmileys([';D', ':-(', ':-)', ';~)']))//3
  console.log(countsmileys([';]', ':[', ';*', ':$', ';-D']))//1

2019/8/22

// 在这个kata中，必须创建一个数字根函数。
// 数字根是数字中所有数字的递归和。给定n，取n的位数之和。如果该值有多个位数，则继续以这种方式减少，直到生成一个位数。这只适用于自然数。
// digital_root(16)
// => 1 + 6
// => 7
//
// digital_root(942)
// => 9 + 4 + 2
// => 15 …
// => 1 + 5
// => 6
function digital_root(num) {
let str = num.toString();
let number = 0;
for(let k in str){
number += +str[k]
}
if(number>9){
return digital_root(number)
}else {
return number;
}
}
console.log(digital_root(98),“aaaa”)//8
// console.log(digital_root(1234))//1

2019/8/23

// 一个孩子在一栋高楼的第N层玩球。这层楼的高度h是已知的。
// 他把球从窗口扔了出去。球反弹（例如）到其高度的三分之二（反弹0.66）。
// 他母亲从离地1.5米的窗户向外看。
// 妈妈会看到球在她窗前经过多少次（包括什么时候落下和弹跳）？
// 有效实验必须满足三个条件：
// 以米为单位的浮点参数“h”必须大于0
// 浮动参数“bounce”必须大于0且小于1
// 浮动参数“window”必须小于h。
// 如果满足上述三个条件，则返回正整数，否则返回-1。
// 注：
// 只有篮板球的高度比窗口参数严格时，才能看到球。
// - h = 3, bounce = 0.66, window = 1.5, result is 3
// - h = 3, bounce = 1, window = 1.5, result is -1
// (Condition 2) not fulfilled).
function bouncingBall(h,float,lookH,number=0){
let falg=h>0&&float<1&&float>0&&lookH<h?true:false;
let num = number;
if(!!falg){
let height=h*float
if(height>=lookH){
num+=2;
return bouncingBall(height,float,lookH,num)
}else {
return num+1;
}
}else {
return -1;
}
}
console.log( bouncingBall(1.6,0.9,1.5),“balabal”)//1
console.log( bouncingBall(3.0, 0.66, 1.5),“balabal”)//3
console.log( bouncingBall(30.0, 0.66, 1.5),“balabal”)//15

2020/2/24

let  arrData = [
			    {id:"1","name":"值1","value":"111"},
			    {id:"1","name":"值1","value":"11111"},
			    {id:"2","name":"值2","value":"25462"},
			    {id:"2","name":"值2","value":"23131"},
			    {id:"2","name":"值2","value":"2315432"},
			    {id:"3","name":"值3","value":"333333"},
			    {id:"4","name":"值4","value":"4444"},
			    {id:"4","name":"值4","value":"4444wq"}
			]
		处理成
		[
    {
        "id": "1",
        "name": "值1",
        "data": [
            {"id": "1", "name": "值1", "value": "111"},
            { "id": "1", "name": "值1", "value": "11111"}
        ]
    },
    {
        "id": "2",
        "name": "值2",
        "data": [
            { "id": "2",  "name": "值2", "value": "25462" },
            { "id": "2", "name": "值2", "value": "23131"},
        ]
    },
    {
        "id": "3",
        "name": "值3",
        "data": [
            {"id": "3", "name": "值3", "value": "333333" }
        ]
    }
]。。
开始
			 let arr = arrData.map((item,index)=>{
				   return item.id
			 })
			 let arr1 = [...new Set(arr)];
			 let arr2 = [];
			  arr2 = arr1.map((item,index)=>{
				 return {id:item,data:[],name:""} 
			  })
			   let arr3 = [];
			  arr3 = arr2.map((item,index)=>{
				  
				  arrData.forEach((item1,index1)=>{
					  if(item.id == item1.id){
						  item.name = item1.name;
						  item.data.push(item1);
					  }
				  })
				  return item;
			  })
			  console.log(arr3,"arr2")