0
点赞
收藏
分享

微信扫一扫

leetcode面试题之数学

胡桑_b06e 2022-04-21 阅读 68

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
    }
};
举报

相关推荐

0 条评论