Leecode刷题记录

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

var twoSum = function(nums, target) {

    for(var i = 0;i

      for(var j = 1;j

        if (j > i) {

          if (nums[i] + nums[j] == target) {

          return [i,j]

          }

        }

      }

    }

};

2.给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

var lengthOfLongestSubstring = function(s) {

    var length=0

    //长度为零时

    if(s.length==0){

      return length

      }

    length = 1;

    var index = 0,has = 0

    for(var i=1;i

        //查看前i-1位是否含有第i位

        has = s.slice(index,i).indexOf(s[i])

        if(has == -1){

            //不包含则取长度长的

            length = Math.max(length,i-index+1)

        }else{

            //包含则从下一位开始匹配

            index = index+has+1

        }

    }

    return length

};

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

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

var reverse = function(x) {

    var isPlus = true

    var num = 0

    if(x<0){

        //数值为负数时

        isPlus = false

    }

    x = Math.abs(x)+""

    //十进制反转取整

    num = parseInt(x.split("").reverse().join(""),10)

    //溢出取0

    if(num>=(Math.pow(2,31)-1)){

        return 0

    }else{

        if(isPlus){

            return num

        }else{

            return -num

        }

    }

}

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

var isPalindrome = function(x) {

    if(x<0){

        return false

    }

    x=x+""

    if(x.length == 1){

        return true

    }

    //如果整数的长度是偶数，则前半部分和后半部分反转结果相同

  if(x.length%2==0){

      if(x.slice(0,x.length/2) == x.slice(x.length/2).split("").reverse().join("")){

          return true

      }else{

          return false

      }

      //奇数时，从中间那一位的左边和右边反转相同

  }else{

      if(x.slice(0,(x.length-1)/2) ==x.slice((x.length-1)/2+1).split("").reverse().join("")){

          return true

      }else{

          return false

      }

  }

};

5.罗马数字包含以下七种字符: 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) {

    var result = 0

    s = s.split('')

    //先将所有罗马数字相加

    s.forEach((v,i)=>{

        switch(v){

            case 'I': result+=1

            break;

            case 'V': result+=5

            break;

            case 'X': result+=10

            break;

            case 'L': result+=50

            break;

            case 'C': result+=100

            break;

            case 'D': result+=500

            break;

            case 'M': result+=1000

            break;

        }

    })

    //再减去特殊的罗马数字数值

    for(var i = 0;i

        switch(s[i]+s[i+1]){

            case 'IV':

            case 'IX': result-=2

            break;

            case 'XL':

            case 'XC': result-=20

            break;

            case 'CD':

            case 'CM': result-=200

            break;

        }

    }

    return result

};

6.编写一个函数来查找字符串数组中的最长公共前缀。

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

var longestCommonPrefix = function(strs) {

    var result = ""

    var shortLengthIndex = 0

    var shortLength = 50

    //长度为0时，直接返回""

    if(strs.length == 0){

      return ""

    }

    strs.forEach((v,i)=>{

        //获取长度最短的字符串

        if(v.length

            shortLength = v.length

            shortLengthIndex = i

        }

    })

    // return shortLengthIndex

        // console.log(shortLengthIndex)

        function demo(){

            for(var i=0;i

                //遍历数组，是否每个元素都含有长度最小的元素且在最前面

                if(strs[i].indexOf(strs[shortLengthIndex])!=0){

                  if(strs[shortLengthIndex].length <= 1){

                      //当元素为1时则为没有共同前缀，

                        strs[shortLengthIndex] = ""

                      }else{

                          //切减最小元素，减一位，递归

                        strs[shortLengthIndex] = strs[shortLengthIndex].slice(0,strs[shortLengthIndex].length-1)

                        demo()

//                          return strs[shortLengthIndex]

//                        console.log(strs[shortLengthIndex])

                      }

              }

        }

    }

  demo()

  return strs[shortLengthIndex]

};