leetcode刷题记录(1)

1.两数之和

题目：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

初版思路：

记录每一个数的值和下标，然后找到对应的差的下标，如果存在且两个下标不同则返回

    for(let i=nums.length-1;i;i--){
        const val1=nums[i]
        const indexList=nums.map((item,index)=>{
            return {
                value:item,
                index:index
            }
        }).filter(item=>item.value===target-val1).map(item=>item.index)
       const index=indexList.find((item)=>{
            return item!==i
        })
        if(index!==undefined){
            return [index,i]
        }
    }

问题：循环用的太多，数据转换也太多，导致性能不够好。

优化方向：

先判断差在原数组是否存在，如果不存在则直接跳到下一个循环

var twoSum = function(nums, target) {
    for(let i=nums.length-1;i;i--){
        const v=nums[i]
        const a=target-v;
        if(nums.includes(a)){
            for(let s=0;s<i;s++){
                if(nums[s]===a){
                    return [s,i]
                }
            }

        }
        

    }
};

 

问题：

循环嵌套，性能可以进一步优化，比较次数可以少一点

优化方向：

采用值-下标的方式，在单次循环中记录值和下标的关系，然后判断差对应的key在对象中是否存在即可。

var twoSum = function(nums, target) {
    const m={};
    for(let i=nums.length-1;i>=0;i--){
        const v=nums[i];
        if(m[target-v]!==void 0){
            return [i,m[target-v]]
        }
        m[v]=i
        
    }
};

2.整数反转

题目:

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

思路：先转换成字符串，切割成数组，然后用数组的reverce方法反转

var reverse = function(x) {
const i=(value)=>{
    return value>=(-1*Math.pow(2,31))&&value<=(Math.pow(2,31)-1)
}
let v;
if(x>=0){
 v=Number(`${x}`.split('').reverse().join(''))

}else{
v=-1* Number(`${-1*x}`.split('').reverse().join(''))
}
return i(v)?v:0
};

问题：内存消耗较大，因为有多次的切割及合并操作

优化方向：

对字符串采用单次循环的方式，在循环中拼接

var reverse = function(x) {
const i=(value)=>{
    return value>=-2147483648&value<=2147483647
}
let v
    let a=''
    let s
if(x>=0){
     s=x.toString();

}else{
     s=(-1*x).toString();
}
 for(j=s.length-1;j>=0;j--){
    a+=s[j]
 }
v=x>=0?Number(a):-1*Number(a)
return i(v)?v:0
};

3.回文数

题目：判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

思路：先区分简单情况，负数肯定不是，小于10的数肯定是。

然后将数字转换成字符串，在单次循环中，判断某个下标及镜像下标上的数是否相等

var isPalindrome = function(x) {
if(x<0){
    return false
}else if(x<=9){
    return true
}
const a=x+''
const l=a.length
const i=Math.floor(l/2)
for(let j=i;j;j--){
    if(a[j-1]!==a[l-j]){
        return false
    }
}
return true
};

4.罗马数字转整数

题目：

罗马数字包含以下七种字符: 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 的范围内。

思路：枚举每一种数字及对应的值的组合，优先匹配组合的罗马数字，然后匹配单罗马数字，每次匹配成功则结果累加

var romanToInt = function (s) {
  const d = {
    IV: 4,
    IX: 9,
    XL: 40,
    XC: 90,
    CD: 400,
    CM: 900,
  };
  const c = {
    I: 1,
    V: 5,
    X: 10,
    L: 50,
    C: 100,
    D: 500,
    M: 1000,
  };
  const res = 0;
  s.replace(/IV|IX|XL|XC|CD|CM/g, (a) => {
    res += d[a];
    return "";
  }).replace(/I|V|X|L|C|D|M/g, (a) => {
    res += c[a];
    return "";
  });
  return res
};

问题：罗列的变量太多，且用正则匹配时回溯较多，导致性能消耗不理想

优化思路：因为从左到右依次增大，所以对字符串从左到右遍历，默认加上对应的值，如果下一个值更大则减去前一个值，这样就不需要罗列两个字符的情况了，也只需要一次遍历。同时，保存下一个字母对应的值，这样在遍历时就不需要每次都读取两个值了

var romanToInt = function(s) {
  const d = {
    M: 1000,
    D: 500,
    C: 100,
    L: 50,
    X: 10,
    V: 5,
    I: 1,
    'undefined':0
  };
let res=0,l=s.length,nv=0;
for(let i=0;i<l;i++){
    const v=nv||d[s[i]];
    nv=d[s[i+1]]
    v>=nv?(res+=v):(res-=v);
}
  return res
};