2.29/3.1 h指数/反转单词/罗马数转整数/除自身外乘积

2.29-1h指数计算：

def findh(A):
    #对A进行倒叙排序
    ans=0
    A.sort(reverse=True)
    for i in range(len(A)):
        if A[i] >= i+1:#如果引用论文数大于等于当前论文数，返回当前论文数
            if i+1>ans and i+1 <= len(A):#如果当前论文数大于ans且小于等于A的长度，返回当前论文数
                ans=i+1
    return ans
print(findh([3,0,6,1,5]))
print(findh([1, 1, 3]))

2.29-2反转字符串单词

# 输入 s = "the sky is blue"
input_str = input()

# 初始化变量，用来存储提取后的反转字符串
reversed_s = ''


start = input_str.find('"')
    # 找到第二个双引号的位置
end = input_str.rfind('"')
#如果需要找到最后一个双引号的位置，可以使用rfind()函数


        # 提取双引号之间的文本
s = input_str[start + 1:end]
        # 分割提取出来的文本并反转顺序，然后拼接成一个新的字符串
reversed_s = ' '.join(s.split()[::-1])

# 打印反转的字符串，确保按照指定格式显示
print('"' + reversed_s + '"')

2.29-3罗马数字转整数

#方法1：
s = input()
s1 = [0]*(len(s)+1)
sum = 0
for i in range(len(s)):
    if s[i] == 'M':
        s1[i] = 1000
    elif s[i] == 'D':
        s1[i] = 500
    elif s[i] == 'C':
        s1[i] = 100
    elif s[i] == 'L':
        s1[i] = 50
    elif s[i] == 'X':
        s1[i] = 10
    elif s[i] == 'V':
        s1[i] = 5
    elif s[i] == 'I':
        s1[i] = 1
for i in range(len(s)):
    if s1[i] < s1[i + 1]:
        sum -= s1[i]
    else:
        sum += s1[i]
print(sum)

#方法2：
s = input()
# 创建一个罗马数字到整数值的映射字典
roman_to_int = {'M': 1000, 'D': 500, 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I': 1}

s1 = [0]*(len(s)+1)  # 为了保留最后一位进行比较
sum = 0

for i in range(len(s)):
    s1[i] = roman_to_int[s[i]]#键值互换

# 计算最终的整数值
for i in range(len(s)):
    if s1[i] < s1[i + 1]:  # 如果当前数字小于它的后一个数字，它将从总和中减掉
        sum -= s1[i]
    else:  # 否则，它将加到总和中
        sum += s1[i]

print(sum)

3.1-1除自身外数乘积：

s = input().split()
len_s = len(s)
s1 = [1] * (len_s + 1)
s2 = [1] * (len_s + 1)
ans = [0] * len_s

# 从左向右累乘，但不包括当前元素
for i in range(1, len_s + 1):
    s1[i] = s1[i - 1] * int(s[i - 1])

# 从右向左累乘，但不包括当前元素
for i in range(len_s - 1, -1, -1):
    s2[i] = s2[i + 1] * int(s[i])

# 计算除了当前索引以外的所有元素的乘积
for i in range(len_s):
    ans[i] = s1[i] * s2[i + 1]

print(ans)

#代码的方法是先从左向右累乘，但不包括当前元素，然后从右向左累乘，但不包括当前元素，最后计算除了当前索引以外的所有元素的乘积。这样就可以得到除自身以外的所有乘积。