目录
1.给定一个正整数，返回它在 Excel 表中相对应的列名称。
3.给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
5.给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
6.给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
8.编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
9.计划偷窃沿街的房屋。影响你偷窃的唯一制约因素就是如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
10.你是一个专业的小偷，第一个房屋和最后一个房屋是紧挨着的。两间相邻的房屋被小偷闯入，系统会自动报警。
1.给定一个正整数，返回它在 Excel 表中相对应的列名称。
例如，
1 -> A
2 -> B
3 -> C
...
26 -> Z
27 -> AA
28 -> AB
...class Solution(object):
def convertToTitle(self, n):
"""
:type n: int
:rtype: str
"""
retr=''
#因为n不可以为零，为0则跳出循环
while n!=0:
#每次取当前数据的末位，添加到返回字符串中
retr += chr((n-1)%26+65)
#将它当作从0开始的数据，减一，21==AA
n = (n-1)//26
return retr[::-1]2.给定一个Excel表格中的列名称，返回其相应的列序号。
例如，
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...class Solution:
def titleToNumber(self, s: str) -> int:
add=0
for i in range(len(s)):
add = add *26 +ord(s[i])-65+1
return add3.给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。
示例 1:
输入: [3,2,3]
输出: 3class Solution:
def majorityElement(self, nums: List[int]) -> int:
l = len(nums)
if l == 1:
return nums[0]
nums.sort()
return nums[(l-1)//2]方法二：
class Solution(object):
def majorityElement(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
'''摩尔投票法'''
#先假设result是第一个数，然后从第二个数开始遍历，遇见相同的就+1，不同的就-1，如果
#count==0，就result赋值为下一个数，接着遍历，最后result的值 就是结果。该方法的思想是
#众数一定比其他所有的数加起来的数量#要多，就算是众数与其他每一个数相抵消，最后剩下来的
#也是众数。况且还有其他数之间的抵消，所以剩下来的一定是众数
cnt, ret = 0, 0
for num in nums:
if cnt == 0:
ret = num
if num != ret:
cnt -= 1
else:
cnt += 1
return ret4.给定一个整数 n，返回 n! 结果尾数中零的数量。
示例 1:
输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。示例 2:
输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零. 首先题目的意思是末尾有几个0比如6! = 【1* 2* 3* 4* 5* 6】
其中只有2*5末尾才有0，所以就可以抛去其他数据 专门看2 5 以及其倍数
比如10！ = 【2*4*5*6*8*10】
其中 4能拆成2*2 10能拆成2*5
所以10！ = 【2*（2*2）*5*（2*3）*（2*2*2）*（2*5）】
一个2和一个5配对 就产生一个0 所以10！末尾2个0
转头一想 因为2肯定比5多 所以只数5的个数就行了
如果N=31，31里能凑10的5为[5, 2*5, 3*5, 4*5, 25, 6*5] 其中25还能拆为 5**2，所以多一个
所以5的个数为 int(31/(5**1)) + int(31/(5**2))
所以 只要先找5的最大的幂次x, 5**x < n 然后按上面循环统计5的个数方法一：
import math
class Solution:
def trailingZeroes(self, n: int) -> int:
if not n:
return 0
count = 0
#计算使5**x<=n的最大的x,最后结果加一,由于range()
for i in range(1,int(math.log(n, 5))+1):
k = n//pow(5,i)
count += k
return count方法二：
class Solution(object):
def trailingZeroes(self, n):
"""
:type n: int
:rtype: int
"""
count=0
while n!=0:
n=int(n/5)
count+=n
return count5.给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
示例 1:
输入:[10,2]输出:210
示例 2:
输入:[3,30,34,5,9]输出:9534330
class Solution:
def largestNumber(self, nums: List[int]) -> str:
retr=''
nums=list(map(str,nums))
while nums!=[]:
temp=nums[0]
for i in range(1,len(nums)):
#比较出数值更大的字符串赋值给temp，连接两个字符串是为了长度统一
if nums[i]+temp > temp+nums[i]:
temp = nums[i]
retr+=temp
nums.remove(temp)
if retr[0]=='0':
return '0'
return retr6.给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
for i in range(k):
nums.insert(0,nums.pop())
#法二：可以减少运行时间
nums[:]=nums[-(k%len(nums)):]+nums[:-(k%len(nums))]7.颠倒给定的 32 位无符号整数的二进制位。
示例 1：
输入: 00000010100101000001111010011100 输出: 00111001011110000010100101000000
解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596， 因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
class Solution:
# @param n, an integer
# @return an integer
def reverseBits(self, n):
b = bin(n)[2:]
b = (32 - len(b))*"0" + b
return int(b[::-1],2)8.编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
class Solution(object):
def hammingWeight(self, n):
"""
:type n: int
:rtype: int
"""
n2=bin(n)[2:]
n2=map(int,n2)
return sum(n2)
#方法二：
n2=bin(n)
return n2.count('1')方法二：
class Solution(object):
def hammingWeight(self, n):
"""
:type n: int
:rtype: int
"""
result=0
while n:
if n%2 == 1:
result+=1
n>>=1
return result9.计划偷窃沿街的房屋。影响你偷窃的唯一制约因素就是如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。class Solution(object):
def rob(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
#python动态规划
n = len(nums)
if n == 0:
return 0
elif n == 1:
return nums[0]
else:
#利用rob[i]来保存第i个屋子时可以得到的最大利益
robs = [0]*n
robs[0] = nums[0]
robs[1] = max(nums[0], nums[1])
for i in range(2, n):
#当前rob到的最大利益要么等于前一个的利益，要么等于前前的利益加当前屋子的利益
robs[i] = max(robs[i-2]+nums[i], robs[i-1])
return robs[-1]最后的else可以优化：
else:
prepre= nums[0]
pre = max(nums[0], nums[1])
for i in range(2, n):
pre, prepre = max(prepre+nums[i], pre),pre
return pre10.你是一个专业的小偷，第一个房屋和最后一个房屋是紧挨着的。两间相邻的房屋被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。class Solution(object):
def rob(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
#首尾相接的数组，意味着偷取了第一个就不能偷取最后一个。那么尝试思考两种情况：
#从第一个开始偷取，那么能偷取的数组范围是：[0, n-2]；
#不从第一个偷取，那么能偷取的数组范围是：[1, n-1]；
n = len(nums)
if n == 1:
return nums[0]
last = 0
now = 0
# 0 ~ n-2
for i in range(n - 1):
last, now = now, max(last + nums[i], now)
last2 = 0
now2 = 0
# 1 ~ n-1,
for i in range(1, n):
last2, now2 = now2, max(last2 + nums[i], now2)
return max(now, now2)
扫一扫
295
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
