标签 pat 下的文章

给定一系列正整数,请按要求对数字进行分类,并输出以下 5 个数字:

A1 = 能被 5 整除的数字中所有偶数的和;
A2 = 将被 5 除后余 1 的数字按给出顺序进行交错求和,即计算 n1−n2+n3−n4⋯;
A3 = 被 5 除后余 2 的数字的个数;
A4 = 被 5 除后余 3 的数字的平均数,精确到小数点后 1 位;
A5 = 被 5 除后余 4 的数字中最大数字。
输入格式:
每个输入包含 1 个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N,随后给出 N 个不超过 1000 的待分类的正整数。数字间以空格分隔。

输出格式:
对给定的 N 个正整数,按题目要求计算 A1~A5
并在一行中顺序输出。数字间以空格分隔,但行末不得有多余空格。

若其中某一类数字不存在,则在相应位置输出 N。

输入样例 1:

13 1 2 3 4 5 6 7 8 9 10 20 16 18

输出样例 1:

30 11 2 9.7 9

输入样例 2:

8 1 2 4 5 6 7 9 16

输出样例 2:

N 11 2 N 9

易错点

  1. 输入的第一个数是有几个数,不计算
  2. A2本身可能为0

    参考答案

    # -*- coding:utf-8 -*-
    s = raw_input()
    s_list = s.split(" ")
    a1=a2=a3=a4=a5=0
    s = -1
    a4_sum = 0
    a4_i = 0.0
    a2_f = False
    n = int(s_list[0])
    s_list = s_list[1:]
    for x in range(0,n):
     i = int(s_list[x])
     if i%10==0:
         a1+=i
     elif i%5==1:
         a2=a2+(-1)*s*i
         s*=-1
         a2_f = True
     elif i%5 ==2:
         a3+=1
     elif i%5==3:
         a4_sum+=i
         a4_i+=1
     elif i%5==4 and i>a5:
         a5=i
    if a4_i>0:
     a4 = round(a4_sum/a4_i,1)
    if a2_f:
     a2 = a2
    else:
     a2='N'
    print("%s %s %s %s %s" %(a1 or 'N', a2, a3 or 'N', a4 or 'N', a5 or 'N'))

    1012 数字分类 (20分).jpeg

给定区间 [−2^31,2^​31] 内的 3 个整数 A、B 和 C,请判断 A+B 是否大于 C。

输入格式:
输入第 1 行给出正整数 T (≤10),是测试用例的个数。随后给出 T 组测试用例,每组占一行,顺序给出 A、B 和 C。整数间以空格分隔。

输出格式:
对每组测试用例,在一行中输出 Case #X: true 如果 A+B>C,否则输出 Case #X: false,其中 X 是测试用例的编号(从 1 开始)。

输入样例:
4
1 2 3
2 3 4
2147483647 0 2147483646
0 -2147483648 -2147483647

输出样例:
Case #1: false
Case #2: true
Case #3: true
Case #4: false

解析:
代码:

#!/usr/bin/python
a = input()
i = 0
result=[]
while i<a:
    s = raw_input()
    s_list = s.split(" ")
    if int(s_list[0]) + int(s_list[1])>int(s_list[2]):
        result.append('true')
    else:
        result.append('false')
    i+=1
for index,item in enumerate(result):
    print("Case #%d: %s" %(index+1,item))

给定一句英语,要求你编写程序,将句中所有单词的顺序颠倒输出。

输入格式:
测试输入包含一个测试用例,在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成,其中单词是由英文字母(大小写有区分)组成的字符串,单词之间用 1 个空格分开,输入保证句子末尾没有多余的空格。

输出格式:
每个测试用例的输出占一行,输出倒序后的句子。

输入样例:
Hello World Here I Come

输出样例:
Come I Here World Hello

解析:
首先我们输入的死一个字符串,单词与单词之间是用空格进行的的划分,我们可以根据空格划分为列表,然后把列表进行倒叙。
列表倒叙我们采用的事切片的操作
实现代码:

#!/usr/bin/python
s = raw_input()
s_list = s.split(" ")
print(" ".join(s_list[-1:-len(s_list)-1:-1]))

1007 数组元素循环右移问题 (20分)Python参考答案
1008.png

输入格式:
每个输入包含一个测试用例,第1行输入N(1≤N≤100)和M(≥0);第2行输入N个整数,之间用空格分隔。

输出格式:
在一行中输出循环右移M位以后的整数序列,之间用空格分隔,序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6

输出样例:
5 6 1 2 3 4

答案解析:
我们首先分析下这个题,输入了n代表了我们将要操控的列表的长度,所以我们要限制我们的列表长度不能超过n。移动m位,那么我们可以采用python里面的切片,这时候,小编就写完了,也提交了,结果没有满分,后来分析了下,m有可能大于n,切片的时候,以m为中间,那么有问题,就改造了下,我们一起来看下代码吧。

#!/usr/bin/python
s = raw_input()
s_list = s.split(" ")
n = int(s_list[0])
m = int(s_list[1])

s = raw_input()
s_list = s.split(" ")
if m>n:
    m -= n
a = []
for i in s_list[0: n]:
    a.append(str(i))
print(" ".join(a[-m:]+a[:-m]))

1.png
输入格式:
输入在一行给出正整数N。

输出格式:
在一行中输出不超过N的满足猜想的素数对的个数。

输入样例:
20
输出样例:
4

分析

在分析之前,小编先说下python的运行效率是真的不是很高,小编的算法优化了好几次才可以,最后的一个测试用例总是超时,20分的算法题只能拿18分,有强迫症的小编好难受,终于功夫不负有心人,完美解决。
大体的思路就是先判断素数,然后判断两个相邻的素数是否相差为2.
细节:

  • 偶数肯定不是素数。
  • 最小的素数对是3,5
  • 求素数的时候先开方,具体理由自己思考。

代码

18分的代码(经历就不说了)

#!/usr/bin/python
import math
n = input()

t = 1
jishu = 0

for num in range(2, n+1):
    chushu = math.sqrt(num)
    f = True
    for number in range(2, int(chushu)+1):
        if num%number==0:
            f = False
            break
    if f:
        if(num-t==2):
            jishu+=1
        t = num
print jishu

20分的

#!/usr/bin/python
import math
n = input()
def issushu(num):
    chushu = math.sqrt(num)
    for number in range(3, int(chushu)+1, 2):
        if num%number==0:
            return False
    return True

t = True
jishu = 0
for number in range(3, n-1, 2):
    t2=issushu(number+2)
    if t and t2:
        jishu+=1
    t = t2
print jishu

原题

让我们用字母 B 来表示“百”、字母 S 表示“十”,用 12...n 来表示不为零的个位数字 n(<10),换个格式来输出任一个不超过 3 位的正整数。例如 234 应该被输出为 BBSSS1234,因为它有 2 个“百”、3 个“十”、以及个位的 4。

输入格式:
每个测试输入包含 1 个测试用例,给出正整数 n(<1000)。

输出格式:
每个测试用例的输出占一行,用规定的格式输出 n。

输入样例 1:
234
输出样例 1:
BBSSS1234
输入样例 2:
23
输出样例 2:
SS123

分析

  1. 输入的是一个三位的正数,百位是几就输出几个‘B’,同样的十位是几就输出几个‘S’,各位是几我们就需要输出1到几。
  2. 所以我们第一步先求出每一位数字的大小,百位的时候,我们直接用这个数除以100,因为这都是int类型的数字之间的计算,得到的值也是int,所以求出的是百位的正数。十位数的计算类似,我们用输入的这个数减去算出来的百位数乘以100,然后除以10得到十位数字,同理得到个人位数字。

     百位 =n/100
     十位 =(n-百位*100)/10
     个位 = n-(百位*100-十位*10)
  3. python的指出字符串个数的做法,就是‘B’*百位个数即可,同理十位也一样,各位的我们通过循环来进行计算。
  4. 最后的输出我们减少字符串的拼接,采用的事%s替代的问题,提高性能。

代码实现

#!/usr/bin/python
n = input()
b = n/100
s = (n-b*100)/10
g = n-(b*100+s*10)
gnum = ''
for num in range(1,g+1):
    gnum = gnum+str(num)
print '%s%s%s' % ('B'*b, 'S'*s, gnum)

原题

卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里,情况稍微有些复杂。

当我们验证卡拉兹猜想的时候,为了避免重复计算,可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候,我们需要计算 3、5、8、4、2、1,则当我们对 n=5、8、4、2 进行验证的时候,就可以直接判定卡拉兹猜想的真伪,而不需要重复计算,因为这 4 个数已经在验证3的时候遇到过了,我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数列中的某个数 n 为“关键数”,如果 n 不能被数列中的其他数字所覆盖。

现在给定一系列待验证的数字,我们只需要验证其中的几个关键数,就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字,并按从大到小的顺序输出它们。

输入格式:
每个测试输入包含 1 个测试用例,第 1 行给出一个正整数 K (<100),第 2 行给出 K 个互不相同的待验证的正整数 n (1<n≤100)的值,数字间用空格隔开。

输出格式:
每个测试用例的输出占一行,按从大到小的顺序输出关键数字。数字间用 1 个空格隔开,但一行中最后一个数字后没有空格。

输入样例:
6
3 5 6 7 8 11
输出样例:
7 6

解题思路

  1. 遍历所有输入的数,求出每个数的覆盖数,去重之后保存在一个列表中。
  2. 遍历覆盖数,输入的数如果在覆盖数里面则删除,剩下的都是关键数了。
  3. 对关键数进行排序,输出。

Python2示例代码

#!/usr/bin/python
n = input()
s = raw_input()
s_list = s.split(" ")
s_list = [int(item) for item in s_list]
n_cover_list = []

for n in s_list:
    while n!=1:
        if n%2==0:
            n/=2
        else:
            n=((3*n)+1)/2
        if n not in n_cover_list:
            n_cover_list.append(n)

for item in n_cover_list:
    if item in s_list:
        s_list.remove(item)
s_str = ''
s_list = sorted(s_list, reverse=True)
for index in range(len(s_list)):
    s_str = s_str+str(s_list[index]) if index==0 else s_str+' '+str(s_list[index])
print(s_str)

1120483222.jpg

题目

读入 n(>0)名学生的姓名、学号、成绩,分别输出成绩最高和成绩最低学生的姓名和学号。

输入格式:
每个测试输入包含 1 个测试用例,格式为
第 1 行:正整数 n
第 2 行:第 1 个学生的姓名 学号 成绩
第 3 行:第 2 个学生的姓名 学号 成绩
... ... ...
第 n+1 行:第 n 个学生的姓名 学号 成绩
其中姓名和学号均为不超过 10 个字符的字符串,成绩为 0 到 100 之间的一个整数,这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出格式:
对每个测试用例输出 2 行,第 1 行是成绩最高学生的姓名和学号,第 2 行是成绩最低学生的姓名和学号,字符串间有 1 空格。

输入样例:
3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95
输出样例:
Mike CS991301
Joe

分析

  1. 输入是先确定输入几行,那么我们就需要先输入一个n,然后循环的输入n行。
  2. 我们需要把每一行输入的字符串处理成一个学生对象(字典),并且保存在一个列表中。
  3. 我们循环遍历这个列表,取出里面的最大值以及最小值,然后输出。

代码实现

#!/usr/bin/python
n = input()
i = 0

students = []
while i<n:
    student = {}
    i = i+1
    s = raw_input()
    std = s.split(" ")
    student['name'] = std[0]
    student['num'] = std[1]
    student['score'] = std[2]
    students.append(student)

max_student = students[0]
min_student = students[0]
for student in students:
    if int(student.get('score'))<int(min_student.get('score')):
        min_student=student
    if int(student.get('score'))>int(max_student.get('score')):
        max_student=student
print '%s %s' % (max_student.get('name'), max_student.get('num'))
print '%s %s' % (min_student.get('name'), min_student.get('num'))

题目

卡拉兹(Callatz)猜想:

对任何一个正整数 n,如果它是偶数,那么把它砍掉一半;如果它是奇数,那么把 (3n+1) 砍掉一半。这样一直反复砍下去,最后一定在某一步得到 n=1。卡拉兹在 1950 年的世界数学家大会上公布了这个猜想,传说当时耶鲁大学师生齐动员,拼命想证明这个貌似很傻很天真的命题,结果闹得学生们无心学业,一心只证 (3n+1),以至于有人说这是一个阴谋,卡拉兹是在蓄意延缓美国数学界教学与科研的进展……

我们今天的题目不是证明卡拉兹猜想,而是对给定的任一不超过 1000 的正整数 n,简单地数一下,需要多少步(砍几下)才能得到 n=1?

输入格式:

每个测试输入包含 1 个测试用例,即给出正整数 n 的值。

输出格式:

输出从 n 计算到 1 需要的步数。

输入样例:

3

输出样例:

5

代码实现:

#!/usr/bin/python
n = input()
i = 0
while not n==1:
    i=i+1
    if n%2==0:
        n=n/2
    else:
        n=(3*n+1)/2
print i

小编使用python2实现的,可能不太适合使用python做算法题,但是仅提供一种解题思路吧,这是第一题,相对来说很简单。

题目

“答案正确”是自动判题系统给出的最令人欢喜的回复。本题属于PAT的“答案正确”大派送 —— 只要读入的字符串满足下列条件,系统就输出“答案正确”,否则输出“答案错误”。

得到“答案正确”的条件是:

  1. 字符串中必须仅有P, A, T这三种字符,不可以包含其它字符;
  2. 任意形如 xPATx 的字符串都可以获得“答案正确”,其中 x 或者是空字符串,或者是仅由字母 A 组成的字符串;
  3. 如果 aPbTc 是正确的,那么 aPbATca 也是正确的,其中 a, b, c 均或者是空字符串,或者是仅由字母 A 组成的字符串。

现在就请你为PAT写一个自动裁判程序,判定哪些字符串是可以获得“答案正确”的。
输入格式: 每个测试输入包含1个测试用例。第1行给出一个自然数n (<10),是需要检测的字符串个数。接下来每个字符串占一行,字符串长度不超过100,且不包含空格。

输出格式:每个字符串的检测结果占一行,如果该字符串可以获得“答案正确”,则输出YES,否则输出NO。

输入样例:
8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA
输出样例:
YES
YES
YES
YES
NO
NO
NO
NO

代码示例及解析

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{
    static Scanner sc;
    public static void main(String[] args) {
        sc = new Scanner(System.in);
        int a = sc.nextInt();
        if(a<10)//由题意可知,第1行给出一个自然数n (<10),是需要检测的字符串个数。
            arr(a);
        
    }
    //定义一个函数,实现判断
    public static void arr(int f) {
        
        List<String> al = new ArrayList<String>();
        int i=1;
        while(i<=f) {
            String s= sc.next();
            al.add(s);
            i++;
        }
        //输出集合中的所有字符串
        for (String string : al) {
            int a=0,p=0,t=0,p1=0,t1=0;//定义一些变量,用来判别字符个数
            char [] s = string.toCharArray(); //字符串转换成字符数组
            //遍历每个字符数组,判断输出什么
            for (char str : s) {
                /**
                 * 确定只有PAT三个字符,否则直接输出“NO”,同时确定3个位置A的个数
                 * 有题可知P前面吗A的个数乘以PT之间A的个数等于T后面A的个数
                 * p代表P前面Ade个数,t代表PT之间A的个数,a代表T后面A的个数
                 * 所以t*p==a
                 * p1,t2用来判断P和T的个数是不是1
                 */
                if(str=='A'||str=='P'||str=='T') {
                    if('A'==str) {
                        a++;
                    }else if('P'==str) {
                        p1++;
                        p=a;
                        a=0;
                        
                    }else if(('T'==str)&&(p1==1)) {//P必须在T的前面
                        t1++;
                        t=a;
                        a=0;
                        
                    }
                }else {
                    break;
                }
            }
            if((t*p==a)&&(a!=0||p!=0||t!=0)&&(p1==1&&t1==1)) {
                System.out.println("YES");
            }else {
                System.out.println("NO");
            }
            
        }
    }
}

Python实现

#!/usr/bin/python
n = input()
i = 0

str_list = []
while i<n:
    i = i+1
    s = raw_input()
    str_list.append(s)

for item in str_list:
    p = 0
    a = 0
    t = 0
    aa = 0
    ap = 0
    at = 0
    if 'P' not in item or 'A' not in item or 'T' not in item:
        print('NO')
        continue
    for i in item:
        if i not in 'PAT':
            p=a=t=0
            break
        if i == 'A' :
            a=a+1
        elif i == 'P':
            p=p+1
        elif i == 'T':
            t=t+1
        if i == 'A' and p==0 and t==0:
            aa=aa+1
        elif i=='A' and p==1 and t==0:
            ap=ap+1
        elif i=='A' and t==1:
            at=at+1
    if p==1 and a>0 and t==1 and aa*ap==at:
        print('YES')
    else:
        print('NO')