Python编程题汇总

找出列表中单词最长的一个

def test():
    a = ["hello", "world", "yoyo", "congratulations"]

    length = len(a[0])

    for i in a:
        if len(i) > length:
            length = i
        return length
print(test())

C = float(input())
F = (C * 1.8) + 32
print(F)
print("{:.1}".format(F))
print('%0.1f' % (F))

x = int(input())
sum = 0
while (x):
    a = x% 10
    sum = sum + a
    x=x//10
print(sum)

一年365天，以第1天的能力值为基数，记为1.0。当好好学习时，能力值相比前一天提高N‰；
当没有学习时，由于遗忘等原因能力值相比前一天下降N‰。每天努力或放任，一年下来的能力值相差多少呢？N可以是小数。
获得用户输入N，计算每天努力和每天放任365天后的能力值及能力间比值，
其中，能力值保留小数点后2位，能力间比值输出整数（小数部分，4舍5入原则），输出结果间采用 英文逗号分隔。
此题目是IPO题，使用input()获得N。
输入案例：1
输出结果：1.44,0.69,2

N= int(input())

原有基础上下降
d=1
d=d*((1-N/1000))**(365)
s=1
s=s*((1+N/1000))**(365)

print("{:.2f} {:.2f}".format(d,s))
bz=s/d
print("{:.0f}".format(bz))

a,b,c=input().split('')
a=int(a)
b=int(b)
c=int(c)

from math import sqrt

a,b,c=input().split(' ')
a=int(a)
b=int(b)
c=int(c)
s=(a+b+c)/2
S=sqrt(s*(s-a)*(s-b)*(s-c))
print("{:.3f}".format(S))

2，数据类型2（字符串）

从键盘输入一个字符串，把字符中的所有大写字母转换为小写，然后对字符串中偶数位置的数据进行逆序输出

str = input()
str2 = str.lower()
even = []
L = list(str2)

for i in range(len(str2)):
    if i % 2 == 0:
      even.append(str2[i])
print(even[::-1])
print(''.join(even[::-1]))

s1 = '''All that doth flow we cannot liquid name

Or else would fire and water be the same;

But that is liquid which is moist and wet

Fire that property can never get.

Then 'tis not cold that doth the fire put out

But 'tis the wet that makes it die, no doubt.'''
x1 = len(s1)    #统计总的字符串个数
x2 = s1.find("the")    #第一次单词the的位置（偏移量）
x3 = s1.rfind("the")   #最后一次出现单词the的位置（偏移量）。
x4 = s1.count("the")
x5 = s1.isalpha()
x6 = s1.isdigit()
print(x1)
print(x2)
print(x3)
print(x4)
print(x5)
print(x6)
#统计字符串的个数字符串相关内置函数的使用

输入一个人民币的整数值（100以内以元为单位），编程找到用10元、5元、2元、1元表示的总数量的最小组合方式。

x=int(input())
a=x//10
a1=x%10
b=a1//5
b1=a1%5
c=b1//2
c1=b1%2
d=c1//1
print("{},{},{},{}".format(a,b,c,d))

3,组合数据类型

a, b = input().split(' ')
a = int(a)
b = int(b)

L=[]
for i in range(a,b+1):

    L.append(i)
print(L[::2])
print(len(L[::-2]))

从键盘输入n个用逗号分隔的整数，计算输出所有数据之和。

根据map函数

map函数还可以用来进行类型转换

>>> list(map(int, (1, 2, 3)))
返回值：[1, 2, 3]

将字符串转换为列表
>>> list(map(int,'1234'))
返回值：[1, 2, 3, 4]

（4）可以提取字典中的key
>>> list(map(int,{'1':2,'2':3,'3':4}))
返回值：[1, 2, 3]

x=list(map(int, input().split(",")))
print(sum(x))

合并的方式是：将a的十位和个位数依次放在结果的十位和千位上， b的十位和个位数依次放在结果的个位和百位上。
例如，当a＝45，b=12。调用该函数后，返回5241

a, b = (int(x) for x in input().split(' '))
A = a // 10
B = a % 10
C = b // 10
D = b % 10
ret = B * 1000 + D * 100 + A * 10 + C
print(ret)

【问题描述】从键盘输入n个字符(逗号分隔)。对n个字符合并为一个字符串s1，把s1字符串中小写字母转大写字母，s1转换为列表L1。输出s1和L1
【样例输入】a,b,c,1,2,3,D,E,F
【样例输出】
#
ABC123DEF
#
['A', 'B', 'C', '1', '2', '3', 'D', 'E', 'F']
#
【样例说明】结果分两行输出，第一行为s1，第二行为L1。
x = input().split(',')
x = ''.join(x)
up = x.upper()
print(up)
print(list(up))x=input().split(',')
x=''.join(x)
up=x.upper()
print(up)
L1=list(x)
print(L1)

L1 = list(input().split(','))
L2 = list(input().split(','))
L1与L2的长度相同
n = len(L1)
d = dict(zip(L1, L2))
x = int(input())
x是作为一个下标的值
if(x

【问题描述】由键盘输入一个整数n，以此n为种子产生3个（1,100）间的随机数，输出三个随机数。
【输入形式】1

【输出形式】18 18 18

结果说明：1为random库种子，18为随机值

import random
n = int(input())
random.seed(n)
print(random.randint(1, 100), end=' ')
random.seed(n)
print(random.randint(1, 100), end=' ')
random.seed(n)
print(random.randint(1, 100), end=' ')

【问题描述】从键盘分两行输入整形数据列表L1和L2，列表元素间用空格分隔。

​ 连接列表L1和L2生成新的列表L3，在L3的末尾添加一个整形数据123，删除L3中的第一个数据，输出最后的L3列表。
【输入形式】

1 2 3

4 5 6 7

【输出形式】

[2,3,4,5,6,7,123]

生成随机数
L1=(input().split(' '))
L2=(input().split(' '))
L3=[]
for i in L1:
    L3.append(int(i))   #如果不转化的话。就是字符类型，磨人的
for i in L2:
    L3.append(int(i))
L3.append(123)
L3.pop(0)
print(L3)

【问题描述】 从键盘输入一个n位正整数，然后反向输出对应的数。假设输入的数据是正确的。
【输入样例】356
【输出样例】653

提示：如果输入时100，输出为001

s =input()
s1=s[::-1]
list(s1)
print(''.join(s1))

4，选择结构

【问题描述】
回文是正读和倒读都一样的句子。读入一个最大长度不超过50个字符的句子，判断其是否是回文。
【输入形式】
输入一个最大长度不超过50个字符的句子
【输出形式】
Yes/No
【输入样例】
abcba
【输出样例】
Yes

a=input() #输入字符串
b = a[::-1]
if a==b:
    print("Yes")
else:
    print("No")

【问题描述】编写一个程序，将输入的三个数从小到大排列出来。
【输入形式】用户在第一行输入三个数字，每个数字用空格分开。
【输出形式】程序在下一行按照从小到大的顺序将三个数字输出出来，每个数字也用空格分开。 要求程序可以处理整数和浮点数两种输入情况的比较。
【样例输入】2.4 5.6 1.5
【样例输出】1.5#2.4#5.6 #表示空格（要求输出时输出空格，而不是输出#，这里#只是表示空格而已！）
【样例说明】输入3个数字，每个数字之间用空格分开，并且进行从小到大排列，最后进行输出。这里的数字可以是整数，也可以是浮点数。

list1 = input().split()
list1 = [2, 3, 4, 5, 86, 0]
list2 = []
list3 = []
for i in list1:
    if isinstance(eval(list1[0]), int):
        list2.append(int(i))
    else:
        list3.append(float(i))
if list2>=3:
    list2.sort()
    print(list2[0], list2[1], list2[2])
else:
    list3.sort()
    print(list3[0], list3[1], list3[2])

自己重写的算法

y=list(map(float,input().split()))
x.sort()
print(x[0],x[1],x[2])
y.sort()
print(y[0],y[1],y[2])
#判断类型最好不要这样

【问题描述】编写一个程序，用户输入出生日期和当前日期，计算出实际年龄。
【输入形式】用户在第一行输入出生日期，在第二行输入当前日期。日期格式为年.月.日，即中间用.分割。
【输出形式】程序在下一行输出实际年龄。
【样例输入】
1964.2.19
2001.7.21
【样例输出】37
【样例说明】用户第一次输入的日期为出生日期，回车表示本次输入结束。第二次输入的为当前日期，回车表示本次输入结束。系统返回实际年龄

编程提示：

实际年龄为周岁，有如下情况

（1）当前日期为生日后，实际年龄= 当前（年）-生日（年）

（2）当前日期在生日前，实际年龄=当前（年）-生日（年）-1

注意：生日的比较，包含 月和日的比较

a = input()
b = input()
age=0
list1=list(a.split('.'))
list2=list(b.split('.'))
if int(list1[1]>list2[2]): #说明在生日前。直接年用来减就可以了
    age=int(list2[0])-int(list1[0])-1
elif int(list1[1]) == int(list2[1]) and int(list1[2]) > int(list2[2]):
    age = int(list2[0]) - int(list1[0])-1
else:
    age = int(list2[0]) - int(list1[0])
print(age)

【问题描述】编写一个程序，输出当前时间的下一秒。
【输入形式】用户在第一行按照小时:分钟:秒的格式输入一个时间。
【输出形式】程序在下一行输出这个时间的下一秒。
【样例输入】23:59:59
【样例输出】0:0:0
【样例说明】用户按照格式输入时间，程序输出此时间的下一秒。

【问题描述】编写一个程序，输出当前时间的下一秒。
【输入形式】用户在第一行按照小时:分钟:秒的格式输入一个时间。
【输出形式】程序在下一行输出这个时间的下一秒。
【样例输入】23:59:59
【样例输出】0:0:0
【样例说明】用户按照格式输入时间，程序输出此时间的下一秒。
#输入整数，然后转化成，int类型
h,m,s=input().split(":")
h=int(h)
m=int(m)
s=int(s)
s=s+1
if s==60:
    s=0
    m=m+1
    if m==60:
        m=0
        h=h+1
        if h==24:
            h=0
print("{}:{}:{}".format(h,m,s))

编程实现简易的计算器：读入两个整数运算数(data1和data2)及一个运算符(op)，

计算表达式data1 op data2的值，其中op可以是+,-,*,/。

【输入形式】

键盘输入运算数和运算符:
1.首先输入以空格分隔的两个整数，分别是data1和data2；
2.输入一个字符作为运算符op，op可以是+,-,*,/中的一个;。
输入时，data1、data2、op之间各留有一个空格。具体格式见样例输入。

x, y, z = input().split()
x=int(x)
y=int(y)
if z=='+':
    print("{}".format(x+y))
elif z=='-':
    print("{}".format(x - y))
elif z=='*':
    print("{}".format(x * y))
elif z=='/':
    print("{:.2f}".format(float(x) /float(y)))

【问题描述】普通时钟都有时针和分针，在任意时刻时针和分针都有一个夹角，并且假设时针和分针都是连续移动的。

​ 现已知当前的时刻，试求出该时刻时针和分针的夹角A（0-180度之间）。
​ 注意：当分针处于0分和59分之间时，时针相对于该小时的起始位置也有一个偏移角度。
【输入形式】从标准输入读取一行，是一个24小时制的时间。格式是以冒号（23:59）分隔的两个整数m（0

（1）时针把钟表圆形分隔为12份，每份为360/12=30度。

（2）分针把面板分隔为60份，每份360/60=6度。

（3）时针随分针的运动，把一个小时的各又分解为60份，每份对应分针运行的值。

（4）夹角有两种情况，分针在前或时针在前，但是夹角的范围一定在0-180度之间。

s,f=input().split(":")
s=int(s)
f=int(f)
jd1=s*30+0.5*f-6*f

if jd1>180:
    print ("{:.3f}".format(360-jd1))
else:
    print ("{:.3f}".format(jd1))

a, b = input().split(":")
a = int(a)
b = int(b)
if (a > 12):
    a = a - 12
A = a * 30 - b * 6 + ((b * 6) / 360) * 30

if A < 0:
    A = 0 - A
    if A > 180:
        A = 360 - A
        print("{:.3f}".format(A))
    else:
        print("{:.3f}".format(A))
else:
    if A > 180:
        A = 360 - A
        print("{:.3f}".format(A))
    else:
        print("{:.3f}".format(A))

5，循环结构

编写一个程序，输入一个正整数N(N大于等于100小于等于999)，求出100~N之间的所有水仙花数。所谓 的水仙花数是：如果一个三位数的个位数、十位数、百位数的立方和等于该数自身，就称这个数为水仙花数。 【输入形式】输入一个正整数N。 【输出形式】输出从100到N之间的所有水仙花数，每个数以回车结束。 【样例输入】 400 【样例输出】 153 370 371 【样例说明】输入一个的正整数400，输出为100~400之间的水仙花数153，370，371

N = int(input())
for i in range(100,N+1):
    a = i % 10      #个位怎么求
    b = (i // 10)%10     #十位怎么求
    c = i // 100    #百位怎么求
    if i == (a ** 3 + b ** 3 + c ** 3):
        print(i)

【问题描述】编写一个程序，用户输入若干整数，试找出其中的最大数和最小数。
【输入形式】用户在第一行待输入数据个数，在第二行输入数据。
【输出形式】程序在下一行输出数据的最大值和最小值
【样例输入】
5
89 62 96 74 52
【样例输出】96 52
【样例说明】用户第一次输入的为数据个数，在下一行依次输入数据。输出为5个数中的最大值和最小值，输出时候两个数之间用空格分隔。

n = int(input())
x = list(map(int, input().split()))
x.sort()
print("{} {}".format(x[n-1],x[0]))

【问题描述】分别统计标准输入中字母、数字字符个数。
【输入形式】从标准输入中读取一个字符串，可以包含任意字符。
【输出形式】分别输出字符串中字母(大小写字母都要进行统计)、数字个数，相邻数字之间用一个空格区分，输出末尾没有空格。
【样例输入】C Java -and- C++ are 3 lanuages. 2006-8-24 16:34
【样例输出】20 12
【样例说明】字符串中共有20个字母，12个数字，所以输出20 12

s = input()
count1=0
count2=0
for i in s:
    if (i>='a' and i'z') or ('A'i'Z'):
        count1+=1
    if ("0"i"9"):
        count2+=1
print("{} {}".format(count1,count2))

【问题描述】一个百万富翁碰到一个陌生人,陌生人找他谈了一个换钱的计划.该计划如下:我每天给你10万,而你第一天给我一元钱,第二天我仍给你十万,你给我二元钱,第三天我仍给你十万,你给我四元钱…你每天给我的钱是前一天的两倍,直到满n(0

n=int(input())
a=0
b=100000*n
for i in range(n):
    a=a+2**(i)
print(b)
print(a)

【问题描述】由键盘当输入一个整数n,对它进行判断,当为素数时,输出1.否则,输出0.

【输入形式】控制台输入一个整数.

【输出形式】控制台输出判断结果0或者1.

【样例输入】45
【样例输出】0
【样例说明】45非素数,故输出为0

n=int(input())

flag=1
for i in range(2,n):
    if n%i==0:
        flag=0
print(flag)

def fun(n):
    flag = 1
    for i in range(2, n):
        if n % i == 0:
            flag = 0
    return flag
n=int(input())
print(fun(n))

【问题描述】删除字符串中的重复字符

【输入形式】输入一个字符串，全为字母字符

【输出形式】输出删除重复字符后的字符串

【样例输入】abbcbd

【样例输出】abcd

【样例说明】删除第二个和第三个”b”;，保留第一个遇到的不同字符

编程提示：利用循环读取字符串中每个字符，判断新列表中是否有这个字符，如果没有就添加在列表中，有的话就不添加。最后把列表转换为字符串

s = input()
list=[]
for i in s:
    if i not in list:
         list.append(i)
str2=''.join(list)   #字符串拼接函数
print(str2)

6，函数的基本使用、

【问题描述】所谓”回文数”是指具有如下性质的整数：一个整数，当它的各位数字逆序排列，形成的整数与原整数相同，这样的数称为回文数。

例如，素数11，373，其各位数字对换位置后仍然为11，373，因此这两个整数均为回文数。

编写函数loop(x)，判断一个整数是否为回文数，如果x是回文数则返回1，否则返回0。

编写程序，接收控制台输入的两个整数a，b。调用loop函数输出a到b之间（包括a和b）的所有回文数
【输入形式】控制台输入两个整数a和b（必有a

【样例说明】输入整数a=3，b=120，要求输出所有[3, 120]之间的回文数。按升序分行输出所有符合题意的整数

def loop():
    a, b = input().split()
    a = int(a)
    b = int(b)
    for i in range(a, b + 1):
        s = str(i)
        if s == s[::-1]:
            print(i)
loop()

#函数求阶乘 n! 不用递归的方式
def fac(n):
    f=1
    for i in range(1,n+1):
        f=f*i
    return f
n = int(input())
print(fac(n))

#什么叫递归
#去调用函数本身，下面这种叫递归法
def fac(n):
    if n

【问题描述】有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子。假如兔子都不死，计算第n（n>=3）个月兔子的总数？

【样例输入】6

【样例输出】8

【问题分析】按月计算兔子的对数为，1,1,2,3,5,8,13,21,34…

可以运用递归来解决问题。如果当出生后第三个月开始生兔子： F(N) = f(n-1)+ f(n-2)

n个月就会生的全宇宙都是兔子。。。

#递归实现的
def f(n):
    if (n==1 or n==2):
        return 1
    else:
        return f(n-1)+f(n-2)
n=int(input())
print(f(n))

month = int(input())
if month == 1 or month == 2:
    print(1)
else:
    a = 1
    b = 1
    c = 0
    for i in range(3, month + 1):
        c=a+b
        a = b
        b = c
    print(c)

【问题描述】用公式π/4≈1-1/3+1/5-1/7+…1/(2*N-1).求圆周率PI的近似值。 从键盘输入一个整数N值，利用上述公式计算出π的近似值，然后输出π值，保留小数后8位。【样例输入】1000 【样例输出】3.14059265

Original: https://blog.csdn.net/Closer9/article/details/124288372
Author: Closer9
Title: Python编程题汇总