关于javascript:js-基础算法题一

一、转驼峰

• 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))

欢送大佬斧正