[蓝桥杯python]学习笔记

Osidal

已于 2024-05-05 13:20:01 修改

阅读量850

点赞数 18

分类专栏：蓝桥备赛文章标签：蓝桥杯学习笔记

于 2024-05-05 12:03:42 首次发布

本文链接：https://blog.csdn.net/Ensoleilef/article/details/138463086

版权

蓝桥备赛专栏收录该内容

11 篇文章 1 订阅

订阅专栏

想说的话

14届蓝桥也是python拿了三等，今年15届还是py拿了二等，但是已经大三了所以可能后面也不会再有机会参加了，maybe等到研究生可能会吧。今年是想冲一下一等的，但是诶呦事与愿违，今年打蓝桥也是临时决定的，甚至最后期限才报名，准备时间也只有差不多一个月的时间，所以想拿奖的朋友们一个月也足够了其实，而且我这一个月也没有说是非常非常上强度的程度，每天抽出一部分时间学习做题，蓝桥py真没那么难，加油！这篇博只是我学习过程中的一些记录，可能会有错误，逻辑表述也不是很好，有什么问题错误请大家直接指出，谢谢！

[蓝桥杯python]动态规划-CSDN博客

[蓝桥杯python]考前必看-CSDN博客

这是另外两篇，大家有兴趣也可以看一下

知识点

散

1. 切片：s[起始位置：终止位置：步长]

[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

s[i：]：代表从第i个位置开始算起，及不检索在i位置前的字符串
s[：i]：代表检索到元组或字典的第i位置处
s[：：i]：代表以i为步长检索s(从头到尾)
s[i:j:k]:代表从字符串（元组或字典）第i位置到第j位置以k步长检索输出

2. 列表用 [ ] 标识；元组用 () 标识；字典用{ }标识。

- 字典由索引(key)和它对应的值value组成。
- 元组不能赋值相当于对列表的只读

3. 运算符

4. 成员运算符身份运算符

5. 通过序列索引迭代

 fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])
 
print ("Good bye!")

当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

6. 素数

素数：只能被1和自身整除的正整数

while(i<100):
	j = 2
	while(j <=(i/j)):# 当 j 不大于 i 的平方根时执行循环体
		if not(i%j):# 判断 i 是否可以被 j 整除
            break# 如果可以整除就说明i不是素数
		j = j+1# j 增加1，继续内层循环的下一次迭代
    # 如果内层循环完成而没有找到能整除的 j，说明 i 是素数
	if (j>i/j) : print(i," 是素数")
    # i 增加1，继续外层循环的下一次迭代
	i = i+1

2  是素数
3  是素数
5  是素数
7  是素数
11  是素数
13  是素数
17  是素数
19  是素数
23  是素数
29  是素数
31  是素数
37  是素数
41  是素数
43  是素数
47  是素数
53  是素数
59  是素数
61  是素数
67  是素数
71  是素数
73  是素数
79  是素数
83  是素数
89  是素数
97  是素数

7. break & continue

Python continue 语句跳出本次循环，而break跳出整个循环。

8. 数学函数

abs(x)	返回数字的绝对值
fabs(x)	以浮点数形式返回数字的绝对值
floor(x)	返回数字的下舍整数：math.floor(4.9)返回4
round(x)	返回浮点数x的四舍五入值
pow(x)	x**y
sqrt(x)	平方根
ceil(x)	将 x 向上舍入到最接近的整数

9. 字符串翻转

str(num)[::-1]：使用切片操作 [::-1] 对字符串进行反转。

10. 列表翻转

python列表反转的4种方法_python反转列表-CSDN博客

列表对象的reverse()方法

.reverse()

没有返回值，将列表中的所有元素进行原地逆序

# reverse()方法
a = [1, 2, 3, 4, 5, 6, 7, 'abc', 'def']
a.reverse()
print('列表反转结果：', a)

列表反转结果：[‘def’, ‘abc’, 7, 6, 5, 4, 3, 2, 1]

内置reversed()函数

reversed(列表名)

内置函数reversed()函数不对原列表做任何修改，而是返回一个逆序排列后的迭代对象。

# 内置reversed()函数
a = [1, 2, 3, 4, 5, 6, 7, 'abc', 'def']
a1 = reversed(a)
print('列表反转结果（迭代对象）：', a1)
print('列表反转结果转换成列表：', list(a1))

列表反转结果（迭代对象）：<list_reverseiterator object at 0x00000243EF467A20>
列表反转结果转换成列表：[‘def’, ‘abc’, 7, 6, 5, 4, 3, 2, 1]

切片： lis[::-1]
for循环:

# 使用for循环
a = [1, 2, 3, 4, 5, 6, 7, 'abc', 'def']
a1 = [a[len(a)-i-1] for i in range(len(a))]
print('列表反转结果：', a1)

列表反转结果：[‘def’, ‘abc’, 7, 6, 5, 4, 3, 2, 1]

11. 保留小数点位数

把x保留到小数点后要求的位数，比如3：

①round(x,3)

②print(‘%.3f’%x)

12. 数值运算

数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0

13. 注意数组与字符串之间的转换

#判断是否为回文：左右对称的数字
def is_palindrome(num):
    return str(num) == str(num)[::-1] # 将数组转化为字符串看两者是否相同

14. 进制转换

十进制转二进制、八进制、十六进制：

# 获取用户输入的十进制数
dec = int(input("输入数字："))
print("十进制数为：", dec)
print("转换为二进制为：", bin(dec))
print("转换为八进制为：", oct(dec))
print("转换为十六进制为：", hex(dec))

15. `ord()`

它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值

返回值是对应的十进制整数。

字符串方法

字符串时0个或多个字母、数字和其他符号的有序集合。

常量字符串值通过引号（单引号或者双引号均可）与标识符进行区分

s.swapcase() 将字符串中所有字母的大小写都反转
s.upper() 将字符串所有的字母都转换为大写
s.lower() 将字符串所有的字母都转换为小写
s.isdigit() 检查字符串中的字符是否都是数字
s.isnumeric() 检查字符串中的所有字符是否都是数字字符
s.capitalize() 返回字符串的副本，但将第一个字符大写
s.isalpha() 检查字符串中的所有字符是否都是字母
s.isalnum() 检查字符串中的字符是否都是字母或数
s.isspace() 检查字符串中的字符是否都是空白字符

`count()`

count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。

str.count(sub, start= 0,end=len(string))

`replace()`

str.replxce(被替换的字符A, ‘B’)：将字符A替换成B，也可以替换为空''

`strip()`

list.strip(字符)：删除字符串两端的一种或多种字符；

list.rstrip()：删除右边

list.lstrip()：删除左边

s = 'abbmmmcccbbb'
s1 = s.strip('abc')
print(s1)
#输出：mmm

集（set）

集（set）是由零个或多个不可修改的Python数据对象组成的无序集合。集不允许重复元素，并且写成由花括号包含、以逗号分隔的一系列值。空集由set()来表示。

字典

字典是无序结构，由相关的元素对构成，其中每对元素都由一个键和一个值组成。这种键-值对通常写成键：值的形式。字典由花括号包含的一系列以逗号分隔的键-值对表达

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

遍历字典

# 字典的遍历
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}

# 使用for循环对字典进行遍历,默认获取的是字典的每一个键
for i in dict1:
    print(i)
'''
name
age
gender
id
'''
# 获取的是字典的每一个键
for i in dict1.keys():
    print(i)
'''
name
age
gender
id
'''

# 获取的是字典的每一个值
for i in dict1.values():
    print(i)
'''
小明
18
男
001
'''

# 获取的是字典中每一个键值对组成的元组
for i in dict1.items():
    print(i)
'''
('name', '小明')
('age', 18)
('gender', '男')
('id', '001')
'''
# 有没有办法可以分别拿到字典的键和值呢?

for i in dict1:
    print(i, dict1[i])

for key, value in dict1.items():
    print(key, value )

创建字典

创建空字典

{}
内建函数dict（）

字典推导式

语法格式

{键:值 for 迭代变量 in 可迭代对象 [if 条件表达式]}

字典推导式还可以包含条件语句。例如，创建一个字典，只包含大于5的数字及其平方。

squares = {i: i**2 for i in range(10) if i > 5}

此时需要注意的是字典中不能出现同名的 key，第二次出现就把第一个值覆盖掉了

formkeys通常用于初始化字典

dic = dict.fromkeys(range(3), 'x')
print(dic)

输出结果：
{0: 'x', 1: 'x', 2: 'x'}

访问字典里的值

>>> tinydict = {'name':'Runoob','Age':7,'class':'frist'}

>>> print(tinydict['name'])

Runoob

修改字典

更新信息

tinydict['Age'] = 8# 更新 Age

添加信息

tinydict['School'] = "菜鸟教程"# 添加信息

删除字典元素

deltinydict['Name']# 删除键 'Name'

tinydict.clear()# 清空字典

deltinydict# 删除字典

按value排序

key使用lambda匿名函数取value进行排序

dict = {'a': 1, 'b': 4, 'd': 2, 'e': 12}

a = sorted(dict.items(), key=lambda x: x[1])
a1 = sorted(dict.items(), key=lambda x: x[1], reverse=True)
print(a)
print(type(a))
print(a1)

lambda函数与Python内置函数配合使用

member_list = [
    {"name": "风清扬", "age": 99, "power": 10000},
    {"name": "无崖子", "age": 89, "power": 9000},
    {"name": "王重阳", "age": 120, "power": 8000}
]
new_list = sorted(member_list, key=lambda dict_: dict_["power"])
print(new_list)
 
number_list = [100, 77, 69, 31, 44, 56]
num_sum = list(map(lambda x: {str(x): x}, number_list))
print(num_sum)


运行结果：

[{'name': '王重阳', 'age': 120, 'power': 8000}, {'name': '无崖子', 'age': 89, 'power': 9000}, {'name': '风清扬', 'age': 99, 'power': 10000}]
[{'100': 100}, {'77': 77}, {'69': 69}, {'31': 31}, {'44': 44}, {'56': 56}]

上面的sorted是Python中对列表排序的内置函数，我们使用lambda来获取排序的key。

map是Python中用来做映射的一个内置函数，接收两个参数，第一个参数是一个函数，第二个参数是一个可迭代对象，map会遍历可迭代对象的值，然后将值依次传递给函数执行。我们使用lambda来实现map中的函数参数

内置方法

dict.clear()删除字典内所有元素

dict.copy()返回字典的浅复制

dict.fromkeys(seq[, value])创建一个新字典，以序列seq中元素作字典的键

value是字典所有键对应的初始值

seq = ('name', 'age', 'sex')

tinydict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(tinydict))

tinydict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(tinydict))

dict.get(key,default = none)返回指定键的值，if键不在字典中返回默认值

dict.update(dict2)把字典dict2的键/值对更新到dict里 # 一般用于两个字典的拼接，

pop(key[,default])删除字典 key（键）所对应的值，返回被删除的值。

popitem()返回并删除字典中的最后一对键和值。

python模块

statistics模块

1、statistics.mean()  求算术平均值
2、statistics.median() 计算数据的中位数，如果有两个中位数，则返回其平均值
   statistics.median_low() 数据中的低中位数
   statistics.median_high() 数据中的高中位数
3、statistics.mode()  计算众数
4、statistics.pvariance() 计算数据的总体方差

collections模块

Python中 collections模块的详细用法介绍_python collections-CSDN博客

1、collections.deque([])
        q = collections.deque([1, 2, 3, 4])
        q.rotate(1)
        print(q)  # [4, 1, 2, 3]
        q.rotate(1)
        print(q)  # [3, 4, 1, 2]
2、collections.Counter()
    >>> import collections
    >>> collections.Counter([1,2,3,1,2,3,1,2])
    Counter({1: 3, 2: 3, 3: 2})

RE库正则表达式

正则表达式(regex)是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。

re.compile: 编译一个正则表达式模式(pattern)
re.match: 从头开始匹配, 使用group()方法可以获取第一个匹配值
re.search: 用包含方式匹配，使用group()方法可以获取第一个匹配值
re.findall: 用包含方式匹配，把所有匹配到的字符放到以列表中的元素返回多个匹配值
re.sub: 匹配字符并替换
re.split: 以匹配到的字符当做列表分隔符，返回列表

Datetime

datetime是由date和Time两部分组成

itertools

Itertools.permutation()

全排列，用于简化组合结构，可以对集合或字符串进行排序或排列的所有可能的组合

接受一个迭代器和r（需要排列的长度）假设“ r”作为迭代器的默认长度(如果未提及)，并分别返回所有可能的长度为“ r”的排列。

如果对象是字典，只对键进行组合

对字符串进行排列

from itertools import  permutations
a = 'abc'   #对字符串进行permutations排列组合
for i in permutations(a,3):
    x = ''.join(i)
    print (x,end=' ')

对列表进行排列

b = [1,2,3] #对列表进行permutations排列组合
for j in permutations(b,3):
    print (''.join('%d'%o for o in j))

函数

sorted（）

排序操作

sorted(iterable, cmp=None, key=None, reverse=False)

iterable -- 可迭代对象。

cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

fin_s=sorted(fin.items(),key=lambda item:(-item[1],item[0]))

按照第二列倒序，如果第二列相同就按照第一列正序排序

count()

可以返回指定元素在列表中出现的次数

>>> a = [10,20,30,40,50,20,30,10,40,20]
>>> a.count(20)
3

len()

获取列表中所有元素的个数

len(L)

pow()

pow(x, y[, z])

函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。

join（）

‘’.join(list)

把list中的元素合成一个字符串

列表常用方法

列表生成方法

l = list(range(1000)#列表构造器产生
l = [i for i in range(1000)]#列表解析器

常用方法

list.append() 增加

list.insert() 插入

list.pop() 删除并返回列表中的最后一个元素

list.pop(i)删除并返回列表中的第i个位置元素#pop根据索引值删除

list.sort()将列表元素排序

list.reverse()倒序排序

del list[i] 删除

list.index(item) 返回item第一次出现时的下标

list.count(item) 返回item在列表中出现的次数

list.remove(item) 从列表中移除第一次出现的item # remove是根据元素值删除

输入

input

strip():去掉字符串首尾的指定字符，默认为换行符和空格。

split():以某个字串或者字符拆分已有的字符串，默认情况以空格拆分。

map()：会根据提供的函数对指定序列做映射。

1. 读取一行输入

s = input() #字符串
n = int(input()) #整数

line = list(map(int, input().strip().split()))

1. 读取多个元素

n, k = map(int, input().split())
num = list(map(int, input().split()))

1. 将整个数组变为整个字符串

s= "".join(map(str,num))

1. 读取多行输入（不指定行数）

lis = []
while True:
    line = input().strip()
    if line == '':
        break
    lines = list(map(int, line.split()))
    lis.append(lines)

1. 读取多行输入指定行数

map=[]
for i in range(N):#N是行数
  map.append(list(input()))

输出

print(m,end=‘ ’)

输出m后后面空一格

end参数设置换行符结尾

sep参数改变分隔符

格式化字符串

print("%s is %d years old."%(aName,gae))

算法

排列组合

排列

中国剩余定理

import os
import sys

# 请在此输入您的代码
dp = [(2,1),(3,2),(5,4),(7,4),(13,10),(19,18),(23,15),(29,16),(31,27),(37,22),(41,1),(47,5)]
lcm = 187
res = 187
i = 0
while i < len(dp):
  if res % dp[i][0] == dp[i][1]:
    lcm *= dp[i][0]
    i += 1
  else:
    res += lcm
print(res)

埃及筛

埃拉托斯特尼筛法，简称埃氏筛或爱氏筛，是一种由希腊数学家埃拉托斯特尼所提出的一种简单检定素数的算法。——百度百科

埃拉托斯特尼筛法的原理很简单，即每个质数的整数倍，必然不是质数。我们建立一个表，把这些数扣掉，就行了

杨辉三角

a[i][j]=a[i−1][j]+a[i−1][j−1]

n = int(input()) # 输入n，类型为整数
a = 
[[0 for i in range(0, n + 1)] for j in range(0, n + 1)] # 建立数组
a[1][1] = 1 # 标记a[1][1]的值为1
for i in range(2, n + 1): # range(a,b)表示在[a,b)区间，不包括b
    for j in range(1, i + 1):
        a[i][j] = a[i-1][j-1] + a[i-1][j] # 递推
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(a[i][j], end = ' ') # end=''可以在输出内容后多输出一个字符串，不写end则默认为换行
    print('') # 输出空，因为默认输出后换行，所以达到了换行作用

最小公倍数、最大公约数

math.gcd()	返回给定的整数参数的最大公约数。
math.lcm()	返回给定的整数参数的最小公倍数。

#输出最小公倍数
print (math.lcm(3, 6))

分解质因数

def prime_factor(num):
    factors = []
    i = 2
    while i * i <= num:
        if num % i == 0:
            factors.append(i)
            num = num // i
        else:
            i += 1
    if num > 1:
        factors.append(num)
    return factors

Fibonacci数列

使用递归的方法容易超时

使用动态规划的方法效率高，空间复杂度也小

class Solution:
    def fib(self, n: int) -> int:
        a, b = 0, 1
        for _ in range(n):
            a, b = b, a + b
        return a

排序

二分法

【深基13.例1】查找

def BinarySearch(x):
    left, right = 0, len(lst) - 1
    count = -1
    while left <= right:
        mid = (left + right) // 2
        if lst[mid] == x:
            count = mid + 1
        if lst[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return count
 
 
n, m = map(int, input().split())
lst = list(map(int, input().split()))
lst2 = list(map(int, input().split()))
 
for i in range(m):
    a = lst2[i]
    print(BinarySearch(a), end=' ')

动态规划

知识

Dynamic programming（DP），通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。对于一个原问题，将其拆分成多个子问题，直到子问题可以被直接解决，再把子问题答案保存起来，以减少重复计算，使用子问题答案反推，得出原问题解。动态规划有自底向上和自顶向下两种解决问题的方式。自顶向下即记忆化搜索，自底向上就是递推。

有向无环图

三步骤：

识别问题类型

首先确定是否为动态规划问题：是否可以把这个问题分解成可以求解的子问题

定义状态：定义数组元素的含义 dp[i]
确定状态转移方程：找出数组元素之间的关系式：最难的一步
确定边界条件：找出初始值，

添加记忆：记忆是存储子问题的结果并在需要解决类似的子问题时再次调用它们的过程。这将降低问题的时间复杂度。如果我们不使用记忆，类似的子问题会重复解决，这可能导致指数时间复杂度。

动态规划的分类

自顶向下的动态规划（Top-Down）

这种方法使用递归来解决问题，从最大的问题开始并逐步分解为更小的子问题。

通常结合“记忆化”（Memorization）使用，即存储已解决的子问题的结果，以避免重复计算。

更符合问题的自然形态，但可能会因过多的递归调用而导致性能问题。

自底向上的动态规划（Bottom-Up）

从最小的子问题开始，逐步合成更大的问题的解。

通常使用迭代方法，通过填充表格（一般是数组或矩阵）的方式来记录子问题的解。

通常更高效，因为它避免了递归的开销，并且可以更容易地进行状态转移。

例题

二维数组DP

定义数组元素的含义：dp[i][j]含义是当从左上角走到(i,j)这个位置时有dp[i][j]种路径
关系式：可以向下或者向右走，所以有两种方式到达，

- 一种是从 (i-1, j) 这个位置走一步到达
- 一种是从(i, j - 1) 这个位置走一步到达

所以dp[i] [j] = dp[i-1] [j] + dp[i] [j-1]

初始值：

- dp[0] [0….n-1] = 1// 相当于最上面一行，机器人只能一直往左走
- dp[0…m-1] [0] = 1 // 相当于最左面一列，机器人只能一直往下走

import os
import sys

# 请在此输入您的代码

dp=[[0]*20 for _ in range(20)]
dp[1][0]=1
dp[0][1]=1
for x in range(20):
  for y in range(20):
    if x==0:
      dp[x][y]=dp[x][y-1]+1
    elif y==0:
      dp[x][y]=dp[x-1][y]+1
    else:
      dp[x][y]=dp[x-1][y]+dp[x][y-1]+1
print(dp[-1][-1]+1)

题目

[NOIP2008 普及组] ISBN 号码

输入格式

一个字符序列，表示一本书的 ISBN 号码（保证输入符合 ISBN 号码的格式要求）。

输出格式

一行，假如输入的 ISBN 号码的识别码正确，那么输出 Right，否则，按照规定的格式，输出正确的 ISBN 号码（包括分隔符 -）。

将第12位所有可能出现的值都放在了一个字符串mod中，对于'X'情况很好处理
语法：'sep'.join(seq)以sep作为分隔符，将seq所有的元素合并成一个新的字符串

参数说明

sep：分隔符。可以为空

seq：要连接的元素序列、字符串、元组、字典

mod="0123456789X"#mod这个字符串存放模11后所有可能出现的值
s=list(input())#在输入是便将字符串转化为列表
j=1
sm=0
for i in range(12):#用for循环遍历求和
    if s[i]=='-': continue # 遇到'-'跳过该字符
    else:
        sm+=int(s[i])*j  # 将字符型转换为int型，同时进行乘
        j+=1
m=sm%11#用m来存放模11后的值
if mod[m]==s[12]:#mod[m]代表正确IBSN号码最后一位数的值（为字符串）
    print("Right")
else:
    s[12]=mod[m]
    strs="".join(s)#用join函数将列表转化为字符串
    print(strs)

数字三角形

import os
import sys


# 请在此输入您的代码
n=int(input())
a=[]
Max=0
for i in range(n):
  b=list(map(int,input().split()))
  a.append(b)
# 建立列表
# 更改每行列表
# 三角形，第一行只能为一个数字，从第二行开始更改
for i in range(1,n):
  for j in range(i+1):
    if j==0:
      # 三角形新列表两边只能为前一个列表侧边上位置
      a[i][j]+=a[i-1][j]
    elif j==i:
      a[i][j]+=a[i-1][j-1]
    else:
      # 不在两边取上一个列表所积累更大的
      a[i][j]+=max(a[i-1][j],a[i-1][j-1])
print(max(a[n-1]))
# 最后一个列表所积累最大值

数位和相等

t=0
for i in range(1,100000000):
  a=str(bin(i))[2:]# 切片操作，可以获得不带前缀的结果
  b=str(oct(i))[2:]
  t1=t2=0
  for A in a:
    t1+=int(A)
  for B in b:
    t2+=int(B)
  if t1==t2:
    t+=1
  if t==23:
    print(i)
    break

小蓝做题

import os
import sys
import math
# 请在此输入您的代码

t = int(input())
def prime_factor(num):# 分解质因数
    factors = []
    i = 2
    while i * i <= num:
        if num % i == 0:
            factors.append(i)
        else:
            i += 1
    if num > 1:# 判断最后剩下的部分是否需要加入
        factors.append(num)
    return factors
def lcm(x,n):#最小公倍数
  t = (x*n)/ math.gcd(x,n)
  return t

for i in range(t):
    n,num = map(int,input().split())
    #print(prime_factor(num))
    x = sum(prime_factor(n))
    if lcm(x,n) == num:
        print('YES')
    else:
        print('NO')

能量石【没思路】

import os
import sys

# 请在此输入您的代码
k,n = map(int,input().split())
n = bin(n)[2:][::-1]
tmp = 0
for i in range(len(n)):
    tmp += int(n[i]) * k**i
print(tmp)

字符串

KMP

boarder

用户登录

s=input()
n=len(s)
next=[0]*(1100000)
for i in range(1,n):
  j=next[i]
  while j>0 and s[i]!=s[j]:
    j=next[j]
  if s[i]==s[j]:
    next[i+1]=j+1
  else:
    next[i+1]=0
x=n-next[n]
if n%x==0:
  print(n//x)
else:
  print(1)

拼接回文串

from collections import Counter

n=int(input())
for _ in range(n):
  l1,l2=map(int,input().split())
  s1=input()
  s2=input()
  c1=Counter(s1)
  c2=Counter(s2)

  c=c1+c2
  t=0
  for v in c.values():
    if v%2:
      t+=1
    if t>1:
      print('NO')
      break
  else:
    print('YES')

拼数

for i in range(n-1):
  for j in range(i+1,n):
    if m[i]+m[j] < m[j]+m[i]:
      m[i],m[j] = m[j],m[i]

十四届蓝桥

T = []
s = ['2', '0', '2', '3']
for i in range(12345678, 98765433):
    L = list(str(i))
    count = 0
    for j in L:
        if j == s[count] :
            count = count + 1
        if count == 4:
            #print(i)
            T.append(i)
            break

print(len(T))

直线

#直线
points=[[x,y] for x in range(20) for y in range(21)] #创建二维列表：代表xy坐标系
docker=set()                            #创建集合属性的容器：因为集合里的元素不会重复
for i in points:                        #二重循环遍历每个坐标
    x1,y1=i[0],i[1]                     #注意书写格式：a,b=c,d
    for j in points:
      x2,y2=j[0],j[1]
      if x1==x2:                        #特殊情况：直线垂直时斜率不存在，先跳过最后计算
          continue
      k=(y2-y1)/(x2-x1)                 #斜率公式
      b=(x2*y1-x1*y2)/(x2-x1)           #截距公式
      if (k,b) not in docker:           #存入容器里没有的（斜率，截距）对
          docker.add((k,b))
print(len(docker)+20)                   #输出结果：容器的长度40237+斜率不存在的20种情况=40257

数位排序

n=int(input())
m=int(input())
s=list(range(1,n+1))
s.sort(key=lambda x:sum(int(i) for i in str(x)))# sort本来就是稳定排序
print(s[m-1])

二进制商城

二进制可以表示任意存在的一个正整数

如果钱够了，就是所有种类的二次方

钱不够，就是钱数本身+1（什么都不买）

import os
import sys

# 读取输入的整数 t 测试用例的数量
t = int(input())
# 循环 t 次
for i in range(t):
    # 读取输入的两个整数 a（硬币数） 和 b（衣服数量）
    a, b = list(map(int, input().split()))
    # 判断二进制表示的 a 的位数是否大于 b
    if len(bin(a)[2:]) > b:
        # 如果是，则输出 2 的 b 次方
        print(2**b)
    else:
        # 如果不是，则输出 a+1
        print(a+1)