PTA 第六章算法题汇总

7-1 输入列表，求列表元素和(eval输入应用） (10分)

在一行中输入列表，输出列表元素的和。

str1 = eval(input())
print(sum([i for i in str1]))

7-2 一帮一 (15分)

“一帮一学习小组”是中小学中常见的学习组织方式，老师把学习成绩靠前的学生跟学习成绩靠后的学生排在一组。本题就请你编写程序帮助老师自动完成这个分配工作，即在得到全班学生的排名后，在当前尚未分组的学生中，将名次最靠前的学生与名次最靠后的异性学生分为一组。

输入格式：

输入第一行给出正偶数N（≤50），即全班学生的人数。此后N行，按照名次从高到低的顺序给出每个学生的性别（0代表女生，1代表男生）和姓名（不超过8个英文字母的非空字符串），其间以1个空格分隔。这里保证本班男女比例是1:1，并且没有并列名次。

输出格式：

每行输出一组两个学生的姓名，其间以1个空格分隔。名次高的学生在前，名次低的学生在后。小组的输出顺序按照前面学生的名次从高到低排列。

n = int(input())
group = [
    [],
    [],
]
# [
#     ["Amy", "Cindy", "Maya", "Linda"],
#     ["Tom", "Bill", "John", "Jack"],
# ]
lst = []
for i in range(n):
    gender, name = input().split()
    lst.append((int(gender), name))
    group[int(gender)].append(name)

for i in range(n//2):
    gender = lst[i][0]
    t = group[gender][0]
    print(t, group[int(not gender)].pop())
    group[gender].remove(t)

7-3 验证“哥德巴赫猜想” (20分)

数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。

输入格式：

输入在一行中给出一个(2, 2 000 000 000]范围内的偶数N。

输出格式：

在一行中按照格式“N = p + q”输出N的素数分解，其中p ≤ q均为素数。又因为这样的分解不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。

'''
def sushu(a):
    for i in range(2, int(a ** 0.5) + 1):
        if a % i == 0:
            return False
    return True


n = int(input())
for j in range(2, n):
    if sushu(j) and sushu(n - j):
        print('{} = {} + {}'.format(n, j, n - j))
        break
'''

'''
import math

def f1(x):
    flag = 0
    for i in range(3, int(math.sqrt(x)) + 1, 2):
        if x % i == 0:
            flag = 1
    if flag == 0:
        return True

def f2(N):
    s = []
    for j in range(3, N // 2 + 1, 2):
        if f1(j) and f1(N - j):
            s.append(j)
            s.append(N - j)
            break
    return s


N = int(input())
if N == 4:
    p = 2
    q = 2
else:
    l = f2(N)
    p = l[0]
    q = l[1]
print('{} = {} + {}'.format(N, p, q))
'''


def prime(p):
    for i in range(2, int(p ** 0.5) + 1):
        if not p % i:
            return False
    return True


def sPrime(N):
    for s in range(2, N):
        if prime(s) and prime(N - s):
            return s

N = int(input())
n = sPrime(N)
print("{} = {} + {}".format(N, n, N - n))

7-4 列表或元组的数字元素求和 (20分)

求列表中数字和,列表中嵌套层次不限2层

输入格式:

在一行中输入列表或元组

输出格式:

在一行中输出数字的和

'''
def nested_sum(ls):
    sum = 0
    for item in ls:
        if isinstance(item, (tuple, list)):
            sum += nested_sum(item)
        elif isinstance(item, int):
            sum += item
    return sum


x = eval(input())
y = nested_sum(x)
print(y)
'''
a=eval(input())
s=0
for i in range(len(a)):
    if type(a[i])==int:
        s=s+a[i]
    elif type(a[i])==tuple or type(a[i])==list:
        s=s+sum(a[i])
    else:
        continue
print(s)

7-5 列表数字元素加权和(1) (40分)

输入一个嵌套列表，嵌套层次不限，根据层次，求列表元素的加权和。第一层每个元素 的值为：元素值*1，第二层每个元素的值为：元素值*2，第三层每个元素的值为：元素值*3， ...,以此类推！

'''
def lst(l,deep):
    sum=0
    for i in l:
        if isinstance(i,int):
            sum+=i*deep
        elif isinstance(i,list):
            sum+=lst(i,deep+1)
    return sum

l= eval(input())
print(lst(l,1))
'''


'''
s = input()
q = 0
all = 0
a = 0
# print(len(s))
for i in range(len(s)):
    if s[i] == "[":
        q += 1
    elif s[i] == "]":
        if "0" <= s[i - 1] <= "9":
            all += q * a
            a = 0
        q = q - 1
    elif s[i] == ",":
        all += q * a
        a = 0
    if "0" <= s[i] <= "9":
        a = a * 10 + int(s[i])
print(int(all))
'''
b = eval(input())

'''
def hos(k, j):
    h = 0
    if type(k) == int:
        k = k * j
        return k
    elif type(k) == list:
        j = j + 1
        for i in k:
            h = h + hos(i, j)
        return h

print(hos(b, 0))
'''


def f(l,a):
    while a != 0:
        s = 0
        a = a-1
        for i in l:
            if type(i) == int:
                s = s + 1
        for i in l:
            if type(i) == list:
                l = i
    return s
l = eval(input())
n = int(input())
print(f(l,n))

7-6 列表元素个数的加权和(1) (40分)

输入一个嵌套列表，嵌套层次不限，根据层次，求列表元素的加权个数和。第一层每个元素算一个元素，第二层每个元素算2个元素，第三层每个元素算3个元素，第四层每个元素算4个元素,...,以此类推！

def f(l,deep):
    sum=0
    for i in l:
        if isinstance(i,int):
            sum+=1*deep
        elif isinstance(i,list):
            sum+=f(i,deep+1)
    return sum
l=eval(input())
print(f(l,1))

7-7 求指定层的元素个数 (40分)

输入一个嵌套列表，再输入层数，求该层的数字元素个数。

'''
def f(l,deep,num):
    sum=0
    for i in l:
        if isinstance(i,int) and deep==num:
                sum+=1
        if isinstance(i,list):
            sum+=f(i,deep+1,num)
    return sum
l=eval(input())
num=int(input())
print(f(l,1,num))
'''

def f(l,a):
    while a != 0:
        s = 0
        a = a-1
        for i in l:
            if type(i) == int:
                s = s + 1
        for i in l:
            if type(i) == list:
                l = i
                break
    return s
l = eval(input())
n = int(input())
print(f(l,n))

7-8 *输出全排列（选作） (20分)

输入整数n（3<=n<=7）,编写程序输出1,2,...,n整数的全排列，按字典序输出。

#需要调用random函数中的shuffle()函数;
#str()将其强转为string类型的数据;
import random
n = int(input())
t = []
sum = 1
#计算n！的值;
for i in range(1,n+1):
    sum = sum * i
    t.append(str(i))
#set()集合存储的元素有序不重复;
s = set()
#set集合中元素是以','进行分割的;


#切记：此处一定不可以用for循环来写，因为临时变量i会随着每一个次的循环累加一个;
while len(s)<sum:
    random.shuffle(t)
    #因为join()接收的参数对象是string类型的，故需要将集合中的
    #''.join(t)作用就是将集合t中的元素进行连接，然后add添加到set集合s当中;
    s.add("".join(t))
#sorted函数作用就是将set集合中的s进行升序排列，然后将其赋值给原来的set集合s当中;
s = sorted(s)
for i in range(0,len(s)):
    print(s[i])
exit(0)