# TODO:HJ71字符串通配符
# 处理输入数据(通配符表达式+一组字符串)
import re
reg = input().strip().lower()
s = input().strip().lower()
# 进行匹配操作：先将‘通配符’转换为‘正则表达式符号’再进行正则匹配
# 正则表达式：
# 1、任意单个字符：\.
# 2、任意长度的字符序列：\w*
# 3、任意单个字符：\w{1}
regx = reg.replace('.', '\.').replace('*', '\w*').replace('?', '\w{1}')
c = re.findall(regx, s)
print('true' if s in c else 'false')
# TODO:HJ74参数解析
# 1、参数分隔符为空格
# 2、用""包含起来的参数，如果中间有空格，不能解析为多个参数。引号不存在嵌套情况。
# 3、参数不定长
# 4、不会出现不符合要求的输入
# 处理输入数据("xcopy /s" c:\\ "d:\\e") -> [xcopy , /s, c:\\ , d:\\e]
s = input().strip().split('"') # 按双引号拆分字符串
sc = []
for i in range(0, len(s), 2): # 偶数索引元素(引号外)
for k in list(s[i].split(' ')):
sc.append(k)
if i <= len(s)-2: # 偶数索引加1的奇数索引一定被双引号包含，直接加入
sc.append(s[i+1])
# 去除split('"')产生的空元素
sc = [i for i in sc if i != '']
'''输出'''
print(len(sc))
print('\n'.join(sc))
# # 处理输入数据
# str1 = input().strip().split('"')
# lst = []
#
# # 解析字符串（分奇数和偶数）
# for i in range(len(str1)):
# if i == 0:
# lst.extend(str1[i].split(' '))
# elif i % 2 == 0: # 偶数
# lst.extend(str1[i].split(' '))
# elif i % 2 != 0: # 奇数
# lst.append(str1[i])
#
# # 处理lst中split('"')的空格
# lst = [i for i in lst if i != '']
#
# # 格式化输出
# print(len(lst))
# print('\n'.join(lst))
# TODO:HJ75公共子串计算
# 处理输入数据
str1 = input().strip()
str2 = input().strip()
if len(str2) < len(str1):
str1, str2 = str2, str1
# 计算最大公共子串
max_s = ''
for i in range(1, len(str1)+1): # 子串长度
for j in range(0, len(str1)-i+1): # 子串的起始位置
if str1[j:j+i] in str2 and len(str1[j:j+i]) > len(max_s):
max_s = str1[j:j+i]
# 输出最大子串的长度
print(len(max_s))
# TODO:HJ77火车进站(深度优先搜索-递归调用dfs)
def dfs(wait, stack, out):
"""
wait: 等候进站的火车序列
stack: 在站的火车序列
out: 已经出站的火车序列
"""
if not wait and not stack:
res.append(' '.join(map(str, out)))
if wait: # 入栈
dfs(wait[1:], stack + [wait[0]], out)
if stack: # 出栈
dfs(wait, stack[:-1], out + [stack[-1]])
# 处理输入数据
n, nums = int(input()), list(map(int, input().strip().split()))
res = []
# 定义递归函数
dfs(nums, [], [])
# 格式化输出
# 输出以字典序从小到大排序的火车出站序列号
for i in sorted(res):
print(i)
# TODO:HJ82将真分数（分子比分母小）分解为埃及分数（分子为1）
# 埃及分数处理函数（特殊情况：分子为1，分子能被分母整除）
def fun(n, m):
if n == 1: # 分子为 1
res.append(m)
return res
if m % n == 0: # “分母” 为 “分子” 的整数倍
res.append(m // n)
return res
while n > 1: # 分子 >1
k = m // n + 1 # 1/k应为小于等于m/n的最小整数
res.append(k)
return fun(n * k - m, m * k) # 根据分数求导公式推导而来
while True:
try:
# 处理输入数据
n, m = map(int, input().split('/')) # 分子和分母
res = []
# 拆分埃及分数
result = fun(n, m)
print('1/' + '+1/'.join(map(str, result)))
except:
break
# TODO:HJ88扑克牌大小
# 1、大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
# 2、输入的两手牌不会出现相等的情况。
# 3、输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
poker = {
'3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10,
'J': 11, 'Q': 12, 'K': 13, 'A': 14, '2': 15,
'joker': 16, 'JOKER': 17
}
# 处理输入数据
s = input().strip().split('-')
s1, s2 = s[0].split(' '), s[1].split(' ')
# 判断手中牌的情况
if 'joker JOKER' in s: # 王炸
print('joker JOKER')
# 牌数一样直接考虑第一张牌大小就好，牌已经按顺序摆好了
elif len(s1) == len(s2):
print(' '.join(s1) if poker[s1[0]] > poker[s2[0]] else ' '.join(s2))
# 数量不一致就看有无炸弹
elif len(s1) == 4:
print(' '.join(s1))
elif len(s2) == 4:
print(' '.join(s2))
# 都没有就比不了
else:
print('ERROR')
# TODO:HJ89 24点运算（扑克牌益智游戏）
# 1、运算只考虑加减乘除运算，没有阶乘，没有括号；
# 2、牌面2~10对应的权值为2~10, J、Q、K、A权值分别为为11、12、13、1；
# 3、如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算
# 4、如果存在多种算式都能计算得出24，只需输出一种即可；
# 处理输入数据
a = input().split(' ')
poker = {
'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10,
'J': 11, 'Q': 12, 'K': 13, 'A': 1,
}
# poker = {'J': 11,'Q': 12,'K': 13,'A': 1}
# 定义24点处理函数（递归）
# wait: 尚未参与运算的扑克牌点数
# target: 需要通过运算得到的目标值
# out: 一个字符串，记录当前的运算表达式
def dfs(wait, target, out):
# 当wait列表中只剩下一个元素时，比较其是否等于目标值（递归退出条件）
if len(wait) == 1 and target == poker[wait[0]]:
res.append(wait[0] + out)
# if len(wait) == 1:
# if wait[0] in poker:
# c = poker[wait[0]]
# else:
# c = int(wait[0])
# if target == c:
# res.append(wait[0] + out)
else:
for i in range(len(wait)):
others = wait[:i] + wait[i+1:]
c = poker[wait[i]]
# *****采用了一种逆向推导的逻辑来构建运算表达式*****************************
# target(y)减去了c,那么wait[i]+out(x)就应该加上c
dfs(others, target-c, '+' + wait[i] + out)
dfs(others, target+c, '-' + wait[i] + out)
dfs(others, target*c, '/' + wait[i] + out)
dfs(others, target/c, '*' + wait[i] + out)
# 分情况求解24点
res = []
if 'joker' in a or 'JOKER' in a:
print('ERROR')
else:
dfs(a, 24, '')
print('NONE' if not res else res[0])
# TODO:HJ90合法IP
# 处理输入数据
ips = input().strip().split('.')
# 判断ip合法性
flg = 0
for i in range(4):
if len(ips) != 4: # ip不足4位
continue
elif not ips[i].isdigit(): # ip含有特殊字符
continue
elif ips[i][0] == '0' and len(ips[i]) > 1: # ip数字第一个为0
continue
elif 0 <= int(ips[i]) <= 255: # ip数字不在0~255之间
flg += 1
if flg == 4:
print('YES')
else:
print('NO')
# TODO:HJ92在字符串中找出连续最长的数字串
while True:
try:
# 处理输入数据
x = input().strip()
strs = ''
for i in x:
if i.isdigit():
strs += i
else:
strs += ' '
# 获取数字的数组，以及每组数字的对应长度
lists = strs.strip().split(' ')
len_lists = [len(i) for i in lists]
# 格式化输出
max_len = max(len_lists)
result = []
for i in lists:
if len(i) == max_len:
result.append(i)
print("".join(result) + ',' + str(max_len))
except:
break
# TODO:HJ93数组分组
# 1、所有5的倍数必须在其中一个组
# 2、所有3的倍数在另一个组
# 3、不是5的倍数也不是3的倍数能放在任意一组
# 处理输入数据: 数据个数+输入数据
n, nums = int(input().strip()), list(map(int, input().strip().split()))
# 先分5的倍数、3的倍数，并计算两组差值
# 例如，假设有一个列表 nums = [3, 5, 6, 9, 10]。当循环开始时，迭代器指向第一个元素 3。如果 3 不是 5 的倍数也不是 3 的倍数，迭代器会移动到下一个元素 5。假设 5
# 是 5 的倍数，执行 nums.remove(5) 后，列表变为 [3, 6, 9, 10]。此时，迭代器已经准备好访问下一个元素，由于列表长度改变，它会跳过原本的 6 直接访问 9（因为删除 5
# 后，6 的索引提前了一位），这样就会导致 6 没有被正确遍历到。
# nums[:]创建的是列表的副本
res = [0]
for i in nums[:]:
if i % 5 == 0: # 5的倍数
res[0] += i
nums.remove(i)
elif i % 3 == 0: # 3的倍数
res[0] -= i
nums.remove(i)
# 分组其他元素
for i in nums:
new_res = []
for e in res:
new_res.extend([e + i, e - i]) # 不能用append
res = new_res
print('true' if 0 in res else 'false')
# TODO:HJ95人民币转换
import re
list1 = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"] # 用于数字转大写
list2 = ['亿', '仟', '佰', '拾', "万", "仟", "佰", "拾", "元", ".", "角", "分"] # 用于单位转大写（从后往前与数字对应）
# 处理输入数据
num = input()
n = len(num)
# 从末尾开始遍历字符串，并将数字转换为大写汉字
str1 = ""
for i in range(-n, 0, 1):
if i != -3: # 跳过小数点
str1 += list1[int(num[i])] + list2[i]
# 下面就是特殊情况的处理（先替换长的）
# re.sub():替换字符串中匹配正则表达式模式的部分
# 1、中文大写金额数字前应标明“人民币”字样
# 2、如532.00应写成“人民币伍佰叁拾贰元整”。在”角“和”分“后面不写”整字。
# 3、阿拉伯数字中间有“0”时，中文大写要写“零”字，阿拉伯数字中间连续有几个“0”时，中文大写金额中间只写一个“零”字，如6007.14，应写成“人民币陆仟零柒元壹角肆分“。
# 4、10应写作“拾”，100应写作“壹佰”。
str2 = re.sub("壹拾", "拾", str1)
str3 = re.sub("零角零分", "整", str2)
str4 = re.sub("零分", "", str3)
str5 = re.sub("零角", "", str4)
str6 = re.sub("零元", "元", str5) # 0.5-> 零元伍角-> 元伍角
str7 = re.sub("(零.)+", "零", str6)
str8 = re.sub("^元", "", str7)
print('人民币'+str8)
# TODO:HJ98自动售货系统
def f(pq):
w10, w5, w2, w1 = 0, 0, 0, 0 # 记录已经找出的零钱
while pq > 0: # 循环直到找零完成
if pq >= 10 and dic_q['10'] >= 1: # 可以找10元时
pq -= 10 # 余额减10
w10 += 1 # 已经找出的零钱+1
dic_q['10'] -= 1 # 零钱10数量-1
elif pq >= 5 and dic_q['5'] >= 1: # 可以找5元时
pq -= 5
w5 += 1
dic_q['5'] -= 1
elif pq >= 2 and dic_q['2'] >= 1:
pq -= 2
w2 += 1
dic_q['2'] -= 1
elif pq >= 1 and dic_q['1'] >= 1:
pq -= 1
w1 += 1
dic_q['1'] -= 1
else:
pq -= 1 # 耍赖，如果因零钱不足导致不能退币，则尽最大可能退币，以减少用户损失。
return pq, w1, w2, w5, w10
while True:
try:
s = input().split(';')
dic_m = {'A1': 2, 'A2': 3, 'A3': 4, 'A4': 5, 'A5': 8, 'A6': 6} # 商品单价字典
dic_n = {'A1': 0, 'A2': 0, 'A3': 0, 'A4': 0, 'A5': 0, 'A6': 0} # 商品数量字典
dic_q = {'10': 0, '5': 0, '2': 0, '1': 0} # 零钱字典
pq = 0
for i in s[:-1]:
if i[0] == 'r': # 系统初始化，把商品数量和零钱放入字典
b = i.split()
m = b[1].split('-')
q = b[2].split('-')
dic_n['A1'], dic_n['A2'], dic_n['A3'], dic_n['A4'], dic_n['A5'], dic_n['A6'] = int(m[0]), int(m[1]), int(m[2]), int(m[3]), int(m[4]), int(m[5])
dic_q['1'], dic_q['2'], dic_q['5'], dic_q['10'] = int(q[0]), int(q[1]), int(q[2]), int(q[3])
print('S001:Initialization is successful')
elif i[0] == 'p': # 投币
pq1 = int(i.split()[1])
if pq1 not in [1, 2, 5, 10]: # 币值非法
print('E002:Denomination error')
elif pq1 not in [1, 2] and pq1 >= (dic_q['1'] + dic_q['2']*2): # 存钱盒中1元和2元面额钱币总额小于本次投入的钱币面额
print('E003:Change is not enough, pay fail')
elif dic_n['A1'] == 0 and dic_n['A2'] == 0 and dic_n['A3'] == 0 and dic_n['A4'] == 0 and dic_n['A5'] == 0 and dic_n['A6'] == 0: # 自动售货机中商品全部销售完毕
print('E005:All the goods sold out')
else :
dic_q[str(pq1)] += 1 # 字典对应币值零钱数量加一
pq += pq1 # 投币余额增加
print('S002:Pay success,balance={}'.format(pq))
elif i[0] == 'b': # 购买商品
bn = i.split()[1]
if bn not in dic_n.keys(): # 购买的商品不在商品列表中
print('E006:Goods does not exist')
elif dic_n[bn] == 0: # 所购买的商品的数量为0
print('E007:The goods sold out')
elif int(pq) < dic_m[bn]: # 投币余额小于待购买商品价格
print('E008:Lack of balance')
else:
pq = int(pq) - dic_m[bn] # 余额相应减少
print('S003:Buy success,balance={}'.format(pq))
dic_n[bn] -= 1 # 贩卖机物品数量减一
elif i[0] == 'c':
if pq == 0: # 币余额等于0
print('E009:Work failure')
else: # 按照退币原则进行“找零”
pq, w1, w2, w5, w10= f(pq) # f()函数实现过程
print('1 yuan coin number={}'.format(w1))
print('2 yuan coin number={}'.format(w2))
print('5 yuan coin number={}'.format(w5))
print('10 yuan coin number={}'.format(w10))
elif i[0] == 'q': # 查询功能
if ' ' not in i: # 给出的案例中q1之间无空格，非标准输入。为了过示例添加
print('E010:Parameter error')
elif i.split()[1] not in ['0', '1']: # “查询类别”参数错误
print('E010:Parameter error')
elif i.split()[1] == '0': # 查询类别0
print('A1 2 {}'.format(dic_n['A1']))
print('A2 3 {}'.format(dic_n['A2']))
print('A3 4 {}'.format(dic_n['A3']))
print('A4 5 {}'.format(dic_n['A4']))
print('A5 8 {}'.format(dic_n['A5']))
print('A6 6 {}'.format(dic_n['A6']))
elif i.split()[1] == '1': # 查询类别1
print('1 yuan coin number={}'.format(dic_q['1']))
print('2 yuan coin number={}'.format(dic_q['2']))
print('5 yuan coin number={}'.format(dic_q['5']))
print('10 yuan coin number={}'.format(dic_q['10']))
except:
break
# TODO:HJ103 Redraiment(走梅花桩)
# 处理输入数据
n = int(input()) # 数组的个数
s = list(map(int, input().split())) # 梅花桩的高度
# 走梅花桩，最大递增子序列长度
dp = [1] * n
for i in range(n-1):
for j in range(i+1, n):
if s[j] > s[i]:
dp[j] = max(dp[j], dp[i] + 1)
print(max(dp))
# TODO:HJ107求解方程根
# round(x, n): 将浮点数x四舍五入到最接近的整数,n是小数点后应该保留的位数
n = float(input().strip())
if n >= 0:
t = n**(1/3)
print(round(t, 1))
else:
t = (-n)**(1/3)
print(round(-t, 1))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
