当前位置:网站首页>js 基础算法题(一)

js 基础算法题(一)

2020-11-10 10:45:02 黄万通

一、转驼峰

  • user-top-info-name 变为驼峰 userTopInfoName

方法 1-利用数组

function toCamelCase(str) {
  if (!str) return ''
  // 首先将字符串转换为小写
  str = str.toLowerCase()
  // 使用 split 将字符串转换为数组
  let strArr = str.split('-')
  // 使用 map 遍历数组,数组第一个不用转,其它的都转
  /*
    strArr =  strArr.map((item,index) => {
    if(index !==0) {
      return item[0].toUpperCase()+item.substr(1)
    }else {
      return item
    }
    })
  */
  // 简化写法
  strArr = strArr.map((item, index) =>
    index !== 0 ? item[0].toUpperCase() + item.substr(1) : item
  )
  // 使用数组的 join 方法将加工后的数组转换为字符串返回
  return strArr.join('')
}
// 测试
console.log(toCamelCase('user-top-info-name')) // 输出:userTopInfoName

方法 2-使用正则

function toCamelCase2(str) {
  if (!str) return ''
  // 首先将字符串转换为小写
  str = str.toLowerCase()
  str = str.replace(/(\-\w)/g, (chars) => chars[1].toUpperCase())
  return str
}
// 测试
console.log(toCamelCase('user-top-info-name')) // 输出:userTopInfoName

二、数组去重

function uniqueArray(arr) {
  // 使用Set将数组去重,然后在使用Array.from方法将set转换为数组返回
  // return Array.from(new Set(arr))
  return [...new Set(arr)] // 也可以使用三点运算符
}
// 测试
console.log(uniqueArray([2, 2, 3, 3, 4, 4, 5, 5, 6, 6]))

三、统计字符串中出现最多的字母

function getlongestChar(str) {
  if (!str) return ''
  if (str.length === 1) return str
  // 定义一个对象存储字符
  let obj = {}
  // 循环遍历字符串
  for (let i = 0; i < str.length; i++) {
    // 得到当前字符
    let char = str.charAt(i)
    // 判断当前字符是否obj的属性,如果是就为该属性+1,如果不是为当前属性赋值为1
    obj[char] ? obj[char]++ : (obj[char] = 1)
  }
  // 得到最大的值
  const max = Math.max(...Object.values(obj))
  // 得到最值的字符
  const resultChar = Object.keys(obj).find((item) => obj[item] === max)
  // 返回字符
  return resultChar
}
console.log(getlongestChar('bbbdddjjjaaab'))

四、字符串反序

function reverseString(str) {
  // 把字符串分割成数组,再调用数组的翻转方法,最后再把数组转换为字符串
  return str.split('').reverse().join('')
  /*
    还可以使用倒序
  */
  // let result = ''
  // for(let i = str.length-1; i >= 0;i++) {
  //   result += str[i]
  // }
  // return result
}
console.log(reverseString('Hello World'))

五、深拷贝

function deepCopy(target) {
  /*
    判断目标元素是否是数组或者对象并且目标元素不为null
  */
  if (
    target instanceof Array ||
    (target !== null && typeof target === 'object')
  ) {
    // 根据目标数据的类型创建一个数组或对象
    let cloneTarget = target instanceof Array ? [] : {}
    // 循环遍历目标元素, for...in...循环可以遍历数组和对象
    for (let key in target) {
      // 递归拷贝
      cloneTarget[key] = deepCopy(target[key])
    }
    // 返回拷贝后的元素
    return cloneTarget
  } else {
    // 如果不是数组或对象类型直接返回元素
    return target
  }
}
console.log(deepCopy({ name: 'kobe', age: 42 }))

六、合并多个有序数组--排序--去重

function flatArray(arr) {
  // 创建一个空数组
  let resultArr = []
  // 循环遍历二维数组
  arr.forEach((item) => {
    // 二维数组转换为一维数组
    item instanceof Array ? resultArr.push(...item) : resultArr.push(item)
  })
  // 去重
  resultArr = [...new Set(resultArr)]
  // 排序并返回
  return resultArr.sort((a, b) => a - b)
}

console.log(
  flatArray([
    [1, 2, 3],
    [6, 2, 1, 3, 4],
    [2, 1, 4, 5, 3, 6],
  ])
)

七、数组排序

function sortArray(arr) {
  for (let i = 0; i < arr.length; 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
}
console.log(sortArray([22, 55, 11, 33, 44, 55, 66, 77, 11, 44]))

八、约瑟夫环问题

  • 描述:编号为 1 到 100 的一百个人围成一圈,以 123123 的方式进行报数,数到 3 的人自动退出圈子,剩下的人继续报数,问最后剩下的人编号为几?
function josephRing(n, k) {
  // 创建一个数组
  let arr = []
  // 去除第一次出场
  for (let i = 1; i <= n; i++) {
    if (i % k !== 0) arr.push(i)
  }
  // 定义一个计数器
  let flag = 0
  while (arr.length > 1) {
    let outNum = 0 // 本次循环已出局人数,便于定位元素位置
    let len = arr.length
    for (let i = 0; i < len; i++) {
      flag++
      if (flag === k) {
        flag = 0
        arr.splice(i - outNum, 1)
        outNum++
      }
    }
  }
  return arr[0]
}
console.log(josephRing(100))

九、回文字符串

  • 回文字符串:是一个正读和反读都一样的字符串。

方法 1:判断字符串和翻转后是否相等

function palindromeString(str) {
  /*
    1. 判断字符串和翻转后是否相等
  */
  return str === str.split('').reverse().join('')
}
console.log(palindromeString('aba'))

方法 2:循环遍历字符串,依次判断第一个字符和最后一个字符是否相等,第二个和倒数第二个是否相等...

function palindromeString2(str) {
  const len = str.length
  let flag = true
  // 循环遍历字符串,只循环到一半
  for (let i = 0; i < len / 2; i++) {
    // 依次判断 str[0] !== str[str.length-1-0],str[1] !== str[str.length-1-1]...
    if (str[i] !== str[len - 1 - i]) {
      // 如果有组不相等为flag赋值为false
      flag = false
      break // 结束循环
    }
  }
  // 返回flag
  return flag
}
console.log(palindromeString2('aba'))

十、不借助临时变量,进行两个整数的交换

function swap(a, b) {
  // 10   20
  // [a,b] = [b,a]
  a = a - b // a = -10
  b = b + a // b = 10
  a = b - a // a = 20
  return [a, b]
}
console.log(swap(30, 20))

十一、找出数组的最大差值

// 找出数组的最大差值
function getMaxDiff(arr) {
  /*
    1. 通过Math.max()和 Math.min()加三点运算符
  */
  // return Math.max(...arr) - Math.min(...arr)

  /*
    2. 数组排序后计算最后一个和第一个的差值
  */
  arr.sort((a, b) => a - b)
  return arr[arr.length - 1] - arr[0]
}
console.log(getMaxDiff([50, 60, 10, 20, 40, 80, 90]))

十二、随机生成指定长度的字符串

方法 1

// 随机生成指定长度的字符串
function randomStr(len) {
  // 定义源字符串
  let sourceStr =
    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
  /*
    1. 使用数组,打乱数组获取前面的len个
   */
  let arr = sourceStr.split('')
  // 将数组乱序
  arr.sort(() => 0.5 - Math.random())
  // 得到数组len个数组元素再转为字符串
  return arr.filter((item, index) => index < len).join('')
}
console.log(randomStr(6))

方法 2

// 随机生成指定长度的字符串
function randomStr2(len) {
  // 定义源字符串
  let sourceStr =
    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
  /*
    2. 循环获取随机下标
  */
  let returnStr = ''
  while (returnStr.length < len) {
    let index = Math.floor(Math.random() * sourceStr.length)
    returnStr += sourceStr[index]
  }
  return returnStr
}
console.log(randomStr2(6))

欢迎大佬指正

版权声明
本文为[黄万通]所创,转载请带上原文链接,感谢
https://segmentfault.com/a/1190000037781279