Leetcode刷题笔记--Day1

今天做了5道简单题，分别是7（反转整数）、9（回文数）、13（罗马数字转整数）、14（最长公共前缀）、867（转置矩阵）。

（7）反转整数

- 问题描述：给定一个 32 位有符号整数，将整数中的数字进行反转。
- 例如：输入: 123，输出: 321；输入: -123，输出: -321。
- 解：

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        if(x>=0 and x<=2**31-1):
            s = str(x)[::-1]
            s.lstrip('0')
            i=int(s)
            if(i>2**31-1):
                return 0
            else:
                return i 
        elif(x<0 and x>=-2**31):
            s=str(abs(x))[::-1]
            s.lstrip('0')
            s1='-'.join(['',s])
            i1=int(s1)
            if(i1<-2**31):
                return 0
            else:
                return i1
        else:
            return 0

将数字转换为字符串，用python切片的方法可以颠倒字符串的顺序，正数负数分开考虑，最后将字符串再转为整数返回。
（不是最优解；编码习惯也不好，需要加强）

（9）回文数

- 问题描述：判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数
- 例如：输入: 121，输出: true；输入: -121，输出: false；
- 解：

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        s=str(x)
        i=s.__len__()//2
        if(s.__len__()%2==0):
            if (s[:i] == s[i:][::-1]):
                return True
            else:
                return False
        else:
            if(s[:i+1]==s[i:][::-1]):
                return True
            else:
                return False

将整数转换为字符串，将该字符串分为两半，比较第一部分和第二部分的颠倒是否相同。一开始马上是想到这样做，但中途发现字符串中的字符是奇数或偶数对应的情况有所不同，于是分成两种情况。解法有些傻~~

（13）罗马数字转整数

- 问题描述：

- 例如：输入: “MCMXCIV”，输出: 1994（解释: M = 1000, CM = 900, XC = 90, IV = 4.）

- 解：

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        d={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        flag=False
        sum=0
        for i in list(range(s.__len__())):
            if(flag==False):
                if (s[i]== 'I' and (s[i+1:].startswith('V') or s[i+1:].startswith('X'))):
                    sum+=d[s[i+1]]-d[s[i]]
                    # L.append(''.join([s[i],s[i+1]]))
                    flag=True
                elif (s[i]== 'X' and (s[i+1:].startswith('L') or s[i+1:].startswith('C'))):
                    sum+=d[s[i + 1]] - d[s[i]]
                    # L.append(''.join([s[i],s[i+1]]))
                    flag = True
                elif (s[i]== 'C' and (s[i+1:].startswith('M') or s[i+1:].startswith('D'))):
                    sum += d[s[i + 1]] - d[s[i]]
                    # L.append(''.join([s[i],s[i+1]]))
                    flag = True
                else:
                    sum += d[s[i]]
            else:
                flag=False
        return sum

先用dict将基础的罗马数字与阿拉伯数字的对应关系存起来，循环字符串中的每个字符，先判断该字符是不是“I”、“X”、“C”中的某一个，且其后紧接着的字符是不是能够组合成那6中特殊字符的情况，如果是则直接运算并累加到变量sum中，否则直接将当前字符对于的数字累加到sum中。Tips：用flag标识本轮循环是否碰到6种特殊情况

（14）最长公共前缀

- 问题描述：编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”

- 例如：输入: [“flower”,”flow”,”flight”]，输出: “fl”；

- 解：

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""
        for i in list(range(strs[0].__len__())):
            for str in strs:
                if(len(str)<=i or strs[0][i]!=str[i]):
                    return strs[0][:i]
        return strs[0]

考虑字符串list中第一个字符串的长度L，最长公共前缀的长度不可能超过L（最多等于L），所以循环L次，用第一个字符串的每个字符和其他字符串对应位置的字符相比较，如果其他所有字符串该位置的字符都与第一个字符串该位置的字符相等，则继续进入下一个循环，对比下一个位置的字符，知道不相等为止，此时可以得到最长公共前缀（用切片的方法）。如果一直都相等，循环完成L次以后，可以判断最长公共前缀就是第一个字符串本身。
Tips: “ len(str)<=i ”表示，当前前缀的长度以及大于或等于list中某个字符串str的长度了，则显然str便是最长公共前缀。

（867）转置矩阵

- 问题描述：给定一个矩阵 A， 返回 A 的转置矩阵。矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

- 例如：输入：[[1,2,3],[4,5,6],[7,8,9]]，输出：[[1,4,7],[2,5,8],[3,6,9]]；

- 解：

class Solution(object):
    def transpose(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        R=A.__len__()
        C=A[0].__len__()
        L=[[None] * R for i in list(range(C))]
        for r,row in enumerate(A):
            for c,col in enumerate(row):
                L[c][r]=col
        return L

class Solution(object):
    def transpose(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        L=[]
        for i in list(range(A[0].__len__())):
            L.append([])
        for a in A:
            for j in list(range(a.__len__())):
                L[j].append(a[j])
        return L

两种解法：
第一种直接考虑A[c][r]=A(T)[r][c]，转置矩阵的性质。
第二种，因为A的行长=A转置的列长（len（A）=len（A转置[0]）），A的列长=A转置的行长。所以可知道转置后list有几个元素（空的），并且A和A的转置有如下图所示的对应关系：

- 生疏的知识： enumerate的用法、字符串操作（startswith方法）