leetcode面试题之数学

01 整数反转 p7

/**
 * 7. 整数反转
 * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
 * 如果反转后整数超过 32 位的有符号整数的范围[−2^31, 2^31− 1] ，就返回 0。
 * 假设环境不允许存储 64 位整数（有符号或无符号）。
 * https://leetcode-cn.com/problems/reverse-integer/
 */
/**
 * @param {number} x
 * @return {number}
 */
var reverse = function (x) {
    let res = 0, flag = 1
    //如果是负数，转换成正数，并用flag记录下来
    if (x < 0) {
        flag = -1
        x = -x
    }
    //数学处理
    while (x !== 0) {
        res = res * 10 + (x % 10)
        x = Math.floor(x / 10) //注意：此处要向下取整，不然会带有小数
    }
    res *= flag
    //如果溢出，返回0
    if (res < -(2 ** 31) || res > 2 ** 31 - 1) return 0
    return res
};

02 字符串转换正数atoi p8

/**
 * 8. 字符串转换整数 (atoi)
 * 请你来实现一个myAtoi(string s)函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
 *
 * 函数myAtoi(string s) 的算法如下：
 * 读入字符串并丢弃无用的前导空格
 * 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
 * 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
 * 将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
 * 如果整数数超过 32 位有符号整数范围 [−2^31, 2^31− 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −2^31 的整数应该被固定为 −2^31 ，大于 2^31− 1 的整数应该被固定为 2^31− 1 。
 * 返回整数作为最终结果。
 * 注意：
 * 本题中的空白字符只包括空格字符 ' ' 。
 * 除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
 * https://leetcode-cn.com/problems/string-to-integer-atoi/
 */
/**
 * @param {string} s
 * @return {number}
 */
var myAtoi = function (s) {
    let res = 0, k = 0, n = s.length
    //1.去除空格,找第一个非空格的字符串
    while (k < n && s[k] === ' ') k++
    //说明全为空格，返回0
    if (k === n) return 0

    //2.flag记录数的正负号，后面计算时使用的是正数
    let flag = 1
    if (s[k] === '-') {
        k++
        flag = -1
    } else if (s[k] === '+') {
        k ++
    }

    //3.截取数字部分，如果后面有非数字或者到达末尾截止
    while (k < n) {
        //非数字，退出循环
        if (s[k] < '0' || s[k] > '9') break
        res = res + s[k]
        k++
        //超出范围，退出循环
        if (res > 2 ** 31 - 1) break
    }

    //4.加上正负号，并对数的进行范围判断
    res *= flag
    if (res < -(2 ** 31)) return -(2 ** 31)
    if (res > 2 ** 31 - 1) return 2 ** 31 - 1
    return res
};

03 罗马数字转整数 p13

/**
 * 13. 罗马数字转整数
 * https://leetcode-cn.com/problems/roman-to-integer/
 */
/**
 * @param {string} s
 * @return {number}
 */
var romanToInt = function(s) {
    //将字符和值映射到一个map当中，类似哈希表
    const hash = new Map([['I', 1], ['V', 5], ['X', 10], ['L', 50],
        ['C', 100], ['D', 500], ['M', 1000]])
    let res = 0, n = s.length
    for (let i = 0; i < n; i ++) {
        //如果当前的值<后一个位置的值，则减去当前位置的值，否则加上
        if (i + 1 < n && hash.get(s[i]) < hash.get(s[i + 1])) {
            res -= hash.get(s[i])
        } else {
            res += hash.get(s[i])
        }
    }
    return res
};

04 有效的数独 p36

/**
 * 36. 有效的数独
 * 请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
 * 数字1-9在每一行只能出现一次。
 * 数字1-9在每一列只能出现一次。
 * 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）
 *
 * 注意：
 * 一个有效的数独（部分已被填充）不一定是可解的。
 * 只需要根据以上规则，验证已经填入的数字是否有效即可。
 * 空白格用 '.'表示。
 * https://leetcode-cn.com/problems/valid-sudoku/
 */
/**
 * @param {character[][]} board
 * @return {boolean}
 * 模拟数独
 */
var isValidSudoku = function(board) {
    const n = 9
    const st = new Array(n).fill(false) // 状态数组
    // 判断行
    for (let i = 0; i < n; i ++) {
        st.fill(false)
        for (let j = 0; j < n; j ++) { // 判断每一行是否满足条件
            if (board[i][j] !== '.') {
                let t = board[i][j] - '1' // 数独是1-9，而状态数组的下标是从0开始
                if (st[t]) return false // 如果当前值已经有了，即重复返回false
                st[t] = true
            }
        }
    }

    // 判断列,与行类似
    for (let i = 0; i < n; i ++) {
        st.fill(false)
        for (let j = 0; j < n; j ++) {
            if (board[j][i] !== '.') {
                let t = board[j][i] - '1'
                if (st[t]) return false
                st[t] = true
            }
        }
    }

    // 判断九个方格
    for (let i = 0; i < n; i += 3) {
        for (let j = 0; j < n; j += 3) {
            st.fill(false)
            for (let x = 0; x < 3; x ++) {
                for (let y = 0; y < 3; y ++) {
                    if (board[i + x][j + y] !== '.') {
                        let t = board[i + x][j + y] - '1'
                        if (st[t]) return false
                        st[t] = true
                    }
                }
            }
        }
    }
    return true
};

05 Pow p50

/**
 * @param {number} x
 * @param {number} n
 * @return {number}
 * 快速幂 二进制思想 时间复杂度O(logn)
 */
var myPow = function(x, n) {
    let tmp = 1
    // 处理n<0情况
    if (n < 0) {
        x = 1 / x //指数是负数，说明结果需要求倒数
        // 注意：判断负数溢出的情况
        if (n === -2147483648) {
            tmp = x
            n ++ //防止溢出
        }
        n = -n //转成正数，利用函数一同处理
    }
    return tmp * qmi(x, n)

    // n>0 pow
    function qmi(x, k) {
        let res = 1
        while (k) {
            if (k & 1) res *= x //枚举k的每一位，如果为1需要乘一次x
            x *= x // 下一个x的值就是前一个的平方
            k >>= 1 // 每次遍历 k/2
        }
        return res
    }
};

06 加一 p66

/**
 * 66. 加一
 * 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
 * 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
 * 你可以假设除了整数 0 之外，这个整数不会以零开头
 * https://leetcode-cn.com/problems/plus-one/
 */
/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    let n = digits.length, t = 1 // t:进位 初始为1可以表示加1
    for (let i = n - 1; i >= 0; i --) { // 从个位开始
        t += digits[i] // 求和
        digits[i] = t % 10 // 求当前位置的值
        t = Math.floor(t / 10) // 求进位 注意：要向下取整，不然js会有小数
    }
    if (t === 1) digits.unshift(t) // 如果最后一位有进位，则放入数组开头(最后一位进位最大为1)
    return digits
};

07 x的平方根 p69

/**
 * 69. x 的平方根
 * 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
 * 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被舍去 。
 * https://leetcode-cn.com/problems/sqrtx/
 */
/**
 * @param {number} x
 * @return {number}
 * 思路：二分法
 */
var mySqrt = function(x) {
  let l = 0, r = x
  while (l < r) {
    let mid = l + r + 1 >> 1
    // mid <= x / mid:防止越界
    if (mid <= x / mid) l = mid
    else r = mid - 1
  }
  return r
};

08 轮转数组 p189

/**
 * 189. 轮转数组
 * 给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
 * https://leetcode-cn.com/problems/rotate-array/
 */
/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 * 思路：3次翻转
 */
var rotate = function (nums, k) {
  const n = nums.length
  k %= n // 如果k>n，只需要轮转(k-n)
  // 1.整体翻转
  reverse(0, n - 1)
  // 2.翻转 (0, k - 1)
  reverse(0, k - 1)
  // 3.翻转 (k, n - 1)
  reverse(k, n - 1)

  function reverse(l, r) {
    while (l < r) [nums[l++], nums[r--]] = [nums[r], [nums[l]]]
  }
};

09 完全平方数 p279

/**
 * 279. 完全平方数
 * 给你一个整数 n ，返回 和为 n 的完全平方数的最少数量
 * https://leetcode-cn.com/problems/perfect-squares/
 */
/**
 * @param {number} n
 * @return {number}
 * 思路：根据两大数学原理：
 * 1.拉格朗日四平方和定理：每个正整数均可表示为4个整数的平方和 => n<=4
 * 2.勒让德三平方和定理：一个正整数可以表示为3个整数的平方和，当且仅当 n!=4^a(8*b+7) 
 *  n最大为4，枚举判断结果
 */
var numSquares = function(n) {
  // check:判断x是否能够开平方
  function check(x) {
    let r = Math.floor(Math.sqrt(x)) // 注意：此处要向下取整
    return x === r * r
  }

  // 枚举判断结果
  // 1
  if (check(n)) return 1
  // 2    a <= n / a:不用a*a，防止越界
  for (let a = 1; a <= n / a; a ++) {
    if (check(n - a * a)) return 2
  }
  // 3
  while (n % 4 === 0) n /= 4
  if (n % 8 !== 7) return 3
  // 4
  return 4
};

console.log(numSquares(12))