CSDN话题挑战赛第2期
参赛话题：算法题解
LeetCode Cookbook 数学（1）
本节是与数学相关的习题，难题放在下一节，这一节都是简单题，喜欢的话，点赞收藏哦！
7. 整数反转（model-I 数字本身操作）
题目链接：7. 整数反转
题目大意：给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围
[
−
2
31
,
2
31
−
1
]
[−2^{31}, 2^{31} − 1]
[−231,231−1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
例如：
输入：x = 123
输出：321
输入：x = -123
输出：-321
输入：x = 120
输出：21
输入：x = 0
输出：0
- 解题思路：while 循环处理就可以了 区间边界的细节注意
- 时间复杂度： O ( l o g ( ∣ x ∣ ) ) O(log(|x|)) O(log(∣x∣)) 翻转的次数即 x 十进制的位数。
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def reverse(self, x: int) -> int:
INT_MIN,INT_MAX = -2**31,2**31-1
flag = 1 if x<0 else 0
x = abs(x)
ans = 0
while x:
tmp = x%10
x //= 10
ans = ans*10+tmp
ans = -ans if flag else ans
if (ans>INT_MAX) or (ans<INT_MIN): ans = 0
return ans
9. 回文数（model-I 数字本身操作）
题目链接：9. 回文数
题目大意：给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。
例如：
输入：x = 121
输出：true
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
- 解题思路：有些耍赖的办法
- 时间复杂度： O ( N ) O(N) O(N) N为字符串长度
- 空间复杂度： O ( N ) O(N) O(N)
class Solution:
def isPalindrome(self, x: int) -> bool:
s = str(x)
return True if s[::-1] == s else False
172. 阶乘后的零 （model-I 数字本身操作）
题目链接：172. 阶乘后的零
题目大意：给定一个整数 n ，返回 n! 结果中尾随零的数量。
提示
n
!
=
n
∗
(
n
−
1
)
∗
(
n
−
2
)
∗
.
.
.
∗
3
∗
2
∗
1
n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1
n!=n∗(n−1)∗(n−2)∗...∗3∗2∗1
例如：
输入：n = 3
输出：0
解释：3! = 6 ，不含尾随 0
输入：n = 5
输出：1
解释：5! = 120 ，有一个尾随 0
输入：n = 0
输出：0
- 解题思路： 贪心 找因子5的个数
- 时间复杂度： O ( N ) O(N) O(N) N为n!中因子 5 的个数
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def trailingZeroes(self, n: int) -> int:
ans = 0
while n:
n //= 5
ans += n
return ans
258. 各位相加（model-I 数字本身操作）
题目链接：258. 各位相加
题目大意：给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果。
例如：
输入: num = 38
输出: 2
解释: 各位相加的过程为：
38 --> 3 + 8 --> 11
11 --> 1 + 1 --> 2
由于 2 是一位数，所以返回 2。
输入: num = 0
输出: 0
- 解题思路： 用 while 循环来处理
- 时间复杂度： O ( l o g ( n ) ) O(log(n)) O(log(n)) n为整数值
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def addDigits(self, num: int) -> int:
# return (num-1) % 9 + 1 if num else num
while num>9:
cur = 0
while num:
cur += num%10
num //= 10
num = cur
return num
263. 丑数（model-I 数字本身操作）
题目链接：263. 丑数
题目大意：丑数 就是只包含质因数 2、3 和 5 的正整数。
给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。
例如：
输入：n = 6
输出：true
解释：6 = 2 × 3
输入：n = 1
输出：true
解释：1 没有质因数，因此它的全部质因数是 {2, 3, 5} 的空集。习惯上将其视作第一个丑数。
输入：n = 14
输出：false
解释：14 不是丑数，因为它包含了另外一个质因数 7 。
- 解题思路：建立满足要求的因子集合 用 while 循环来处理
- 时间复杂度： O ( l o g ( n ) ) O(log(n)) O(log(n)) n为整数值
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def isUgly(self, n: int) -> bool:
if n<1: return False
factor = [2,3,5]
for i in factor:
# Be sober!
while n % i == 0:
n //= i
if n == 1: return True
return False
507. 完美数（model-I 数字本身操作）
题目链接：507. 完美数
题目大意：对于一个 正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。
给定一个 整数 n， 如果是完美数，返回 true；否则返回 false。
例如：
输入：num = 28
输出：true
解释：28 = 1 + 2 + 4 + 7 + 14
1, 2, 4, 7, 和 14 是 28 的所有正因子。
输入：num = 7
输出：false
- 解题思路：打表.
- 时间复杂度： O ( 1 ) O(1) O(1)
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def checkPerfectNumber(self, num: int) -> bool:
return num==6 or num==28 or num==496 or num==8128 or num==33550336
202. 快乐数（model-I 数字本身操作）
题目链接：202. 快乐数
题目大意：编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
例如：
输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
输入：n = 2
输出：false
- 解题思路：快慢指针处理的手段 非常地妙
- 时间复杂度： O ( l o g ( n ) ) O(log(n)) O(log(n))
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def isHappy(self, n: int) -> bool:
def get_nxt(num: int) -> int:
tSum = 0
while num>0:
num,dig = divmod(num,10)
tSum += dig**2
return tSum
slow,fast = n,get_nxt(n)
while fast != 1 and slow != fast:
slow = get_nxt(slow)
fast = get_nxt(get_nxt(fast))
return fast == 1
1137. 第 N 个泰波那契数（model-I 数字本身操作）
题目链接：1137. 第 N 个泰波那契数
题目大意：泰波那契序列 Tn 定义如下：
T
0
=
0
,
T
1
=
1
,
T
2
=
1
T_0 = 0, T_1 = 1, T_2 = 1
T0=0,T1=1,T2=1, 且在 n >= 0 的条件下
T
n
+
3
=
T
n
+
T
n
+
1
+
T
n
+
2
T_{n+3} = T_n + T_{n+1} + T_{n+2}
Tn+3=Tn+Tn+1+Tn+2
给你整数 n，请返回第 n 个泰波那契数 T_n 的值。
例如：
输入：n = 4
输出：4
解释：
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
输入：n = 25
输出：1389537
- 解题思路：预设好做就可以了。
- 时间复杂度： O ( N ) O(N) O(N) N为数组长度
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def tribonacci(self, n: int) -> int:
if n<2: return n
a,b,c = 0,1,1
while n>2:
c,b,a = a+b+c,c,b
n -= 1
return c
1154. 一年中的第几天（model-I 数字本身操作）
题目链接：1154. 一年中的第几天
题目大意：给你一个字符串 date ，按 YYYY-MM-DD 格式表示一个 现行公元纪年法 日期。返回该日期是当年的第几天。
例如：
输入：date = "2019-01-09"
输出：9
解释：给定日期是2019年的第九天。
输入：date = "2019-02-10"
输出：41
- 解题思路：这道题 的范围贼坑 注意 年份需要好好判断。
- 时间复杂度： O ( 1 ) O(1) O(1)
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def dayOfYear(self, date: str) -> int:
amount = [31,28,31,30,31,30,31,31,30,31,30,31]
year,mon,day = [int(x) for x in date.split('-')]
if year%400==0 or (year%4==0 and year%100!=0):
amount[1] += 1
ans = sum(amount[:(mon-1)])
return ans+day
1281. 整数的各位积和之差（model-I 数字本身操作）
题目链接：1281. 整数的各位积和之差
题目大意：给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
例如：
输入：n = 234
输出：15
解释：
各位数之积 = 2 * 3 * 4 = 24
各位数之和 = 2 + 3 + 4 = 9
结果 = 24 - 9 = 15
输入：n = 4421
输出：21
解释：
各位数之积 = 4 * 4 * 2 * 1 = 32
各位数之和 = 4 + 4 + 2 + 1 = 11
结果 = 32 - 11 = 21
- 解题思路： 按题意做就可以。
- 时间复杂度： O ( l o g N ) O(log N) O(logN) N为整数
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def subtractProductAndSum(self, n: int) -> int:
s,t = 0,1
while n:
tmp = n%10
s += tmp
t *= tmp
n //= 10
return t-s
812. 最大三角形面积（model-II 几何）
题目链接：812. 最大三角形面积
题目大意：给定包含多个点的集合，从其中取三个点组成三角形，返回能组成的最大三角形的面积。
例如：
示例:
输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
输出: 2
解释:
这五个点如下图所示。组成的橙色三角形是最大的，面积为2。
- 解题思路： 三个梯形求解
- 时间复杂度： O ( N 3 ) O(N^3) O(N3) N为数组长度
- 空间复杂度： O ( 1 ) O(1) O(1)
class Solution:
def largestTriangleArea(self, points: List[List[int]]) -> float:
ans = 0
N = len(points)
for i in range(N-2):
for j in range(i+1,N-1):
for k in range(i+2,N):
(x1,y1),(x2,y2),(x3,y3) = points[i],points[j],points[k]
# decompose into three trapezoids operation
# 分解成三个梯形之间的运算
ans = max(ans,0.5*abs(x1*y3-x1*y2+x2*y1-x2*y3+x3*y2-x3*y1))
return ans
总结
努力 奋斗！要写大论文 啊~ 要命。
184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
