2021-03-23pta总结 20+

问题拆分
1049 数列的片段和 (20 分)
解题步骤：先分析题意，搞懂输入输出之间的关系
找出数据结构
数据结构：是双变量还是数组存储，还是字典，还是多维列表
组合列表，集合

板子：最值问题，存序列和初始化最大值并更新

解决推荐题
对于列表append列表问题，最好不用append[a,b]形式，而是使用整体，前面的a，b应用使用列表+下标

upper函数新记忆：upper是将字符串中的小写字符变为大写字符，可以自动识别大小写字母

按照加入list去重，可以lambda x :list.index(x),或者直接传index对象即

key=list.index,外加前面set的去重绝了，两者缺一不可
原类型list的index key和去重的set

原理是那元素的index作比较，在set里挑出元素，同时具备两个功能

对于两字符串比较，一个使用索引，为防止索引出界，必须要加i==len（str）-1判断，可以加入i=i这种无效语句

再次验证了python非零返回是列表out of index

所以在设置判断时一般要判断自己写的列表究竟有没有添加进去东西，会不会是空列表

def do_c(str_):
    ans=[]
    num=0
    if str_=='':
        return ans
    left=str_[0]
    for i in str_:
        if i==left:
            num+=1
        else:
            if num>1:
                ans.append(str(num)+left)
            else:
                ans.append(left)
            left=i
            num=1
    if len(ans)==0 or ans[-1]!=str_[-1]:
        if num>1:
            ans.append(str(num)+str_[-1])
        else:
            ans.append(str_[-1])
    return ''.join(ans)
def do_d(str_):
    num=1
    ans=[]
    flag=False
    for i in str_:
#数字合成判断，使用数字控制，交替输入字符串和
        if i.isdigit():
            
            if flag :
                num=num*10+int(i)
            else:
                num=int(i)
            flag=True
        else:
            flag=False
            while num:
                num-=1
                ans.append(i)
            num=1
    return ''.join(ans)

fangfa=input()
need_poc=input()
if fangfa=='C':
    print(do_c(need_poc))
else:
    print(do_d(need_poc))

在使用format格式化输出时，不考虑“”内的转义字符，直接输出

处理数字输入时，判断是否为合法字符，可以使用异常来写

异常在清洗数据时，也会用到，try里抛出异常，在except里可以执行，下面的代码不影响

排除非合法的可以统一使用try和except方法，不是异常的使用抛出异常，

    try:
          代码
    except：
          代码

raise Exception,在所有的异常抛出后try里写上正确结果
异常使用except Exception统一处理

浮点数小数点前可以不加数字

1055从新写代码

思路，根据奇偶控制输出

a, b = [int(x) for x in input().split()]
l = []
for i in range(b):
    if i == 0:
        l.append(a // b + a % b)
    else:
        l.append(a // b)
n = []
for i in range(a):
    s = input().split()
    n.append(s)
n = sorted(n, key=lambda x: x[0])
n = sorted(n, key=lambda x: int(x[1]), reverse=True)
for i in l:
    ls = []
    if i % 2 == 0:
        for j in range(i):
            if j % 2 == 0:
                ls.append(n.pop(0)[0])
            else:
                ls.insert(0, n.pop(0)[0])
    else:
        ls.append(n.pop(0)[0])
        for j in range(i - 1):
            if j % 2 == 0:
                ls.insert(0, n.pop(0)[0])
            else:
                ls.append(n.pop(0)[0])
    print(' '.join(ls))
'''
num=0
def print_my(l):
    ans=[]
    l=l[::-1]
    for i in range(0,len(l),2):
        if i==len(l)-1:
            ans.append(l[i][0])
        else:
            ans.append(l[i][0])
            ans.insert(0,l[i+1][0])
    return ' '.join(ans)
final_ans=[]

while numa-num>0:
        final_ans.append(print_my(student_and_tall[num:]))
        break
    else:
        final_ans.append(print_my(student_and_tall[num:num+3]))
        num+=3
final_ans.reverse()
for i in final_ans:
    print(i)
'''

数学问题

1056 组合数的和 (15 分)

list_=list(map(int,input().split()))
num=list_[0]
list_=list_[1:]
cnt=0
for i in list_:
    cnt+=(num-1)*(i*11)
print(cnt)

关于代码的优化，能优化的尽量进行优化

能写在一次循环里的尽量写在一次循环里，尤其循环里判断时比较复杂

lower可以将字符串里不是英文字母的自动规避

import re
str1=input()
'''
str2=''

for i in str1:
    if re.match(r'[A-Za-z]',i):
        str2+=i
'''
str1=str1.lower()
ans_de=0
for i in str1:
    if re.match(r'[A-Za-z]',i):
        ans_de+=ord(i)-ord('a')+1
cnt0,cnt1=0,0
while ans_de:
    if ans_de%2==0:
        cnt0+=1
        ans_de//=2
    else:
        cnt1+=1
        ans_de//=2
print(cnt0,cnt1)

1058 数据结构选择问题，列表储存

两层列表中元素位置可表示元素的编号信息，==可以判断值相等，多个储存结果时使用列表存储最好

正则匹配时，一定要注意括号问题，如匹配（）内的内容，则外层括号一定要使用((regex))

import re
nums,numq=map(int,input().split())
qu_info=[]

for i in range(numq):
    #qu_info.append([i]+input().split())
    qu_info.append(input().split())
    #[i]没起到作用，因为直接可以用位置当作序列
max_list=[0]*(numq+5)
for i in range(nums):
    
    str_ans=input()
    regex=re.compile(r'\((.+?)\)')
    list_=regex.findall(str_ans)
    #print(list_)
    perans=0
    for index,item in enumerate(list_):
        #print('here is',index)
        list_per_ans=item.split()
        if qu_info[index][3:]==list_per_ans[1:]:
            perans+=int(qu_info[index][0])
            #pass
        else:
            max_list[index]+=1
    print(perans)
max_count=max(max_list)
if max_count!=0:
    
    print(max_count,end='')
    for i in range(len(max_list)):
        if max_list[i]==max_count:
            print(' {}'.format(i+1),end='')

    print()
else:
    print("Too simple")

python对于素数测试超时问题难以解决,C语言竞赛1059

num=int(input())
list_id=[]
for _ in range(num):
    list_id.append(input())
index_prime=[True]*10005
index_prime[0],index_prime[1]=False,False
index_prime[2]=True
for i in range(2,10001):
    if index_prime[i]:
        for j in range(2,10000//i+1):
            index_prime[i*j]=False
num_k=int(input())
had_seach=[]
for _ in range(num_k):
    id_=input()
    
    if id_ in list_id:
        if id_ in had_seach:
            print("{}: Checked".format(id_))
        else:
            had_seach.append(id_)
            if id_==list_id[0]:
                print("{}: Mystery Award".format(id_))
            elif index_prime[list_id.index(id_)+1]:
                print("{}: Minion".format(id_))
            else:
                print("{}: Chocolate".format(id_))
    else:
        print("{}: Are you kidding?".format(id_))

1060 更换思路

设置两个变量，一个在前面走试探是否前n天的历程都超过n，后一个变量在后面是满足题意得天数
排序，前大后小，天数在循环里累计，直至试探的变量不再满足，该天的里程小于该天的天数

或者直接使用一个（后者）变量V，再判断是否

里程[V]（前v+1个最小的里数）>V+1（天数）

input()
list_distance=list(map(int,input().split()))
list_distance=sorted(list_distance,reverse=True)
ans=0
while ansans+1:
    ans+=1
print(ans)

最简分数必使用辗转相除法，在使用辗转相除法时不必进行大小比较，因为计算机程序可以在大小不合适时调换位置,此时严格按照辗转相除法的公式来做

辗转相除法

1062

坑1两个分数需要判断一下谁大谁小

坑儿，直接从最小值最大值哪里不太好处理，可以从1开始变量，首先看是否越过上届，再看是否再下届之上

a,b,c = input().split()
n1, m1 = map(float, a.split('/'))
n2, m2 = map(float, b.split('/'))
c = int(c)
x, y = n1/m1, n2/m2
min_, max_ = min(x, y), max(x, y)
 
def judge(a,b):
    if a%b==0:
        return b
    else:
        return judge(b,a%b)
 
f = 0
for i in range(1,c):
    val = float(i) / c
    if val >= max_:
        break
    if val > min_:
        if judge(i,c)!=1:
            continue
        if f == 0:
            print("%d/%d" % (i,c), end="")
            f = 1
        else:
            print(" %d/%d" % (i,c), end="")

1065单身狗 数据结构选择与python语法学习

选择数据结构为dict映射，同时检查是否键与值都在输入中，如果有都remove掉

set的检查是否存在 相比list更快

num=int(input())
#per1,per2=[],[]
#list_sing=[False]*(num+5)
dict_pair={}
for _ in range(num):
    a,b=input().split()
    dict_pair[a]=b
#allper=per1+per2
#list_ans=[]
input()
listkey=dict_pair.keys()
test_list=input().split()
set_test=set(test_list)
for item in set_test:
    if item in listkey and dict_pair[item] in set_test:
        test_list.remove(item)
        test_list.remove(dict_pair[item])
test_list=sorted(test_list)
len_=len(test_list)
print(len_)
if len_:
    print(' '.join(test_list))

如果样例能运行过，应该代码没有语法问题，应该想想有无逻辑问题

例如跑神导致某逻辑分支，出了大问题

1066 图像过滤 (15 分)

a,_,c,d,e=input().split()
a,c,d=int(a),int(c),int(d)
for _ in range(a):
    list_=list(map(int,input().split()))
    ans_=''
    for i in list_:
        if c<=i<=d:
            ans_+=" {:0>3}".format(e)
        else:
            ans_+=" {:0>3}".format(i)
    #ans_=
    print(ans_.strip(' '))

1067 python的无规定读入问题，换个逻辑使其避免使用输入，或者判断读入数据，而不是使用类似于scanf的返回值EOF

跑神出了大问题2,非零返回另一个问题是输入的执行条数大于实际提供输入

right_ans,num=input().split()
num=int(num)
flag=True
for i in range(num):
    str_=input()
    if str_==right_ans:
        print("Welcome in")
        break
    elif str_=='#':
        break
    elif i==num-1:
        print("Wrong password: {}".format(str_))
        print("Account locked")
    else:
        print("Wrong password: {}".format(str_))

1070 结绳 (25 分)

如何划分对折的绳子问题

#搜索？没有动态规划，单纯的一个数学问题
#遇到问题先想有没有数学性质，一个一个的加进去，最长的应该收到最少的/2影响
n=int(input())
list_length=list(map(int,input().split()))
list_length=sorted(list_length)
ans=list_length[0]/2+list_length[1]/2
for i in list_length[2:]:
    ans=ans/2+i/2
print(int(ans))

对python而言 在不加括号时候, and优先级大于or

1071 小赌怡情 (15 分)

收获一：在写if else一定要先区分，分支是等价的分支，还是有优先级的分支

一般而言需要退出的优先级最高，写在最前面，什么时候退出一定要审清题意

money,num=map(int,input().split())
for i in range(num):
    n1,b,t,n2=map(int,input().split())
    if t>money:
        print("Not enough tokens.  Total = {}.".format(money))
    else:
        if b==1 and n2>n1 or b==0 and n2