LeetCode 其他部分 简单 Python实现

#LeetCode 其他部分 简单 Python实现 
'''
位1的个数
编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

示例 :
输入: 11
输出: 3
解释: 整数 11 的二进制表示为 00000000000000000000000000001011

 

示例 2:
输入: 128
输出: 1
解释: 整数 128 的二进制表示为 00000000000000000000000010000000
'''
方法1： 通过
class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        num =0

        bin_n = bin(n)
        print(bin_n)
        for i in bin_n:
            #print(i)
            if i == '1':
                num=num +1
                #print(i,num)
        return num 
my = Solution()
a = my.hammingWeight(3)
print(a)

#方法2：通过
class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """

        bin_n = bin(n)
        return bin_n.count('1')
my = Solution()
a = my.hammingWeight(3)
print(a)

方法3：通过，位运算
class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        count=0
        while n!=0:
            if n&1==1:#十进制可以使用&，>>
                count+=1
            n=n>>1 #右移一位
        return count
'''
汉明距离
两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。也就是求异或运算

给出两个整数 x 和 y，计算它们之间的汉明距离。

注意：
0 ≤ x, y < 231.

示例:
输入: x = 1, y = 4

输出: 2

解释:
1   (0 0 0 1)
4   (0 1 0 0)
       ↑   ↑

上面的箭头指出了对应二进制位不同的位置。

'''
class Solution(object):
    def hammingDistance(self, x, y):
        """
        :type x: int
        :type y: int
        :rtype: int
        """
        #print(x&y)  #与运算
        #print(x|y) #或运算
        return bin(x ^ y).count('1')  #异或运算后取二进制，计算1个数
my = Solution()
a = my.hammingDistance(5,4)
print(a)

'''
颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。

示例:
输入: 43261596
输出: 964176192
解释: 43261596 的二进制表示形式为 00000010100101000001111010011100 ，
     返回 964176192，其二进制表示形式为 00111001011110000010100101000000 。

进阶:
如果多次调用这个函数，你将如何优化你的算法？
'''



class Solution:
    # @param n, an integer
    # @return an integer
    def reverseBits(self, n):
        bin_n = '{0:032b}'.format(n)    #n格式化为二进制bin（n)带有前缀0b
        reverse_bin_n = bin_n[::-1]     #反转字符串bin_n是用方法[::-1]
        reverse_n = int(reverse_bin_n, 2) #二进制转化为十进制数字
        return   reverse_n

my = Solution()
a = my.reverseBits(43261596)
print(a)


964176192
[Finished in 0.9s]


'''
帕斯卡三角形
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5
输出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]
相信很多人已经熟悉了帕斯卡三角形是什么，这里简单介绍一下：
-有N个数组
-第N个数组有N项
-第N个数组的第K项=第N-1个数组的第K-1和第K项之和（K!=1 && K <N）
#方法1：通过AC
#思路：
class Solution:
    # @return a list of lists of integers
    def generate(self, numRows):
        ret = []
        for i in range(numRows):
            ret.append([1])
            for j in range(1,i+1):
                if j==i:
                    ret[i].append(1)
                else:
                    ret[i].append(ret[i-1][j]+ret[i-1][j-1])
        return ret

my = Solution()
a = my.generate(5)
print(a)


[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
[Finished in 1.4s]


方法2：通过LeetCode，但是没有通过我的编译器。
思路：计算通项公式，首先是编写阶乘函数，然后计算C00，C10，C11即可

利用Python 的map嵌套可以很简洁地实现，核心代码只有一行！
'''
class Solution:
    # @return factorial value of n
    def factorial(self,n):
        if n==0:
            return 1
        else:
            return reduce(lambda x,y:x*y,range(1,n+1))
    # @return a list of lists of integers
    def generate(self, numRows):
        result = map(lambda i:map(lambda x:self.factorial(i)/self.factorial(x)/self.factorial(i-x),range(i+1)),range(numRows))
        return result

my = Solution()
a = my.generate(5)
print(a)

<map object at 0x00000000023A0278>
[Finished in 0.8s]

'''
有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:
输入: "()"
输出: true


示例 2:
输入: "()[]{}"
输出: true


示例 3:
输入: "(]"
输出: false


示例 4:
输入: "([)]"
输出: false


示例 5:
输入: "{[]}"
输出: true
'''
#通过
class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        dic = {'(':')', '[':']', '{':'}'}
        lis = []
        for i in s:
            if i in dic.keys():
                print('i_keys is:',i)

                lis.append(i) #lis里面只能保存（【{

            elif i in dic.values():
                print('i_dic is:',i)
                print('lis is:',lis)
                print('len(lis) is:',len(lis))
                print('dic.get(lis[-1]) is:',dic.get(lis[-1]) )
                if len(lis) == 0 or dic.get(lis[-1]) != i: #dic.get(lis[-1])就是取键lis【-1】对应的值，也就是括号的右半边内容
                #如果lis为空，说明用】）}开头，报错；dic.get(lis[-1])就是【{（对应的右半边括号}】），
                #因为要保证lis对称，所以dic.get(lis[-1])一定对称于lis最右侧的符号，如果i刚好等于dic.get(lis[-1])，说明符号对称，说明符号合理，否则不合理
                    return False 
                else: #符号刚好对称了，那就删除lis最右侧的符号，如果符号全部对称，lis结果就被删除光了。
                    print('lis_before_pop is:',lis)

                    lis.pop()
                    print('lis_after_pop is:', lis)
        if len(lis) == 0:
            print('lis_last is:', lis)
            return True 
        else:
            return False 

my = Solution()
a = my.isValid('{[]}')
print(a)

                
i_keys is: {
i_keys is: [
i_dic is: ]
lis is: ['{', '[']
len(lis) is: 2
dic.get(lis[-1]) is: ]
lis_before_pop is: ['{', '[']
lis_after_pop is: ['{']
i_dic is: }
lis is: ['{']
len(lis) is: 1
dic.get(lis[-1]) is: }
lis_before_pop is: ['{']
lis_after_pop is: []
lis_last is: []
True
[Finished in 0.9s]



'''
缺失数字
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。

示例 1:
输入: [3,0,1]
输出: 2


示例 2:
输入: [9,6,4,2,3,5,7,0,1]
输出: 8


说明:
你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
'''
#方法1：通过
#思路：缺失的那个数字加上给的数组num刚好就是完整的从0到n的一个数组。利用这个公式就可以了。
class Solution(object):
    def missingNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        n = len(nums)
        full_sum = n*(n+1)//2 #从1到n之和的数学公式
        part_sum = sum(nums)
        lost_num = full_sum - part_sum
        return lost_num


my = Solution()
a = my.missingNumber([9,6,4,2,3,5,7,0,1])
print(a)

8
[Finished in 0.7s]