python函数题

读取若干个点，每个点放入元组。并将所有点的点信息、点的类型、点与原点的距离打印出来。

函数接口定义：

readPoint() #从一行以,分隔的数中读取坐标，放入元组并返回
distance(point) #计算point与原点的距离并返回，要math库中的函数

裁判测试程序样例：

/* 请在这里填写答案 */
n = int(input())
for i in range(n):
    p = readPoint()
    print(‘Point = {}, type = {}, distance = {:.3f}‘.format(p,type(p),distance(p)))

输入格式:

输入n，代表底下要输入n行点坐标。坐标全部为整数。
点坐标x,y,z以,分隔。坐标全部为整数。

注意：坐标以,分隔，相应位置可能无字符或者包含多个空格字符，读入时按照0进行处理。

输出格式:

见输出样例

输入样例:

5
1,1,1
,,
2,,1
3,1,3
5,,

输出样例:

Point = (1, 1, 1), type = <class ‘tuple‘>, distance = 1.732
Point = (0, 0, 0), type = <class ‘tuple‘>, distance = 0.000
Point = (2, 0, 1), type = <class ‘tuple‘>, distance = 2.236
Point = (3, 1, 3), type = <class ‘tuple‘>, distance = 4.359
Point = (5, 0, 0), type = <class ‘tuple‘>, distance = 5.000

在上题(1.计算坐标点欧氏距离)的基础上。将每个点根据距离原点的远近分成两类，一类是小于r的点，一类是大于等于r的点。

步骤如下：

1. 调用ClassifyPoints(points, r)函数根据输入的半径r进行分类，将所有<r的点放入a列表，>=r的点放入b列表。然后将a,b列表以元组的方式返回赋值给pointsTuple。
2. 将pointsTuple直接输出。
3. 调用printPointsTuple(pointsTuple, r)，将<r与>=r的点集合分情况输出，输出还需包含每个点集的平均距离。

函数接口定义：

readPoint() #从一行以,分隔的数中读取坐标，放入元组并返回。如果相应位置无数据，按0处理。
distance(point) #计算point与原点的距离并返回，要math库中的函数
ClassifyPoints(points, r): #根据r将points中的点分成两类放入两个列表，距离小于r与大于等于r。然后将两个列表以元组的形式返回
avgDistance(pointList): #计算列表pointList中的所有点到原点的平均距离，可利用distance(p)函数
printPointsTuple(psTuple, r): #将元组psTuple中的数据按照输出样例格式输出。输出顺序由psTuple中点列表的顺序决定。

裁判测试程序样例：

/* 请在这里填写答案 */
n = int(input())
r = int(input())
points = []
for i in range(n):
    p = readPoint()
    points.append(p)
    print(‘Point = {}, type = {}, distance = {:.3f}‘.format(p,type(p),distance(p)))

pointsTuple = ClassifyPoints(points, r)
print("pointsTuple = {}".format(pointsTuple))
printPointsTuple(pointsTuple,r)

输入格式:

输入n，代表底下要输入n行点坐标。点坐标x,y,z以,分隔。坐标全部为整数。
输入r， 代表要以r作为分类依据。

注意：坐标以,分隔，相应位置可能无字符或者包含多个空格字符，读入时按照0进行处理。

输出格式:

见输出样例。注意：= < >=两侧均有一个空格，,后面要有一个空格。
printPointsTuple中计算的平均距离保留3位小数。输出顺序由psTuple中点列表的顺序决定。

输入样例:

5
5
1,1,1
,,
2,3,5
3,1,3
5,,

输出样例:

Point = (1, 1, 1), type = <class ‘tuple‘>, distance = 1.732
Point = (0, 0, 0), type = <class ‘tuple‘>, distance = 0.000
Point = (2, 3, 5), type = <class ‘tuple‘>, distance = 6.164
Point = (3, 1, 3), type = <class ‘tuple‘>, distance = 4.359
Point = (5, 0, 0), type = <class ‘tuple‘>, distance = 5.000
pointsTuple = ([(1, 1, 1), (0, 0, 0), (3, 1, 3)], [(2, 3, 5), (5, 0, 0)])
distance < 5, avgDistance = 2.030, points = [(1, 1, 1), (0, 0, 0), (3, 1, 3)]
distance >= 5, avgDistance = 5.582, points = [(2, 3, 5), (5, 0, 0)]

随机生成n个点并存入字典，每个点的坐标为(x, y)，坐标x、y的取值范围是[0,10]之间的整数。
随机生成点的过程中可能会产生重复的点(两个点的坐标值一样)，需记录该点生成的次数，如在
整个生成点的过程中生成了3个坐标为(2，1)的点，那么需将3作为点生成次数纪录下来。
最后在字典中查询3次点坐标，并返回查询结果。

建议：使用字典存储点。
思考:如何在此基础上使用蒙特卡洛方法计算圆周率。

步骤如下： 输入n代表要产生n个点
输入x代表随机数种子（注意：设置种子前需将x转化为整型）

1. 调用generatePoint(n)函数生成n个点，每个点包含x,y坐标，将(x,y)存为元组，然后将该元组作为元素放入列表(可放重复的点坐标)，并将该列表返回。
2. 调用createPointDict(pList)将步骤1生成的点列表pList中的每个点放入字典pDict中，字典的键为点(元组)，值为出现次数。
3. 调用doQuery(pDict, p): 在pDict中查询p，如果查到则输出点即出现次数，否则输出Not Found。

注意：需要导入random库

函数接口定义：

generatePoints(n) #产生n个2维坐标点放入列表并返回该列表
createPointDict(pList) #将pList中的节点加入字典并统计出现次数，然后返回字典
doQuery(pDict, p) #在pDict中查询p，如果查到则输出该点及其出现次数，否则输出‘Not Found‘。

裁判测试程序样例：

/* 请在这里填写答案 */
n = int(input())  
seed(int(input()))
pList = generatePoints(n)
pDict = createPointDict(pList)
for i in range(3):#查询3次
    x, y = [int(e) for e in input().split(‘,‘)]
    doQuery(pDict, (x, y))

输入格式:

输入的n代表产生n个坐标点
输入x代表种子(x需转化为整型)
若干个行所要查找的坐标。

输出格式:

如果存在，输出 二维坐标点 = 出现次数。注：二维坐标点以元组形式出现。
否则输出Not Found

输入样例:

10000
1
2,9
99,100
1,7

输出样例:

(2, 9) = 87
Not Found
(1, 7) = 75

本题要求实现一个函数，判断参数是否是质数，是的话返回True，否则返回False

注意：函数中要有异常处理，如果参数不是整数，返回False

函数接口定义：

def isPrime(num)

裁判测试程序样例：

/* 请在这里填写答案 */
num=input()
if isPrime(num):
    print(‘yes‘)
else:
    print(‘no‘)

输入样例1：

ab

输出样例1：

no

输入样例2：

1.1

输出样例2：

no

输入样例3：

11

输出样例3：

yes

def isPrime(num):
    try:
        num=int(num)
        for i in range(2,num):
            if num%i==0:
                return False
        return True
    except:
        return False
num=input()
if isPrime(num):
    print(‘yes‘)
else:
    print(‘no‘)

giveChange(money) #money代表要找的钱，为整数。该函数经过计算，然后按照格式"要找的钱 = x*10 + y*5 + z*1"直接输出。

/* 请在这里填写答案 */
n =  int(input())
for i in range(n):
    giveChange(int(input()))

5
109
17
10
3
0

109 = 10*10 + 1*5 + 4*1
17 = 1*10 + 1*5 + 2*1
10 = 1*10 + 0*5 + 0*1
3 = 0*10 + 0*5 + 3*1
0 = 0*10 + 0*5 + 0*1

def giveChange(a):
    a10, a5, a1 =  0, 0, 0
    a10 = a//10
    a5 = (a%10)//5
    a1 = (a%10)%5
    print("{} = {}*10 + {}*5 + {}*1".format(a, a10, a5, a1))
    

printYanghui(n):#打印n行杨辉三角型

/* 请在这里填写答案 */
n = int(input())        
printYanghui(n)

5

    1 
   1 1 
  1 2 1 
 1 3 3 1 
1 4 6 4 1 

def printYanghui(n):
    num=[]
    for i in range(n+1):
        num+=[[]]
        for j in range(n+1):
            num[i]+=[0]
    num[1][1]=1
    for i in range(2,n+1):
        for j in range(1,n+1):
            num[i][j]=num[i-1][j]+num[i-1][j-1]
    for i in range(1,n+1):
        for k in range(n-i):
            print("",end=‘ ‘)
        for j in range(1,i+1):
            print(num[i][j],end=‘ ‘)
        print()



n = int(input())        
printYanghui(n)

Freq(line) 

/* 请在这里填写答案 */
line = input()
Freq(line)

abc 123 adex!!!

11
  = 2
! = 3
1 = 1
2 = 1
3 = 1
a = 2
b = 1
c = 1
d = 1
e = 1
x = 1

def Freq(line):
    words=line
    s={}
    for i in words:
        if i in s:
            s[i]+=1
        else:
            s[i]=1
    s=list(s.items())
    print(len(s))
    s.sort(key=lambda x:x[0])
    for i in range(len(s)):
        word,count=s[i]
        print("{} = {}".format(word,count))

line = input()
Freq(line)

fn(a,n)
其中 a 和 n 都是用户传入的参数。 a 的值在[1, 9]范围；n 是[1, 9]区间内的个位数。函数须返回级数和

/* 请在这里填写答案 */
		 
a,b=input().split()
s=fn(int(a),int(b))
print(s)

2 3

246

def fn(a,n):
    sum=0
    for i in range(1,n+1):
        c=a
        for j in range(0,i-1):
            c=a+c*10
        sum=sum+c
    return sum

在这里描述函数接口：
prime(p)，返回True表示p是素数，返回False表示p不是素数
PrimeSum(m,n)，函数返回素数和

/* 请在这里填写答案 */

m,n=input().split()
m=int(m)
n=int(n)
print(PrimeSum(m,n))

1 10

17

def prime(p):
    if p<=1:
        return False
    for i in range(2,p):
        if p%i==0:
            return False
    return True

def PrimeSum(m,n):
    sum=0
    for i in range(m,n+1):
        if prime(i):
            sum+=i
    return sum

在这里描述函数接口。例如：
CountDigit(number,digit ),返回digit出现的次数

/* 请在这里填写答案 */

number,digit=input().split()
number=int(number)
digit=int(digit)
count=CountDigit(number,digit )
print("Number of digit 2 in "+str(number)+":",count)

-21252 2

Number of digit 2 in -21252: 3

def CountDigit(number,digit ):
    count=0
    if number<0:
        number=-number
    while number>0:
        i=number%10
        if i==digit:
            count+=1
        number//=10
    return count

函数接口:
funcos(eps,x ),返回cos(x)的值。

在这里给出函数被调用进行测试的例子。例如：


/* 请在这里填写答案 */

eps=float(input())
x=float(input())
value=funcos(eps,x )
print("cos({0}) = {1:.4f}".format(x,value))

0.0001
-3.1

cos(-3.1) = -0.9991

def funcos(eps,x ):
    sum=0
    i=0
    count=0
    while True:
        c=1
        for j in range(1,2*i+1):
            c=c*j
        if ((x**(2*i))/c)<eps:
            return sum
            break
        else:
            if count%2==0:
                sum=sum+(x**(2*i))/c
            else:
                sum=sum-(x**(2*i))/c
        i+=1
        count+=1

在这里描述函数接口。例如：
fib(n),返回fib(n)的值
PrintFN(m,n)，用列表返回[m, n]中的所有Fibonacci数。

在这里给出函数被调用进行测试的例子。例如：
/* 请在这里填写答案 */

m,n,i=input().split()
n=int(n)
m=int(m)
i=int(i)
b=fib(i)
print("fib({0}) = {1}".format(i,b))
fiblist=PrintFN(m,n)
print(len(fiblist))

20 100 6

fib(6) = 13
4

def fib(n):
    if n==0 or n==1:
        return 1
    else:
        return fib(n-1)+fib(n-2)

def PrintFN(m,n):
    a=[]
    #for i in range(m,n+1):
    for j in range(26):
        if m<=fib(j)<=n:
            a.append(fib(j))
    #print(a)
    return a

/* 请在这里填写答案 */

x,y =map(int, input().split())
print(primeSum(x,y))

2 8

17

def isPrime(num):
    num=int(num)
    for i in range(2,num):
        if num%i==0 :
            return False
    return True
def primeSum(a,b):
    sum=0
    for i in range(a,b+1):
        if isPrime(i):
            sum+=i
    return sum