LeetCode21-03-12~21-03-21

最新推荐文章于 2023-11-01 15:18:24 发布

取名好樊

最新推荐文章于 2023-11-01 15:18:24 发布

阅读量63

点赞数

分类专栏： LeetCode刷题

本文链接：https://blog.csdn.net/qq_31290307/article/details/114845417

版权

LeetCode刷题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

2021-03-12
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

js的Number均为64位，所以我第一反应是转String，翻转比较大小输出。后来察觉的位数限制，假定了下位数。

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    if(x<0){
        let x1 = x * -1;
        let rev = 0;
        while(x1 > 0) {
            const yu = x1 % 10;
            if(rev > Math.floor(Math.pow(2, 31)/10)){
                rev = 0;
                break;
            } else if(rev === Math.floor(Math.pow(2, 31)/10) && yu > 8){
                rev = 0;
                break;
            } else {
                rev = rev * 10 + yu;
                x1 = Math.floor(x1 / 10);
            }
        }
        return -1 * rev;
    } else {
        let x1 = x ;
        let rev = 0;
        while(x1 > 0) {
            const yu = x1 % 10;
            if(rev > Math.floor(Math.pow(2, 31)/10)){
                rev = 0;
                break;
            } else if(rev === Math.floor(Math.pow(2, 31)/10) && yu > 7){
                rev = 0;
                break;
            } else {
                rev = rev * 10 + yu;
                x1 = Math.floor(x1 / 10);
            }
        }
        return rev;
    }
};

2021-03-13
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    let s = x;
    const list = [];
    if(x<0){
        return false;
    }
    while (s > 0){
        let yu = s % 10;
        s = Math.floor(s /10);
        list.unshift(yu);
    }
    list.forEach((item,index) => {
        s = s+ (item*Math.pow(10,index));
    });
    return s === x;
};

2021-03-14
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

/**
 * @param {string} s
 * @return {number}
 */
var romanToInt = function(s) {
    const list = s.split('');
    let r = 0;
    let result = 0;
    list.forEach((item, index) => {
        if(item === 'I' && list[index +1] && list[index +1] !=='I') {
            result += -1;
        } else if(item === 'I'){
            result += 1;
        } else if(item === 'V') {
            result += 5;
        } else if(item === 'X' && list[index +1] && (list[index+1] ==='L' || list[index+1] === 'C')) {
            result += -10;
        } else if(item === 'X'){
            result += 10;
        } else if(item === 'L') {
            result += 50;
        } else if(item === 'C' && list[index +1] && (list[index+1] ==='D' || list[index+1] === 'M') ) {
            result += -100;
        } else if(item === 'C') {
            result += 100;
        } else if(item === 'D') {
            result += 500;
        } else if(item === 'M') {
            result += 1000;
        }
    });
    return result;
};

2021-03-15
编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
    let result = '';
    strs.forEach((item, index) =>{
        if(index){
            result =test(item, result);
        }else {
            result = item;
        }
    });
    return result;
    
};
var test = function(item, result){
    if(result.length && !item.startsWith(result)){
        result = result.substring(0, result.length-1);
        return test(item, result);
     } else{
         return result;
     }
}

2021-03-16
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

var searchInsert = function(nums, target) {
    let index = nums.length;
    for(let i = 0; i<nums.length;i++){
        if(nums[i] >= target){
            index = i;
            break;
        }
    }
    return index;
};

2021-03-20
1、给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

countAndSay(1) = “1”
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
前五项如下：

```
1
```
```
11
```
```
21
```
```
1211
```
```
111221
```

第一项是数字 1
描述前一项，这个数是 1 即 “ 一个 1 ”，记作 “11”
描述前一项，这个数是 11 即 “ 二个 1 ” ，记作 “21”
描述前一项，这个数是 21 即 “ 一个 2 + 一个 1 ” ，记作 “1211”
描述前一项，这个数是 1211 即 “ 一个 1 + 一个 2 + 二个 1 ” ，记作 “111221”
要描述一个数字字符串，首先要将字符串分割为最小数量的组，每个组都由连续的最多相同字符组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。

/**
 * @param {number} n
 * @return {string}
 */
var countAndSay = function(n) {
    if(n>1){
        const list = (countAndSay(n-1) + '').split('');
        let result = '';
        let tem1 = '';
        let tem2 = '';
        list.forEach(item => {
            if(tem2 == item) {
                tem1 += 10;
            } else {
                result = result + tem1;
                tem1 = 10 + parseInt(item);
                tem2 = item;
            }
        })
        return result + tem1;
    } else {
        return '1'
    }
};

2、给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    let max = Math.max(...nums);
    let first = 0;
    nums.forEach(item=> {
        if(first + item > 0){
            first += item;
            if(first > max) {
                max = first;
            }
        } else{
            first = 0;
        }
    });
    return max;

};

2021-03-21
1、给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。

单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLastWord = function(s) {
    let result = 0;
    let list = s.split(' ');
    const length = list.length;
    if(length){
        result = test(list, length -1);
    } 
    return result;
};
var test = function(list, index){
    if(index === 0){
        return list[index].length;
    }
    if(list[index].length){
        return list[index].length;
    } else {
        return test(list, index-1)
    }
}

2、给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    let jinwei = 0;
    const length = digits.length;
    for(let i = 1; i<length +1; i++){
        digits[length -i] = digits[length -i] +1;
        if(digits[length -i]> 9){
            digits[length -i] = 0;
            jinwei = 1;
        } else {
            jinwei = 0;
            break;
        }
    }
    if(jinwei){
        digits.unshift(1);
    }
    return digits;
};

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer

取名好樊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode21-03-12~21-03-21

2021-03-12给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。js的Number均为64位，所以我第一反应是转String，翻转比较大小输出。后来察觉的位数限制，假定了下位数。/** * @param {number} x * @return {number} */var reverse = function(
复制链接

扫一扫