排列字母

代码如下：

s = "WHERETHEREISAWILLTHEREISAWAY"
ans = sorted(s)
print(''.join(ans))

英文字母

代码如下：

n = int(input())
print(chr(64 + n))

工作时长

方法1：excel法

1.复制文件中的时间到单元格A1，点击“数字”修改属性

2.点击“数据”的“升序”

3.在B1单元格输入

=A2-A1

双击右下角"+"填充一整列

4.我们只需要奇数行的差值，在C1输入公式

=IF(MOD(ROW(),2)=1, B1, 0)

双击右下角"+"填充一整列,这样C列只有奇数行保留时间差，偶数行为0

5.在D1输入

=C1 * 86400

因为一天=86400秒，然后设置单元格格式为“数值”

6.在E1求和

=SUM(D:D)

方法2：使用代码

先在同级目录下新建一个文件“text',将题目所给文件里的日期复制进去

import datetime

# 存储时间的列表
time_list=[]
# 这个模板代码要记住 很简单并不是很复杂
with open("text","r") as f:
    for time in f.readlines():
        time_list.append(time.strip())

# 将字符串 转换为时间格式 的 datetime
trans_time=[]
for time in time_list:
    # 对于每一个字符串进行一个转换
    trans_time.append(datetime.datetime.strptime(time,"%Y-%m-%d %H:%M:%S"))

# 再进行一个转换，全部转换成秒
s_list=[]
for time in trans_time:
    s_list.append(time.timestamp())
# 然后进行一个排序

s_list.sort()
sums=0

#然后进行累计统计
for i in range(1,521,2):
    sums+=(s_list[i]-s_list[i-1])
print(int(sums))

罗马数字

                

代码如下：

n = int(input())
values = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, "D": 500, 'M': 1000}
subtract_pairs = {'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90, 'CD': 400, 'CM': 900}
for _ in range(n):
    s = input()
    ans = 0
    i = 0
    while i < len(s):
        if s[i:i+2] in subtract_pairs:
            ans += subtract_pairs[s[i:i+2]]
            i += 2
        else:
            ans += values[s[i]]
            i += 1
    print(ans)

常见减法对只有 6 种：

· IV（4）
· IX（9）
· XL（40）
· XC（90）
· CD（400）
· CM（900）

算法思路

从左到右扫描：

· 先判断当前位置和下一个字符是不是组合减法（优先级高），如果是，就加对应的值，然后跳过 2 个字符。
· 否则，就加上当前字符对应的值，然后进到下一位。

人物相关性分析

代码如下：

import re

k = int(input())
s = input()

# 找出所有 Alice 和 Bob 的位置，记录它们的起始下标
A = [m.start() for m in re.finditer(r'\bAlice\b', s)]
B = [m.start() for m in re.finditer(r'\bBob\b', s)]

count = 0
left = 0
right = 0
lenB = len(B)

for a in A:
    L = a - k - 3
    R = a + k + 5
    # 移动 left 到第一个 ≥ L 的位置
    while left < lenB and B[left] < L:
        left += 1
    # 移动 right 到第一个 > R 的位置
    while right < lenB and B[right] <= R:
        right += 1
    # 区间内的 Bob 个数
    count += right - left

print(count)

核心思想：

对每个 Alice 的位置 posA，我们想知道：
哪些 Bob 的位置 posB 满足 |posB - posA| 在一定范围内（考虑单词长度后）？

先考虑 Bob 在 Alice 左边的情况（即 Bob 在前，Alice 在后）：

· 中间字符数 = posA - (posB + 3) ≤ K
· 变形得：posB ≥ posA - K - 3
    因为 Bob 要在 Alice 左边，所以 posB 要小于 posA，但又要大于等于某个最小值。

再考虑 Bob 在 Alice 右边的情况（即 Alice 在前，Bob 在后）：

· 中间字符数 = posB - (posA + 5) ≤ K
· 变形得：posB ≤ posA + K + 5

所以，对当前的 posA，所有符合条件的 posB 必须满足：

posA - K - 3 ≤ posB ≤ posA + K + 5

数字换字母

s = input()
dic = dict()
for i in range(len(s)):
    dic[i] = s[i]

t = input()
t_lst = list(t)
num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
for i in range(len(t_lst)):
    if t_lst[i] in num:
        t_lst[i] = dic[int(t_lst[i])]

print(''.join(t_lst))

回文判定

代码一：

s = input()
flag = True
if s != s[:-1]:
    flag = False
print("Y" if flag else "N")

代码二：

s = input()
n = len(s)
left, right = 0, n - 1
flag = True
while left <= right:
    if s[left] == s[right]:
        left += 1
        right -= 1
    else:
        flag = False
        break
if flag:
    print('Y')
else:
    print('N')

单词分析

代码如下：

s = input()
dic = dict()
for ch in s:
    dic[ch] = dic.get(ch, 0) + 1

dic = sorted(dic.items(), key = lambda x: (-x[1], x[0]))
print(dic[0][0])
print(dic[0][1])

子串简写

代码如下：

k = int(input())
s, c1, c2 = map(str, input().split())

lstA = []#记录c1的位置
lstB = []#记录c2的位置

for i in range(len(s)):
    if c1 == s[i]:
        lstA.append(i)
    elif c2 == s[i]:
        lstB.append(i)

j = 0
ans = 0
pos = 0
for i in range(len(lstA)):
    while j < len(lstB):
        if lstB[j] >= lstA[i] + k - 1:
            ans += len(lstB) - j#后续的都会满足条件，直接相加
            break
        else:
            pos = j#标记最后一个值作为下一轮开始的位置
        j += 1#继续往后遍历
    j = pos
print(ans)

01串的熵

代码如下：

import math

x = 23333333
for i in range(10000000, x // 2):#因为0比1少所以最大值肯定小于x//2
    j = x - i#1的个数
    if round((i / x * math.log2(i / x)) * i + (j / x * math.log2(j / x)) * j, 4) == -11625907.5798:
        print(i)
        break

压缩字符串

错误代码：（虽然通过了数据但是逻辑不对，局限 太大）

s = input()
dic = dict()
for ch in s:
    dic[ch] = dic.get(ch, 0) + 1

s_ans = ''
flag = False
for key, value in dic.items():
    if value == 1 or value == 2:
        s_ans += str(key)
    else:
        s_ans += str(key) + str(value)
        flag = True
print(s_ans if flag else "NO")

正确代码：

s = input().strip()

# 特殊情况：空字符串
if not s:
    print("NO")
    exit()

# 压缩字符串
compressed = []
i = 0
n = len(s)

while i < n:
    # 统计连续相同字符的个数
    count = 1
    while i + count < n and s[i + count] == s[i]:
        count += 1 
    # 按规则添加压缩后的内容
    if count == 1:
        compressed.append(s[i])
    else:
        compressed.append(s[i] + str(count))
    i += count
# 得到压缩后的字符串
compressed_str = ''.join(compressed)
# 判断是否真的压缩了（长度更短才输出）
if len(compressed_str) < len(s):
    print(compressed_str)
else:
    print("NO")

错误票据

代码如下：

n = int(input())
a = []
for i in range(n):
    a.extend(list(map(int, input().split())))

a.sort()
min_num = a[0]
max_num = a[-1]

n, m = 0, 0
for i in range(min_num, max_num):
    if i not in a:
        m = i
    if a.count(i) == 2:
        n = i
print(m, n)

串的处理

s = input()
#将输入字符串按空格分割成单词列表
words = s.split()
ans = ''
#遍历每个单词
for word in words:
    #初始化临时字符串，用于存储处理后的单词
    tmp = word[0]
    #遍历单词的每个字符（除了第一个字符）
    for i in range(1, len(word)):
        if (word[i].isdigit() and word[i - 1].isalpha()) or (word[i].isalpha() and word[i - 1].isdigit()):
            tmp += '_'
        #将当前字符添加到临时字符串中
        tmp += word[i]
    #将临时字符串的首字母大写，其他字母小写
    tmp = tmp.capitalize()
    ans += tmp + " "
print(ans)