PAT-B java实现

注意：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）输出步数

 #include <stdio.h>
 //输入：每个测试输入包含1个测试用例，即给出自然数n的值。
 //输出：输出从n计算到1需要的步数。

 int main(){

     int n=;//输入的自然数
     int step=;//步数 

     scanf("%d",&n); 

     while(n>){
         if(n%==){//n为偶数时
             n/=;
         }
         else{//n为奇数时
             n=(*n+)/;
         }
         step++;
     }
     printf("%d",step);

     return ;
 } 

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();
            }
        }
    }
}