LeetCodeEasyLevel

ReverseString

先来个简单的练练手，看到这个第一反应就是reverse一下，所以就先把str转换成list，然后 使用 ‘’.joint（）输出为str格式

class Solution(object):
    def reverseString(self, s):
       a=list(s)
        a.reverse()
        r = ''.join(a)
        return r

 

Runtime: 44 ms      

然后看评论，果然这个是比较正常的思维，另外一个很意外的答案是

class Solution(object):
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        return s[::-1]

一个more Pythonic的方法...

开了个不错的头，相信自己能坚持刷下去

Nim Game

乍一看还以为这个题目很难，哎呀两个人的选择都是具有范围的，需要动态的去判断...后来再仔细一看，Both of you are very clever and have optimal strategies for the game

然后又说如果只剩四个你肯定死定了...这样一想，那你要是只剩4的倍数你还不是死定了，喵的就这么叫简单。

class Solution(object):
    def canWinNim(self, n):
        """
        :type n: int
        :rtype: bool
        """
        if n%4==0:
            r = False
        else:
            r = True
        return r

但是，我相信这样肯定不Pythonic， return (n%4)!=0这样才最简洁....

借着这个题目复习了下，Python中的bool型，bool是int的子类，2==True:False ,bool(2)==True:True.，除了''、""、0、()、[]、{}、None为False之外，其他的都是True

Sum of Two Integers

要求不用+ 和减完成两个整型的加法运算。第一反应就是转换到其他运算上。

方案一

class Solution(object):
    def getSum(self, a, b):
        import math
        return math.log2((1<<a)*(1<<b))

移位之后对2求对数，指数的乘法就是指数的加法。提交后错误，因为有一组TestCase 是 -1 和+1，-1无法完成左移操作。

所以干脆把移位操作改成指数运算

方案二

class Solution(object):
    def getSum(self, a, b):
        import math
        return int(math.log(math.exp(a)*math.exp(b)))

提交后又错误...    错误输入为：2147483647 -2147483648运算溢出
暂时想不出来了，先挂着吧，有灵感了再来

MoveZeros

在不改变原有非零项排序的条件下把0移到列表的末尾，count(0)得到0的数目，然后删除一个0，append一个0

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        k = nums.count(0)
        for i in range(k):
            nums.remove(0)
            nums.append(0)
        

但是124ms，24%，不是很理想

Intersection of Two Arrays

查找两个列表中相同相同的元素，也就是求两个列表的交集

蠢方法

class Solution(object):
    def intersection(self, nums1, nums2):
              for i, element in enumerate(nums1):
                       if element in nums2 and not in list:
                             list.append(element)

聪明方法，当然是用内建的方法咯

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        return list(set(nums1).intersection(set(nums2)))

Excel Sheet Column Number

这个其实就是26进制计数，23%

<span style="font-size:14px;">class Solution(object):
    def titleToNumber(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = len(s)
        r=0
        for i, element in enumerate(s):
            r += (26**(l-1-i))*(ord(element)-64)
        return r</span>

简约版

<span style="font-size:14px;">class Solution(object):
    def titleToNumber(self, s):
        """
        :type s: str
        :rtype: int
        """
        return sum(26**p*(ord(c)-64)for p,c in enumerate(s[::-1]))</span>

64%，唉，还是没养成那种思维啊

<span style="font-size:14px;">class Solution(object):
    def titleToNumber(self, s):
        """
        :type s: str
        :rtype: int
        """
        return reduce(lambda x,y:x*26+y,map(lambda x:ord(x)-64,s))</span>

这个，看后面评论使用map reduce然后发现，时间反而变慢了 18%

Valid Anagram

找出两个字符串是否含有相同的字母只是排序不同，想法是，先看是否具有同样的元素，然后计算每个元素是否出现的次数一样

<span style="font-size:14px;">class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if set(s) != set(t):
            return False
        else:
            for i, element in enumerate(set(s)):
                if s.count(element) != t.count(element):
                    return False
            return True</span>

52 ms，98.59%，哈哈哈，这好像是最高的一次了

Majority Element

列表中个数大于 n/2 的元素，那肯定是出现最多的元素咯

<span style="font-size:14px;">class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max = 0
        for i, element in enumerate(set(nums)):
            if nums.count(element) > max:
                max = nums.count(element)
                maj = element
        return maj</span>

34.9%
评论区看到一个新思路，但是还是30%多

<span style="font-size:14px;">class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        return nums[len(nums)/2]</span>

Contains Duplicate

<span style="font-size:14px;">class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        return False if len(nums) == len(set(nums))  else True</span>

one line,But,42%...it's a little low

205. Isomorphic Strings

class Solution(object):
    def isIsomorphic(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        dic1 = self.cons(s)
        dic2 = self.cons(t)
        s1 = [dic1[x] for x in s]
        t1 = [dic2[x] for x in t]
        return True if s1 == t1 else False

    def cons(self , lst):
        redic = {}
        flag = 0
        for i, ele in enumerate(lst):
            if not ele in redic:
                redic[ele] = flag
                flag +=1
        return redic