PAT-B java实现

最新推荐文章于 2021-02-19 01:03:39 发布
最新推荐文章于 2021-02-19 01:03:39 发布
阅读量118 收藏
点赞数
文章标签： java 测试
原文链接：http://www.cnblogs.com/zjutJY/p/9413829.html
版权
注意：java提交PAT时，不需要加package ； 类名必须是Main。

 

1001 害死人不偿命的(3n+1)猜想 (15)

输入格式：每个测试输入包含1个测试用例，即给出自然数n的值。

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

思路一：

1）当n=1的时候，直接输出步数0；

2）当n>1的时候，判断n为偶数时，将其除以2；奇数时，令n为（3n+1）/2;如此循环直到n=1.每循环一次则步数+1；

3）输出步数

 1 #include <stdio.h>
 2 //输入：每个测试输入包含1个测试用例，即给出自然数n的值。
 3 //输出：输出从n计算到1需要的步数。
 4 
 5 int main(){
 6 
 7     int n=0;//输入的自然数
 8     int step=0;//步数 
 9     
10     scanf("%d",&n); 
11 
12     while(n>1){
13         if(n%2==0){//n为偶数时 
14             n/=2;
15         }
16         else{//n为奇数时
17             n=(3*n+1)/2;
18         }
19         step++;
20     }
21     printf("%d",step);
22     
23     return 0;
24 }

 

package B1001;

import java.util.Scanner;
public class Main {
    //害死人不偿命的(3n+1)猜想
    public static void main(String[] args){
            Scanner input = new Scanner(System.in);
            int n = input.nextInt();
            int count=0;
            while(n!=1){
                if(n%2==0){ //偶数
                    n=n/2;
                }else{      //奇数
                    n=(3*n+1)/2;
                }
                count++;
            }
           System.out.println(count);
    }
}

 

1002 写出这个数 （20 分）

读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

package B1002;

import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
    //读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        //字符串转int数组
        int[] arr = new int[str.length()];
        for(int i=0;i<str.length();i++){
            arr[i] = Integer.parseInt(str.substring(i,i+1));
        }
        Integer sum=0;  //输入整数的和
        for(int j=0;j<arr.length;j++){
            sum += arr[j];
        }
        //int[] arr1 = sum.toString().toCharArray()Select(s => int.Parse(s.ToString())).ToArray();
        String str1 = sum.toString();   //int转字符串
        String[] s = str1.split("");    //字符串转字符串数组；
        String ss="";                   //最终输出的字符串
        for(int k=0;k<s.length;k++){
            ss = ss + map(s[k]) + " ";
        }
        ss = ss.substring(0,ss.length()-1); //去掉最后一个字符，即空格
        System.out.println(ss);
    }
    private static String map(String str){      //构建数字与中文对应的map；
        Map<String,String> map = new HashMap<String,String>();
        map.put("0","ling");
        map.put("1","yi");
        map.put("2","er");
        map.put("3","san");
        map.put("4","si");
        map.put("5","wu");
        map.put("6","liu");
        map.put("7","qi");
        map.put("8","ba");
        map.put("9","jiu");
        return map.get(str);
    }
}

　　

1003 我要通过！ （20 分）

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

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

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

现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

package B1003;

import java.util.Scanner;
public class Main {
    //得到“答案正确”的条件是：
    //字符串中必须仅有 P、 A、 T这三种字符，不可以包含其它字符；
    //任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
    //如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = new Integer(input.nextLine());
        String[] str = new String[n];
        for(int i=0;i<n;i++){
            str[i] = input.nextLine();
        }
        for(int j=0;j<n;j++){
            //System.out.println(str[j]);
            YesOrNo(str[j]);
        }
    }
    private static void YesOrNo(String str){
        String[] s = str.split("");
        int num_p=0,num_t=0,other=0;    //分别代表p、t、除PAT外字符的个数
        int loc_p=-1,loc_t=-1;          //分别代表p、t的位置
        for(int i=0;i<s.length;i++){
            if(s[i].equals("P")){
                num_p++;
                loc_p=i;
            }else if(s[i].equals("T")){
                num_t++;
                loc_t=i;
            }else if(s[i].equals("A")==false){
                other++;
            }
        }
        //如果p的个数不为1，或者t的个数不为1，或者存在其他字符，或者P和T之间没有字符
        if(num_p!=1||num_t!=1||other!=0||loc_t-loc_p<=1){
            System.out.println("NO");
        }else{
            //x,y,z分别代表P前A的个数，P和T之间A的个数,T之后的个数
            int x=loc_p,y=loc_t-loc_p-1,z=s.length-loc_t-1;
            if(z-x*(y-1)==x){   //条件2成立
                System.out.println("YES");
            }else{
                System.out.println("NO");
            }
        }
    }
}

　　

1004 成绩排名 （20 分）

读入 n（>）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

package B1004;

import java.util.Scanner;
public class Main {
    //读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = new Integer(input.nextLine());
        String[] name = new String[n];
        String[] number = new String[n];
        int[] grade = new int[n];
        for(int i=0;i<n;i++){
            name[i] = input.next();
            number[i] = input.next();
            grade[i] = input.nextInt();
            input.nextLine();
        }
        //max、min分别记录最高和最低成绩，x、y分别记录最高和最低成绩所在的下标
        int max=grade[0],min=grade[0],x=0,y=0;
        for(int j=0;j<n;j++){
            if(grade[j]>max){
                max=grade[j];
                x=j;
            }
            if(grade[j]<min){
                min=grade[j];
                y=j;
            }
        }
        //先输出成绩最高学生的姓名和学号,再输出成绩最低学生的姓名和学号
        System.out.print(name[x]+" ");
        System.out.println(number[x]);
        System.out.print(name[y]+" ");
        System.out.println(number[y]);
    }
}
1005 继续(3n+1)猜想 （25 分）

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

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

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

package B1005;

import java.util.Arrays;
import java.util.Comparator;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
    //继续(3n+1)猜想
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = new Integer(input.nextLine());
        Integer[] arr=new Integer[n];
        for(int i=0;i<n;i++){
            arr[i]=input.nextInt();
        }
        //动态数组list存放n的卡拉兹猜想过程中出现的数
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<n;i++){
            int a=arr[i];
            while(a!=1){
                if(a%2==0){ //偶数
                    a=a/2;
                }else{      //奇数
                    a=(3*a+1)/2;
                }
                list.add(a);
            }
        }
        //arr数组中的数与list中的每个数进行比对，若相等则置为0
        for(int i=0;i<n;i++){
            for(int j=0;j<list.size();j++){
                if(arr[i]==list.get(j)){
                    arr[i]=0;
                }
            }
        }
        //对arr数组降序排序
        Comparator cmp=new MyComparator();
        Arrays.sort(arr,cmp);

        //对arr数组从大到小排序，冒泡排序
//        for(int i=0;i<n-1;i--){ //n-1趟排序
//            int flag=0;
//            for(int j=n-1;j>0;j--){    //
//                if(arr[j-1]<arr[j]){
//                    int temp = arr[j-1];
//                    arr[j-1] = arr[j];
//                    arr[j] = temp;
//                    flag=1;
//                }
//            }
//            if(flag==0)
//                break;
//        }

        //输出
        int count=0;
        for(int i=0;i<n;i++){
            if(arr[i]>0){
                count++;
                if (count==1){
                    System.out.print(arr[i]);
                }else{
                    System.out.print(" "+arr[i]);
                }
            }
        }
    }
    public static class MyComparator implements Comparator<Integer>
    {

        public int compare(Integer arg0, Integer arg1) {
            if(arg0<arg1)
                return 1;
            else if(arg0>arg1)
                return -1;
            else
                return 0;
        }

    }

}
1006 换个格式输出整数 （15 分）

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

package B1006;

import java.util.Scanner;
public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        int[] arr = new int[s.length()];
        for(int i=0;i<s.length();i++){
            arr[i] = Integer.parseInt(s.substring(i,i+1));
        }
        String str="";  //输出的字符串
        for(int j=arr.length-1,k=1;j>=0;j--,k++){
            if(k==1){   //个位
                for(int x=arr[j];x>0;x--){
                    str = x+str;
                }
            }else if(k==2){ //十位
                for(int x=arr[j];x>0;x--){
                    str = "S"+str;
                }
            }else{          //百位
                for(int x=arr[j];x>0;x--){
                    str = "B"+str;
                }
            }
        }
        System.out.println(str);
    }
}
1007 素数对猜想 （20 分）

让我们定义d​n​​为：d​n​​=p​n+1​​−p​n​​，其中p​i​​是第i个素数。显然有d​1​​=1，且对于n>1有d​n​​是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。

现给定任意正整数N(<10​5​​)，请计算不超过N的满足猜想的素数对的个数。

package B1007;

import java.util.Scanner;
public class Main {
    //素数对猜想
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int count=0;
        for(int i=3;i<=n-2;i+=2){
            if(IsPrime(i)&&IsPrime(i+2)){
                count++;
            }
        }
        System.out.println(count);
    }
    private static boolean IsPrime(int n){  //判断n是否是素数
        int max = (int) Math.sqrt(n);
        int flag=0;
        for(int j=2;j<=max;j++){
            if(n%j==0){
                flag=1;
                break;
            }
        }
        if(flag==0){
            return true;
        }
        return false;
    }
}
1008 数组元素循环右移问题 （20 分）

一个数组A中存有N（>）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥）个位置，即将A中的数据由（A​0​​A​1​​⋯A​N−1​​）变换为（A​N−M​​⋯A​N−1​​A​0​​A​1​​⋯A​N−M−1​​）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

import java.util.Scanner;
public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int M = input.nextInt();
        int[] a= new int[N];
        for(int i=0;i<N;i++){
            a[i] = input.nextInt();
        }
        M=M%N;
        int count=0;
        for(int i=N-M;i<N;i++){
            count++;
            System.out.print(a[i]);
            if(count<N){
                System.out.print(" ");
            }
        }
        for(int j=0;j<N-M;j++){
            count++;
            System.out.print(a[j]);
            if(count<N){
                System.out.print(" ");
            }
        }
    }
}

 

1009 说反话 （20 分）

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

package B1009;

import java.util.Scanner;
public class Main {
    //给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        String[] str = s.split(" ");
        int n = str.length;
        for(int i=0;i<n-1;i++){
            System.out.print(str[n-1-i]);
            System.out.print(" ");
        }
        System.out.print(str[0]);
    }
}

 

1010 一元多项式求导 （25 分）

设计函数求一元多项式的导数。（注：x​n​​（n为整数）的一阶导数为nx​n−1​​。）

 

1011 A+B 和 C （15 分）

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

package B1011;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        long[][] a = new long[n][3];
        for(int i=0;i<n;i++){
            a[i][0] = input.nextInt();
            a[i][1] = input.nextInt();
            a[i][2] = input.nextInt();
        }
        for(int i=1;i<=n;i++){
            boolean flag=false;
            if(a[i-1][0]+a[i-1][1]>a[i-1][2]){
                flag = true;
            }
            System.out.println("Case #"+i+": "+flag);
        }
    }
}

 

1012 数字分类 （20 分）

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

  • A​1​​ = 能被 5 整除的数字中所有偶数的和；
  • A​2​​ = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n​1​​−n​2​​+n​3​​−n​4​​⋯；
  • A​3​​ = 被 5 除后余 2 的数字的个数；
  • A​4​​ = 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位；
  • A​5​​ = 被 5 除后余 4 的数字中最大数字。
package B1012;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] a = new int[n];
        for(int i=0;i<n;i++){
            a[i] = input.nextInt();
        }
        System.out.print(A1(a)+" "+A2(a)+" "+A3(a)+" "+A4(a)+" "+A5(a));
    }
    private static String A1(int[] a){
        //能被 5 整除的数字中所有偶数的和
        Integer sum=0;
        boolean flag=false;     //有无满足条件的标志
        for(int i=0;i<a.length;i++){
            if(a[i]%5==0&&a[i]%2==0){   //能被 5 整除的偶数
                sum += a[i];
                flag =true;
            }
        }
        if(flag==false){
            return "N";
        }else{
            return sum.toString();
        }
    }
    private static String A2(int[] a){
        // 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n1−n2+n3−n4⋯；
        Integer sum=0;
        boolean flag=false;
        int count=0;
        for(int i=0;i<a.length;i++){
            if(a[i]%5==1){  //被 5 除后余 1
                count++;
                if(count%2!=0){ //第奇数个
                    sum += a[i];
                }else{          //第偶数个
                    sum -= a[i];
                }
                flag =true;
            }
        }
        if(flag==false){
            return "N";
        }else{
            return sum.toString();
        }
    }
    private static String A3(int[] a){
        // 被 5 除后余 2 的数字的个数；
        Integer count=0;
        boolean flag=false;
        for(int i=0;i<a.length;i++){
            if(a[i]%5==2){  //被 5 除后余 2
                count++;
                flag =true;
            }
        }
        if(flag==false){
            return "N";
        }else{
            return count.toString();
        }
    }
    private static String A4(int[] a){
        // 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位；
        double sum = 0.0;
        int count = 0;
        boolean flag=false;
        for(int i=0;i<a.length;i++){
            if(a[i]%5==3){  //被 5 除后余 3
                sum += a[i];
                count++;
                flag =true;
            }
        }
        if(flag==false){
            return "N";
        }else{
            double ave = sum/count;
            return String.format("%.1f",ave);   //取一位小数
        }
    }
    private static String A5(int[] a){
        //被 5 除后余 4 的数字中最大数字。
        Integer max=0;
        boolean flag=false;
        for(int i=0;i<a.length;i++){
            if(a[i]%5==4){  //被 5 除后余 4
                if(a[i]>max){
                    max = a[i];
                }
                flag =true;
            }
        }
        if(flag==false){
            return "N";
        }else{
            return max.toString();
        }
    }
}

 

1013 数素数 （20 分）

令 P​i​​ 表示第 i 个素数。现任给两个正整数 M≤N≤10​4​​，请输出 P​M​​ 到 P​N​​ 的所有素数。

package B1013;

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int M = input.nextInt();
        int N = input.nextInt();
        int count=0;
        for(int i=2;;i++){
            if(IsPrime(i)){
                count++;
                if(count>N){    //超过第N个
                    break;
                }else if (count==N){    //最后一个
                    System.out.print(i);
                }else if(count>=M&&(count+1-M)%10==0){    //每行的第十个
                    System.out.println(i);
                }else if(count>=M&&(count+1-M)%10!=0){     //每行前9个
                    System.out.print(i+" ");
                }
            }
        }
    }
    private static boolean IsPrime(int n){  //判断n是否是素数
        int max = (int) Math.sqrt(n);
        int flag=0;
        for(int j=2;j<=max;j++){
            if(n%j==0){
                flag=1;
                break;
            }
        }
        if(flag==0){
            return true;
        }
        return false;
    }
}

 

1014 福尔摩斯的约会 （20 分）

大侦探福尔摩斯接到一张奇怪的字条：我们约会吧！ 3485djDkxh4hhGE 2984akDfkkkkggEdsb s&hgsfdk d&Hyscvnm。大侦探很快就明白了，字条上奇怪的乱码实际上就是约会的时间星期四 14:04，因为前面两字符串中第 1 对相同的大写英文字母（大小写有区分）是第 4 个字母 D，代表星期四；第 2 对相同的字符是 E ，那是第 5 个英文字母，代表一天里的第 14 个钟头（于是一天的 0 点到 23 点由数字 0 到 9、以及大写字母 A 到 N 表示）；后面两字符串第 1 对相同的英文字母 s 出现在第 4 个位置（从 0 开始计数）上，代表第 4 分钟。现给定两对字符串，请帮助福尔摩斯解码得到约会的时间。

package B1014;

import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        //前两个字符串处理
        String s1 = input.nextLine();
        String s2 = input.nextLine();
        //字符串转成String数组
        String[] c1= s1.split("");
        String[] c2= s2.split("");
        int l1=c1.length,l2=c2.length;
        int n=l1<l2?l1:l2;  //n为c1和c2较短一个数组的长度
        String[] c = new String[2]; //用于存放前两个字符串相同的两个字符
        for(int i=0,j=0;i<n;i++){
            if(j==0&&c1[i].matches("[A-G]")){     //检查是否是A-G之间的字符
                if(c1[i].equals(c2[i])){    //找到两字符串中相同的字符
                    c[j++] = c1[i];
                }
            }else if(j==1&&c1[i].matches("[0-9A-N]")){     //检查是否是0-9A-N之间的字符
                if(c1[i].equals(c2[i])){    //找到两字符串中相同的字符
                    c[j++] = c1[i];
                }
            }
        }

        //后两个字符串处理
        String s3 = input.nextLine();
        String s4 = input.nextLine();
        //字符串转成String数组
        String[] c3= s3.split("");
        String[] c4= s4.split("");
        int l3=c3.length,l4=c4.length;
        int m=l3<l4?l3:l4;  //n为c1和c2较短一个数组的长度
        Integer count=0;    //用于存放前两个字符串相同的的位置
        for(int i=0;i<m;i++){
            if(c3[i].matches("[a-zA-Z]")){
                if(c3[i].equals(c4[i])){    //找到两字符串中相同的字符,记录其位置
                    count=i;
                    break;
                }
            }
        }
        String min;  //将count转成string型，满足分钟格式
        if(count<10){
            min= "0"+count.toString();
        }else{
            min= count.toString();
        }
        System.out.print(week(c[0])+" "+hour(c[1])+":"+min);
    }
    private static String week(String str){     //得到星期
        Map<String,String> map = new HashMap<String,String>();    //定义map；
        map.put("A","MON");  //初始化map；
        map.put("B","TUE");
        map.put("C","WED");
        map.put("D","THU");
        map.put("E","FRI");
        map.put("F","SAT");
        map.put("G","SUN");
        return map.get(str);
    }
    private static String hour(String str){     //得到小时
        String E1 = "[0-9]";
        //String E2 = "[A-N]";
        if(str.matches(E1)){
            return "0"+str;
        }else {
            char[] s = str.toCharArray();
            Integer n = 10+ s[0]-'A';
            String ss = n.toString();
            return ss;
        }
    }
}

 

1016 部分A+B （15 分）

正整数 A 的“D​A​​（为 1 位整数）部分”定义为由 A 中所有 D​A​​ 组成的新整数 P​A​​。例如：给定 A=3862767，D​A​​=6，则 A 的“6 部分”P​A​​ 是 66，因为 A 中有 2 个 6。

现给定 A、D​A​​、B、D​B​​，请编写程序计算 P​A​​+P​B​​。

package B1016;


import java.util.Scanner;
public class Main {
    //部分A+B
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        long a = input.nextInt();
        long da = input.nextInt();
        long b = input.nextInt();
        long db = input.nextInt();
        long pa=0,pb=0;
        while(a!=0){
            if(a%10==da){
                pa = pa*10 + da;
            }
            a=a/10;
        }
        while(b!=0){
            if(b%10==db){
                pb = pb*10 + db;
            }
            b=b/10;
        }
        System.out.print(pa+pb);
    }
}

 

1021 个位数统计 （15 分）

给定一个 k 位整数 1 (0, ,, d​k−1​​>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 0，则有 2 个 0，3 个 1，和 1 个 3。

package B1021;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        char[] a = str.toCharArray();
        int len = a.length;
        int[] count = new int[10];
        for(int i=0;i<len;i++){
            count[a[i]-'0'] ++;
        }
        for(int i=0;i<10;i++){
            if(count[i]!=0){
                System.out.println(i+":"+count[i]);
            }
        }
    }
}

　　

　　

 

1026 程序运行时间 （15 分）

要获得一个 C 语言程序的运行时间，常用的方法是调用头文件 time.h，其中提供了 clock() 函数，可以捕捉从程序开始运行到 clock() 被调用时所耗费的时间。这个时间单位是 clock tick，即“时钟打点”。同时还有一个常数 CLK_TCK，给出了机器时钟每秒所走的时钟打点数。于是为了获得一个函数 f 的运行时间，我们只要在调用 f 之前先调用 clock()，获得一个时钟打点数 C1；在 f 执行完成后再调用 clock()，获得另一个时钟打点数 C2；两次获得的时钟打点数之差 (C2-C1) 就是 f 运行所消耗的时钟打点数，再除以常数 CLK_TCK，就得到了以秒为单位的运行时间。

这里不妨简单假设常数 CLK_TCK 为 100。现给定被测函数前后两次获得的时钟打点数，请你给出被测函数运行的时间。

package B1026;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int c1 = input.nextInt();
        int c2 = input.nextInt();
        int ans = c2 - c1;
        if(ans%100 >=50){   //五入
            ans = ans/100 +1;
        }else{              //四舍
            ans = ans/100;
        }
        //分别得到时 分 秒
        int hour = ans/3600;
        int min = ans%3600/60;
        int sed = ans%60;
        //输出。格式转换，不足10高位要补0
        System.out.print(String.format("%02d",hour)+":"+String.format("%02d",min)+":"+String.format("%02d",sed));
    }
}

 

 

1031 查验身份证 （15 分）

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：

首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：

Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2

现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

package B1031;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = Integer.parseInt(input.nextLine());
        int[] W={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};  //权重
        char[] M ={'1','0','X','9','8','7','6','5','4','3','2'};    //校验码
        boolean flag = true;
        for(int i=0;i<n;i++){
            String str = input.nextLine();
            char[] a = str.toCharArray();
            int j,last=0;
            for(j=0;j<17;j++){
                if(a[j]>='0' &&a[j]<='9' ){
                    last = last + W[j]*(a[j]-'0');
                }else{
                    break;
                }
            }
            if(j<17){           //有非数字的存在
                flag=false;
                System.out.println(a);
            }else {             //前17位均为数字
                if(M[last%11]!=a[17]){  //校验码不等于最后一位
                    flag=false;
                    System.out.println(a);
                }
            }
        }
        if(flag==true){
            System.out.println("All passed");
        }
    }
}

　

1036 跟奥巴马一起编程 （15 分）

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014 年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

package B1036;

import java.util.Scanner;

public class Main {
    //
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        String s = input.next();
        char c = s.charAt(0);
        //四舍五入
        int row=0;  //行数
        if(n%2!=0){ //行数为奇数
            row = n/2+1;
        }else {
            row = n/2;
        }
        //输出
        for(int i=1;i<=row;i++){
            if (i==1){  //第一行
                for(int j=0;j<n;j++){
                    System.out.print(c);
                }
                System.out.println();
            }else if(i==row){   //最后一行
                for(int j=0;j<n;j++){
                    System.out.print(c);
                }
            }else { //中间几行
                System.out.print(c);
                for(int j=0;j<n-2;j++){
                    System.out.print(" ");
                }
                System.out.print(c);
                System.out.println();
            }
        }
    }
}

　　

 

转载于:https://www.cnblogs.com/zjutJY/p/9413829.html

babi0430
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PAT-B1005 继续(3n+1)猜想 JAVA&&C
chauncyyoung的博客
03-06 218
1005继续(3n+1)猜想（25 分） 当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对n=3进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数...
PAT预热--算法初步--插入排序（JAVA实现）
qq_40755025的博客
04-08 91
/** * @author csj * @date 2020/4/8 - 10:37 */ //从小到大排序 public class insert_sort { public static void insert_sort(int[] arr){ int n = arr.length; //n个元素 需要N-1趟 // ...
【PAT】Digital Library (30)Java实现
zjkC050818的博客
10-19 422
1022. Digital Library (30) 时间限制 1000 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue A Digital Library contains millions of bo
PAT 乙级 1020 月饼 （25分）Java实现
zmjのblog
11-17 1005
原题链接：月饼 1. 题意 题意比较明了，就是让我们求最大的收益 2. 思路 这道题用Java写要注意两个地方 输入的时候不能使用Scanner类，因为输入的数据比较多，使用Scanner输入会很慢，所以我们要用BufferedReader类，得到字符串后，再转为double型计算 输出保留两位小数，Java的做法：String.format("%.2f", sum) 3. 代码 packag...
1065.单身狗(25)--PAT乙级真题java实现
JingLisen的博客
09-09 1392
个人博客：小景哥哥 1065.单身狗(25)–PAT乙级真题java实现 “单身狗”是中文对于单身人士的一种爱称。本题请你从上万人的大型派对中找出落单的客人，以便给予特殊关爱。 输入格式： 输入第一行给出一个正整数N（&lt;=50000），是已知夫妻/伴侣的对数；随后N行，每行给出一对夫妻/伴侣——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；...
【JAVA】1001 A+B Format (20分) PAT甲级 PAT (Advanced Level) Practice
12-21
【JAVA】1001 A+B Format (20分) 是PAT甲级(Advanced Level)实战中的一个编程题目，目标是计算两个整数a和b的和，并按照标准格式输出，即每三位数字之间用逗号分隔，除非数字少于四位。题目要求输入为-10^6至10^6...
PAT(A&B Level)Practise
06-15
2. **算法与数据结构**：PAT测试的重点在于算法设计与实现。常见的算法包括排序（如冒泡、选择、插入、快速、归并排序）、查找（如线性查找、二分查找）、图论（如深度优先搜索、广度优先搜索）、动态规划、贪心算法...
pat题目分类.docx
09-07
这些PAT甲级题目涵盖了多个计算机科学的基础知识点，主要包括字符串处理、哈希表的应用、图论问题和树结构的处理。接下来我们将对这些知识点进行详细解释。 1. **字符串处理**： - **修复键盘坏损** (1112 Stucked...
PAT全套答案_1001至1049.rar
10-22
PAT考试通常包括一系列的编程题目，涵盖C、C++、Java等编程语言，涉及数据结构、算法、操作系统、计算机网络等多个领域。在准备PAT考试时，熟悉这些答案可以帮助考生理解解题思路，学习如何有效地解决问题，并且提升...
pat java_PAT-A Java实现
weixin_42356139的博客
02-19 314
1001A+B Format (20)输入：两个数a,b，-1000000 <= a, b <= 1000000输出：a+b，并以每3个用逗号隔开的形式展示。思路一：1)计算出a+b的值，赋给sum。判断sum<0，则先输出一个“”-”号，并将sum=-sum(转换为正值)；判断sum==0时，则输出0；2)然后将sum存到一个数组num[10]中，将sum数值的低位存到数组的...
pat 乙级 1001 害死人不偿命的(3n+1)猜想(C++)
魔神之云的博客
02-01 353
题目 卡拉兹(Callatz)猜想： 对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。这样一直反复砍下去，最后一定在某一步得到 n=1。卡拉兹在 1950 年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证 (3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展…… 我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过 1000 的正整数 n
算法笔记 3.1 简单模拟
ceneri
05-22 255
题目描述卡拉兹(Callatz)猜想： 对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+1)砍掉一半。这样一直反复砍下去，最后一定在某一步 得到n=1。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题， 结果闹得学生们无心学业，一心只证(3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延
将一个数组中所有的奇数放左边，偶数放右边，且原来数字的相对位置不变
zw_wen的博客
09-24 3589
public class Test { public static void main(String[] args) { int[] arr={1,3,2,4,5,7,9,8}; int count=0; //定义获取的方法 //定义计数器，计算数组中奇数的个数 for(int i=0;i if(arr[i]%2!=0) count++; } //定义新数组存储原数
关于Integer.parseInt（）的使用
热门推荐
YAN_HUAXIANGMO的博客
11-09 5万+
翻译上解释： integer 英 ['ɪntɪdʒə] 美 ['ɪntɪdʒɚ] n. [数] 整数；整体；完整的事物 更多释义>> [网络短语] integer 整数,整型,整数 (计算机科学)Gaussian integer 高斯整数,gauss整数,高斯整数Eisenstein in
关于Integer.parseInt()方法的问题
阿康的博客
02-04 4944
在我解决蓝桥练习的十六进制转八进制的练习中，我想要使用Integer的parseInt方法来实现将16进制的数封装到Integer对象中再输出为8进制。 类似这样 Scanner sc = new Scanner(System.in); int n = Integer.valueOf(sc.nextLine()); long[] a = new lon
使用Java语言刷 pat 题
说文科技，做有态度的研究。
01-13 1880
使用Java语言刷 pat 题 1. 搭建Intellij 环境 这个很好解决，不再赘述。 主要的问题是，如何解决数据输入的问题。如何使用java 读取输入的问题，可以见我的博客：Java 实现标准输入的几种方式 2. 如何控制读取结束 刚从c语言转移到Java语言的同学，可能会对java语言的输入不大熟悉，不像c语言的scanf()函数那样使用方便，如果我们想先输入数字N，接着再输入N个数字，在...
第一次使用Java写pat
一腔诗意喂了狗
08-10 2496
遇到了编译错误： ERROR: can not renice Main.java:3: error: class Three is public, should be declared in a file named Three.java public class Three {        ^ 1 error 其解决方案为 Java的类名必须为Main
C语言解决对给定的任一不超过1000的正整数n，简单地数一下，需要多少步（砍几下）才能得到n=1？
small_feiyu的博客
03-24 6530
/* 卡拉兹(Callatz)猜想： 对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+1)砍掉一半。这样一直反复砍下去， 最后一定在某一步得到n=1。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员， 拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证(3n+1)，以至于有人说这是一个阴谋， 卡拉兹是在蓄意延
New Beginning --- PAT_Basic 1001
Znmax1217的博客
03-05 308
New Beginning---PAT_Basic 1001
jmu-java-01入门-第一个pat上java程序
最新发布
03-16
jmu-java-01入门-第一个pat上java程序是一篇介绍如何使用Java语言编写第一个PAT（浙江大学计算机程序设计能力测试）题目的教程。在这篇教程中，作者详细介绍了Java语言的基本语法和编程思路，并通过一个简单的例子来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值