【蓝桥杯简单篇】Python组刷题日寄Part03

刷题日记?刷题日寄!
萌新备战蓝桥杯python组
🌹 发现有需要纠正的地方,烦请指正!
🚀 欢迎小伙伴们的三连+关注!

往期系列:
【蓝桥杯简单篇】Python组刷题日寄Part01

【蓝桥杯简单篇】Python组刷题日寄Part02

简单篇03

第01题:DNA

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
小强从小就喜欢生命科学,他总是好奇花草鸟兽从哪里来的。终于, 小强上中学了,接触到了神圣的名词–DNA.它有一个双螺旋的结构。这让一根筋的小强抓破头皮,“要是能画出来就好了” 小强喊道。现在就请你帮助他吧
输入描述:
输入包含多组测试数据。第一个整数N(N<=15),N表示组数,每组数据包含两个整数a,b。a表示一个单位的DNA串的行数,a为奇数且 3<=a<=39。b表示重复度(1<=b<=20)。
输出描述:
输出DNA的形状,每组输出间有一空行。
样例输入:
2
3 1
5 4
样例输出:

X X
 X
X X

X   X
 X X
  X
 X X
X   X
 X X
  X
 X X
X   X
 X X
  X
 X X
X   X
 X X
  X
 X X
X   X

答案:

分析:
对于一个单位的dna串,我们可以先打印其a-1行,重复b-1次,最后打印最后一行

def dna(a):
    # 先创建 (a-1)*a 的二维列表,元素都为 空格' '
    lis = [[' ' for i in range(a)] for j in range(a-1)]
    # 在对应位置赋值'X'
    for i in range(a-1):
        lis[i][i] = 'X'
        lis[i][a-1-i] = 'X'
    # 打印
    for j in lis:
        print(''.join(j))

n = int(input())
A, B = [], []
for i in range(n):
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)

for i in range(n):
    a = A[i]
    b = B[i]
    for j in range(b):
        dna(a)
    print('X' + ' '*(a-2) + 'X\n')

第02题:数的读法

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
Tom教授正在给研究生讲授一门关于基因的课程,有一件事情让他颇为头疼:一条染色体上有成千上万个碱基对,它们从0开始编号,到几百万,几千万,甚至上亿。
比如说,在对学生讲解第1234567009号位置上的碱基时,光看着数字是很难准确的念出来的。
所以,他迫切地需要一个系统,然后当他输入12 3456 7009时,会给出相应的念法:
十二亿三千四百五十六万七千零九
用汉语拼音表示为:
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
这样他只需要照着念就可以了。
你的任务是帮他设计这样一个系统:给定一个阿拉伯数字串,你帮他按照中文读写的规范转为汉语拼音字串,相邻的两个音节用一个空格符格开。
注意必须严格按照规范,比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”,“100000”读作“shi wan”而不是“yi shi wan”,“2000”读作“er qian”而不是“liang qian”。
输入描述:
有一个数字串,数值大小不超过2,000,000,000。
输出描述:
是一个由小写英文字母,逗号和空格组成的字符串,表示该数的英文读法。
样例输入:
1234567009
样例输出:
shi er yi san qian si bai wu shi liu wan qi qian ling jiu


答案:

分析:
见注释

d = {'1':'yi', '2':'er', '3':'san', '4':'si', '5':'wu',
        '6':'liu', '7':'qi', '8':'ba', '9':'jiu', '0':'ling'}
n = input().strip()
a = []
b = []
# 定义函数,读四位数的拼音
def exchange(n):
        # 先将数字逆序
        # b用来存储读法的逆序
        n = n[::-1]
        for i in range(len(n)):
                # 对于第一个(对应原数字最后一个)
                if i==0:
                        # 不为0,则正常读
                        if n[i]!='0':
                                b.append(d[n[i]])
                # 对于第二个(对应原数字倒数第二个)
                elif i==1:
                        # 为0,且前一个不为0
                        if n[i]=='0' and n[0]!='0':
                                # 读 'ling'
                                b.append(d['0'])
                        # 为1,且只有两位,则读 十('shi')
                        elif n[i]=='1' and len(n)==2:
                                b.append('shi')
                        # 不为0,读 几十('shi')
                        elif n[i]!='0':
                                b.append('shi')
                                b.append(d[n[i]])
                # 对于第三个数(对应原数字的第二个数)
                elif i==2:
                        # 为0,且前一个不为0
                        if n[i]=='0' and n[1]!='0':
                                # 读 零('ling')
                                b.append(d['0'])
                        # 不为0,读 几百('bai')
                        elif n[i]!='0':
                                b.append('bai')
                                b.append(d[n[i]])
                # 对于第四个数(对应原数字的第一个数)
                elif i==3:
                        # 为0,且前一个不为0
                        if n[i]=='0' and n[2]!='0':
                                # 读 零('ling')
                                b.append(d['0'])
                        # 不为0,读 几千('qian')
                        elif n[i]!='0':
                                b.append('qian')
                                b.append(d[n[i]])
while n!='':
        # 不为空
        # 四位及以上
        # 最终得到一个列表a,是从个位开始,每四位截取为一个元素
        if len(n)>=4:
                s = n[-4:]      # 取出后四位
                n = n[:-4]      # 删除后四位
                a.append(s)     # 将后四位写入列表a
        else:
                a.append(n)
                n = ''

for i in range(len(a)):
        if i==0:
                # 对于:个、十、百、千位
                exchange(a[i])
        elif i==1:
                # 对于:万、十万、百万、千万位
                b.append('wan')
                exchange(a[i])
        elif i==2:
                # 对于:亿、十亿、百亿、千亿位
                b.append('yi')
                exchange(a[i])

for i in range(len(b)-1, -1, -1):
        # 将列表b逆序输出即可
        # 元素之间要空格
        if i==len(b)-1:
                print(b[i], end='')
        else:
                print(' %s' % b[i], end='')

第03题:Tom数

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
正整数的各位数字之和被Tom称为Tom数。求输入数(<2^32)的Tom数!
输入描述:
每行一个整数(<2^32)。
输出描述:
每行一个输出,对应该数的各位数之和。
样例输入:
12345
56123
82
样例输出:
15
17
10


答案:

分析:

while True:
    try:
        x = input()
        print(sum([int(i) for i in x]))
    except:
        break

第04题:错误票据

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
某涉密单位下发了某种票据,并要在年终全部收回。
每张票据有唯一的ID号。全年所有票据的ID号是连续的,但ID的开始数码是随机选定的。
因为工作人员疏忽,在录入ID号的时候发生了一处错误,造成了某个ID断号,另外一个ID重号。
你的任务是通过编程,找出断号的ID和重号的ID。
假设断号不可能发生在最大和最小号。
输入描述:
要求程序首先输入一个整数N(N< 100)表示后面数据行数。
接着读入N行数据。
每行数据长度不等,是用空格分开的若干个(不大于100个)正整数(不大于100000),请注意行内和行末可能有多余的空格,你的程序需要能处理这些空格。
每个整数代表一个ID号。
输出描述:
要求程序输出1行,含两个整数m n,用空格分隔。
其中,m表示断号ID,n表示重号ID
样例输入:
2
5 6 8 11 9
10 12 9
样例输出:
7 9


答案:

分析:
sort()函数,remove()函数

N = int(input())
L = []
for i in range(N):
    lis = list(map(int, input().split()))
    L.extend(lis)
L.sort()
for i in range(L[0], L[-1]+1):
    if i in L:
        # remove()函数移除某个值的第一个匹配项
        L.remove(i)
        if i in L:
            n = i
    else:
        m = i
print(str(m)+' '+str(n))

第05题:FJ的字符串

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
FJ在沙盘上写了这样一些字符串:
A1 = “A”
A2 = “ABA”
A3 = “ABACABA”
A4 = “ABACABADABACABA”
……
你能找出其中的规律并写所有的数列AN吗?
输入描述:
仅有一个数:N ≤ 26。
输出描述:
请输出相应的字符串AN,以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入:
3
样例输出:
ABACABA


答案:

分析:
ord()函数,chr()函数,递归

def func(n):
    if n==1:
        return 'A'
    else:
        s = chr(ord('A')+n-1)
        return func(n-1)+s+func(n-1)

print(func(int(input())))

第06题:Sine之舞

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
最近FJ为他的奶牛们开设了数学分析课,FJ知道若要学好这门课,必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏,寓教于乐,提高奶牛们的计算能力。
不妨设
A n = s i n ( 1 – s i n ( 2 + s i n ( 3 – s i n ( 4 + . . . s i n ( n ) ) . . . ) An=sin(1–sin(2+sin(3–sin(4+...sin(n))...) An=sin(1sin(2+sin(3sin(4+...sin(n))...)

S n = ( . . . ( A 1 + n ) A 2 + n − 1 ) A 3 + . . . + 2 ) A n + 1 Sn=(...(A1+n)A2+n-1)A3+...+2)An+1 Sn=(...(A1+n)A2+n1)A3+...+2)An+1
FJ想让奶牛们计算Sn的值,请你帮助FJ打印出Sn的完整表达式,以方便奶牛们做题。
输入描述:
仅有一个数:N<201。
输出描述:
请输出相应的表达式Sn,以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入:
3
样例输出:
( ( s i n ( 1 ) + 3 ) s i n ( 1 − s i n ( 2 ) ) + 2 ) s i n ( 1 − s i n ( 2 + s i n ( 3 ) ) ) + 1 ((sin(1)+3)sin(1-sin(2))+2)sin(1-sin(2+sin(3)))+1 ((sin(1)+3)sin(1sin(2))+2)sin(1sin(2+sin(3)))+1


答案:

分析:
找规律:
A 1 = s i n ( 1 ) A1=sin(1) A1=sin(1)
A 2 = s i n ( 1 − s i n ( 2 ) ) A2=sin(1-sin(2)) A2=sin(1sin(2))

def a(n):
    for i in range(1, n+1):
        print('sin(', end='')
        print(i, end='')
        if i!=n:
            if i%2!=0:
                print('-',end='')
            else:
                print('+', end='')
    for i in range(1, n+1):
        print(')', end='')
    return ''

def s(n):
    for i in range(1, n):
        print('(', end='')
    for i in range(1, n+1):
        print(a(i), end='')
        print('+', end='')
        print(n-i+1, end='')
        if i!=n:
            print(')', end='')

s(int(input()))

第07题:分解质因数

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
求出区间[a,b]中所有整数的质因数分解。
提示:
先筛出所有素数,然后再分解。
数据规模和约定
输入描述:
输入两个整数a,b。
2 ≤ a ≤ b ≤ 10000 2\leq a\leq b\leq 10000 2ab10000
输出描述:
每行输出一个数的分解,形如 k = a 1 ∗ a 2 ∗ a 3... k=a1*a2*a3... k=a1a2a3...( a 1 ≤ a 2 ≤ a 3... a1\leq a2\leq a3... a1a2a3... k k k 也是从小到大的)(具体可看样例)
样例输入:
3 10
样例输出:
3 = 3 3=3 3=3
4 = 2 ∗ 2 4=2*2 4=22
5 = 5 5=5 5=5
6 = 2 ∗ 3 6=2*3 6=23
7 = 7 7=7 7=7
8 = 2 ∗ 2 ∗ 2 8=2*2*2 8=222
9 = 3 ∗ 3 9=3*3 9=33
10 = 2 ∗ 5 10=2*5 10=25


答案:

分析:
自定义函数来判断是否是质数;
分解质因数,找最小质因数,再利用递归找到所有质因数。

# 自定义函数来判断是否是质数
def isPrime(n):
    for i in range(2, n//2+1):
        if n%i==0:
            return False
    return True
# 分解质因数
def func(n, nums):
    flag = 1
    for i in range(2, n//2+1):
        if n%i==0 and isPrime(i):
            # 找到了最小的质因数
            nums.append(str(i))
            flag = i
            break
    if flag!=1:
        # 找到最小的质因数flag,再找n//flag的最小质因数
        func(n//flag, nums)
    else:
        # flag=1则说明只有本身是质因数
        nums.append(str(n))

a,b = map(int, input().split())
for i in range(a, b+1):
    nums = []
    func(i, nums)
    print('{}={}'.format(str(i),'*'.join(nums)))

第08题:字符串对比

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间),它们之间的关系是以下4种情况之一:
1:两个字符串长度不等。比如 Beijing 和 Hebei
2:两个字符串不仅长度相等,而且相应位置上的字符完全一致(区分大小写),比如 Beijing 和 Beijing
3:两个字符串长度相等,相应位置上的字符仅在不区分大小写的前提下才能达到完全一致(也就是说,它并不满足情况2)。比如 beijing 和 BEIjing
4:两个字符串长度相等,但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类,给出所属的类的编号。
输入描述:
包括两行,每行都是一个字符串
输出描述:
仅有一个数字,表明这两个字符串的关系编号
样例输入:
BEIjing
beiJing
样例输出:
3


答案:

分析:
lower()函数:将字符串中所有大写字母转换为小写字母。

s1 = input()
s2 = input()
if not len(s1)==len(s2):
    print(1)
elif s1==s2:
    print(2)
elif s1.lower()==s2.lower():
    print(3)
else:
    print(4)

第09题:报时助手

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
给定当前的时间,请用英文的读法将它读出来。
时间用时h和分m表示,在英文的读法中,读一个时间的方法是:
如果m为0,则将时读出来,然后加上“o’clock”,如3:00读作“three o’clock”。
如果m不为0,则将时读出来,然后将分读出来,如5:30读作“five thirty”。
时和分的读法使用的是英文数字的读法,其中0~20读作:
0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。
30读作thirty,40读作forty,50读作fifty。
对于大于20小于60的数字,首先读整十的数,然后再加上个位数。如31首先读30再加1的读法,读作“thirty one”。
按上面的规则21:54读作“twenty one fifty four”,9:07读作“nine seven”,0:15读作“zero fifteen”。
输入描述:
输入包含两个非负整数h和m,表示时间的时和分。非零的数字前没有前导0。h小于24,m小于60。
输出描述:
输出时间时刻的英文。
样例输入:
0 15
样例输出:
zero fifteen


答案:

分析:
见代码注释。

dic1 = {0:'zero', 1:'one', 2:'two', 3:'three', 4:'four', 5:'five', 6:'six',
        7:'seven', 8:'eight', 9:'nine', 10:'ten', 11:'eleven', 12:'twelve',
        13:'thirteen', 14:'fourteen', 15:'fifteen', 16:'sixteen', 17:'seventeen',
        18:'eighteen', 19:'nineteen', 20:'twenty'}
dic2 = {2:'twenty', 3:'thirty', 4:'forty', 5:'fifty'}
L = [int(i) for i in input().split()]
def to_str(n):
        if n<=20:
                # 小于20用dic1
                return dic1[n]
        else:
                # 否则用dic2
                lis = list(str(n))
                s = dic2[int(lis[0])]+' '+dic1[int(lis[1])]
                return s

if L[1]==0:
        # 整点
        print(to_str(L[0])+" o'clock")
else:
        # 非整点
        print(to_str(L[0])+' '+to_str(L[1]))

第10题:龟兔赛跑预测

题目:
时间限制:
1s
内存限制:
128MB
题目描述:
话说这个世界上有各种各样的兔子和乌龟,但是研究发现,所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛,小华对此很感兴趣,于是决定研究不同兔子和乌龟的赛跑。他发现,兔子虽然跑比乌龟快,但它们有众所周知的毛病——骄傲且懒惰,于是在与乌龟的比赛中,一旦任一秒结束后兔子发现自己领先t米或以上,它们就会停下来休息s秒。对于不同的兔子,t,s的数值是不同的,但是所有的乌龟却是一致——它们不到终点决不停止。
然而有些比赛相当漫长,全程观看会耗费大量时间,而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1(表示每秒兔子能跑v1 米),乌龟的速度v2,以及兔子对应的t,s值,以及赛道的长度l——就能预测出比赛的结果。但是小华很懒,不想通过手工计算推测出比赛的结果,于是他找到了你——清华大学计算机系的高才生——请求帮助,请你写一个程序,对于输入的一场比赛的数据v1,v2,t,s,l,预测该场比赛的结果。
输入描述:
输入只有一行,包含用空格隔开的五个正整数v1,v2,t,s,l,其中( v 1 , v 2 ≤ 100 ; t ≤ 300 ; s < ≤ 10 ; l ≤ 10000 且 为 v 1 , v 2 的 公 倍 数 v1,v2\leq 100;t\leq 300;s<\leq 10; l\leq 10000且为v1,v2的公倍数 v1,v2100;t300;s<10;l10000v1,v2)
输出描述:
输出包含两行,第一行输出比赛结果——一个大写字母“T”或“R”或“D”,分别表示乌龟获胜,兔子获胜,或者两者同时到达终点。
第二行输出一个正整数,表示获胜者(或者双方同时)到达终点所耗费的时间(秒数)。
样例输入:
10 5 5 2 20
样例输出:
D
4


答案:

分析:

v1, v2, t, s, l = map(int,input().split())
# 初始化两者路程,以及时间
x1, x2, time = 0, 0, 0
while x1 < l and x2 < l:
    x1 += v1
    x2 += v2
    time += 1
    if (x1-x2) >= t and x1 < l and x2 < l:
        for i in range(s):
            x2 += v2
            time += 1
            if x2 >= l:
                break
if x1 == x2:
    print('D')
elif x1 > x2:
    print('R')
else:
    print('T')
print(time)

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四口鲸鱼爱吃盐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值