位1的个数
编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例 :
输入: 11
输出: 3
解释: 整数 11 的二进制表示为 00000000000000000000000000001011
示例 2:
输入: 128 输出: 1 解释: 整数 128 的二进制表示为 00000000000000000000000010000000
我的解答：
class Solution(object):
def hammingWeight(self, n):
"""
:type n: int
:rtype: int
"""
nbin = bin(n)[2:]
count = 0
for i in range(len(nbin)):
if nbin[i] == '1':
count = count + 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:
def hammingDistance(self, x, y):
"""
:type x: int
:type y: int
:rtype: int
"""
xBin = bin(x)[2:] # 0b100需要去掉之前的0b
yBin = bin(y)[2:]
count = 0
# 两个二进制数如果位数不同需要补0
if len(xBin) > len(yBin):
xstr = xBin
ystr = ['0']*len(xBin)
for i in range(len(xBin)-len(yBin)):
ystr[i] = '0'
ystr[len(xBin)-len(yBin):] = yBin
elif len(xBin) < len(yBin):
ystr = yBin
xstr = ['0']*len(yBin)
for i in range(len(yBin)-len(xBin)):
xstr[i] = '0'
xstr[len(yBin)-len(xBin):] = xBin
else:
xstr = xBin
ystr = yBin
# 判断不同的个数
for i in range(len(xstr)):
if xstr[i] != ystr[i]:
count = count + 1
return count颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。
示例:
输入: 43261596 输出: 964176192 解释: 43261596 的二进制表示形式为 00000010100101000001111010011100 ， 返回 964176192，其二进制表示形式为 00111001011110000010100101000000 。
进阶:
如果多次调用这个函数，你将如何优化你的算法？
我的解答：
class Solution:
# @param n, an integer
# @return an integer
def reverseBits(self, n):
xbin = bin(n)[2:]
xstr = ['0']*32
xstr[-len(xbin):] = xbin
for i in range(16):
temp = xstr[i]
xstr[i] = xstr[-i-1]
xstr[-i-1] = temp
# 二进制转换为十进制:使用int函数，指定进制转换为十进制
return int(''.join(xstr),2)帕斯卡三角形
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5 输出: [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]
我的解答：
帕斯卡三角形定义：
1. 有N个数组
2. 第N个数组有N项
3. 第N个数组的第K项=第N-1个数组的第K-1和第K项之和（K!=1 && K<N）
4. 每个数组的第1和最后1项均为1
class Solution:
def generate(self, numRows):
"""
:type numRows: int
:rtype: List[List[int]]
"""
res = []
temp = [] #中间变量
for i in range(1,numRows+1):
lists = [] #存储每一行的数组
lists.append(1)
if i > 1: #第二行及以后的情况
k = 1
while k < i-1:
lists.append(temp[k-1] + temp[k])
k = k + 1
lists.append(1)
res.append(lists)
temp = lists
return res有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()" 输出: true
示例 2:
输入: "()[]{}" 输出: true
示例 3:
输入: "(]" 输出: false
示例 4:
输入: "([)]" 输出: false
示例 5:
输入: "{[]}" 输出: true
我的解答：
我用栈来实现！
class Solution:
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
# "栈"实现
stack = list()
for strs in s:
if strs == '(' or strs == '[' or strs == '{':
stack.append(strs)
else:
#下面是栈不为空的情况，需要返回栈顶元素进行对比判断
if stack:
temp = stack.pop()
if strs == ')' and temp == '(' or strs == ']' and temp == '[' or strs == '}' and temp == '{':
continue
else:
return False
#下面是栈顶为空的情况，返回False
else:
return False
#如果此时栈里面还有元素，就返回False
if stack:
return False
#如果此时栈里面没有元素，就返回True
else:
return True缺失数字
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。
示例 1:
输入: [3,0,1] 输出: 2
示例 2:
输入: [9,6,4,2,3,5,7,0,1] 输出: 8
说明:
你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
我的解答：
方法1——数学方法：由于是0-n个数字，我们可以轻易的用等差数列求和公式求出和，那么减去给定数组的和，得到的结果就是缺失的数字。
class Solution:
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
allSum = len(nums)*(len(nums)+1)//2
nowSum = sum(nums)
return allSum-nowSum