小景哥哥

世界很大,而我们还需要再成长!

您现在的位置是:首页>爱编程

爱编程文章

1072. 开学寄语(20)–PAT乙级真题java实现

    1072. 开学寄语(20)–PAT乙级真题java实现
     
    下图是上海某校的新学期开学寄语:天将降大任于斯人也,必先删其微博,卸其QQ,封其电脑,夺其手机,收其ipad,断其wifi,使其百无聊赖,然后,净面、理发、整衣,然后思过、读书、锻炼、明智、开悟、精进。而后必成大器也! 
    本题要求你写个程序帮助这所学校的老师检查所有学生的物品,以助其成大器。 
    输入格式: 
    输入第一行给出两个正整数N(<= 1000)和M(<= 6),分别是学生人数和需要被查缴的物品种类数。第二行给出M个需要被查缴的物品编号,其中编号为4位数字。随后N行,每行给出一位学生的姓名缩写(由1-4个大写英文字母组成)、个人物品数量K(0 <= K <= 10)、以及K个物品的编号。 
    输出格式: 
    顺次检查每个学生携带的物品,如果有需要被查缴的物品存在,则按以下格式输出该生的信息和其需要被查缴的物品的信息(注意行末不得有多余空格): 
    姓名缩写: 物品编号1 物品编号2 …… 
    最后一行输出存在问题的学生的总人数和被查缴物品的总数。 
    输入样例: 
    4 2 
    2333 6666 
    CYLL 3 1234 2345 3456 
    U 4 9966 6666 8888 6666 
    GG 2 2333 7777 
    JJ 3 0012 6666 2333 
    输出样例: 
    U: 6666 6666 
    GG: 2333 
    JJ: 6666 2333 
    3 5
     
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().trim().split(" ");
            int N = Integer.parseInt(s[0]);
            int M = Integer.parseInt(s[1]);
            String[] thing = br.readLine().split(" ");
            int stuTol = 0, thTol = 0;
            for(int i = 0; i < N; i++) {
                String[] temp = br.readLine().split(" ");
                boolean flag = false;
                for(int j = 2; j < temp.length; j++) {
                    for(int k = 0; k < M; k++) {
                        if(temp[j].equals(thing[k])) {
                            thTol++;
                            if(flag) {
                                System.out.print(" " + temp[j]);
                            }else {
                                System.out.print(temp[0] + ": " + temp[j]);
                            }
                            flag = true;
                        }
                    }
                }
                if(flag) {
                    stuTol++;
                    System.out.println();
                }
            }
            System.out.println(stuTol + " " + thTol);
        }
    }
    阅读全文>>

作者:Jason分类:【pat浏览(288评论(0

2018-09-15

1071.小赌怡情(15)--PAT乙级真题java实现

    1071.小赌怡情(15)--PAT乙级真题java实现
     
    常言道“小赌怡情”。这是一个很简单的小游戏:首先由计算机给出第一个整数;然后玩家下注赌第二个整数将会比第一个数大还是小;玩家下注t个筹码后,计算机给出第二个数。若玩家猜对了,则系统奖励玩家t个筹码;否则扣除玩家t个筹码。
    注意:玩家下注的筹码数不能超过自己帐户上拥有的筹码数。当玩家输光了全部筹码后,游戏就结束。
    输入格式:
    输入在第一行给出2个正整数T和K(<=100),分别是系统在初始状态下赠送给玩家的筹码数、以及需要处理的游戏次数。随后K行,每行对应一次游戏,顺序给出4个数字:
    n1 b t n2
    其中n1和n2是计算机先后给出的两个[0, 9]内的整数,保证两个数字不相等。b为0表示玩家赌“小”,为1表示玩家赌“大”。t表示玩家下注的筹码数,保证在整型范围内。
    输出格式:
    对每一次游戏,根据下列情况对应输出(其中t是玩家下注量,x是玩家当前持有的筹码量):
    玩家赢,输出
    Win t! Total = x.
    玩家输,输出
    Lose t. Total = x.
    玩家下注超过持有的筹码量,输出
    Not enough tokens. Total = x.
    玩家输光后,输出
    Game Over.
    并结束程序。
    输入样例1:
    100 4
    8 0 100 2
    3 1 50 1
    5 1 200 6
    7 0 200 8
    输出样例1:
    Win 100! Total = 200.
    Lose 50. Total = 150.
    Not enough tokens. Total = 150.
    Not enough tokens. Total = 150.
    输入样例2:
    100 4
    8 0 100 2
    3 1 200 1
    5 1 200 6
    7 0 200 8
    输出样例2:
    Win 100! Total = 200.
    Lose 200. Total = 0.
    Game Over.
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().trim().split(" ");
            int T = Integer.parseInt(s[0]);
            int K = Integer.parseInt(s[1]);
            
            for(int i = 0; i < K; i++) {
                String[] sp = br.readLine().trim().split(" ");
                int n1 = Integer.parseInt(sp[0]);
                int b = Integer.parseInt(sp[1]);
                int t = Integer.parseInt(sp[2]);
                int n2 = Integer.parseInt(sp[3]);
                if(t > T) {
                    System.out.println("Not enough tokens.  Total = "+ T +".");
                    continue;
                }
                if((n1 < n2 && b == 1)||(n1 > n2 && b == 0)) {
                    T = T + t;
                    System.out.println("Win "+t+"!  Total = "+ T +".");
                }else {
                    T = T - t;
                    System.out.println("Lose "+ t +".  Total = "+ T +".");
                }
                
                if(T == 0) {
                    System.out.println("Game Over.");
                    break;
                }
            }
        }
    }

     

    阅读全文>>

作者:Jason分类:【pat浏览(286评论(0

2018-09-15

1070. 结绳(25)–PAT乙级真题java实现

    1070. 结绳(25)–PAT乙级真题java实现
     
    给定一段一段的绳子,你需要把它们串成一条绳。每次串连的时候,是把两段绳子对折,再如下图所示套接在一起。这样得到的绳子又被当成是另一段绳子,可以再次对折去跟另一段绳子串连。每次串连后,原来两段绳子的长度就会减半。 
    给定N段绳子的长度,你需要找出它们能串成的绳子的最大长度。
    这里写图片描述

    输入格式: 
    每个输入包含1个测试用例。每个测试用例第1行给出正整数N (2 <= N <= 104);第2行给出N个正整数,即原始绳段的长度,数字间以空格分隔。所有整数都不超过104。 
    输出格式: 
    在一行中输出能够串成的绳子的最大长度。结果向下取整,即取为不超过最大长度的最近整数。 
    输入样例: 

    10 15 12 3 4 13 1 15 
    输出样例: 
    14
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Arrays;
    public class Main {
        
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            int[] s = new int[n];
            String[] sp = br.readLine().split(" ");
            for(int i = 0; i < n; i++)
                s[i]  = Integer.parseInt(sp[i]);
            Arrays.sort(s);
            int res = s[0];
            for(int i = 1; i < n; i++)
                res = (res + s[i]) / 2;
            System.out.println(res);
        }
    }

     

    阅读全文>>

作者:小景哥哥分类:【pat浏览(287评论(0

2018-09-09

1069. 微博转发抽奖(20)–PAT乙级真题java实现

    1069. 微博转发抽奖(20)–PAT乙级真题java实现
     
    小明PAT考了满分,高兴之余决定发起微博转发抽奖活动,从转发的网友中按顺序每隔N个人就发出一个红包。请你编写程序帮助他确定中奖名单。 
    输入格式: 
    输入第一行给出三个正整数M(<= 1000)、N和S,分别是转发的总量、小明决定的中奖间隔、以及第一位中奖者的序号(编号从1开始)。随后M行,顺序给出转发微博的网友的昵称(不超过20个字符、不包含空格回车的非空字符串)。 
    注意:可能有人转发多次,但不能中奖多次。所以如果处于当前中奖位置的网友已经中过奖,则跳过他顺次取下一位。 
    输出格式: 
    按照输入的顺序输出中奖名单,每个昵称占一行。如果没有人中奖,则输出“Keep going…”。 
    输入样例1: 
    9 3 2 
    Imgonnawin! 
    PickMe 
    PickMeMeMeee 
    LookHere 
    Imgonnawin! 
    TryAgainAgain 
    TryAgainAgain 
    Imgonnawin! 
    TryAgainAgain 
    输出样例1: 
    PickMe 
    Imgonnawin! 
    TryAgainAgain 
    输入样例2: 
    2 3 5 
    Imgonnawin! 
    PickMe 
    输出样例2: 
    Keep going…
     
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.List;
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().split(" ");
            int total = Integer.parseInt(s[0]);
            int interval = Integer.parseInt(s[1]);
            int prize = Integer.parseInt(s[2]);
            List<String> list = new ArrayList<>();
            boolean flag = false;
            for(int i = 1; i <= total; i++) {
                String user = br.readLine();
                if(list.contains(user))
                    prize++;
                if(i == prize) {
                    System.out.println(user);
                    list.add(user);
                    flag = true;
                    prize += interval;
                }
            }
            if(!flag)
                System.out.println("Keep going...");
        }
    }
    阅读全文>>

作者:小景哥哥分类:【pat浏览(241评论(0

2018-09-09

1068. 万绿丛中一点红(20)–PAT乙级真题java实现

    1068. 万绿丛中一点红(20)–PAT乙级真题java实现
     
    对于计算机而言,颜色不过是像素点对应的一个24位的数值。现给定一幅分辨率为MxN的画,要求你找出万绿丛中的一点红,即有独一无二颜色的那个像素点,并且该点的颜色与其周围8个相邻像素的颜色差充分大。 
    输入格式: 
    输入第一行给出三个正整数,分别是M和N(<= 1000),即图像的分辨率;以及TOL,是所求像素点与相邻点的颜色差阈值,色差超过TOL的点才被考虑。随后N行,每行给出M个像素的颜色值,范围在[0, 224)内。所有同行数字间用空格或TAB分开。 
    输出格式: 
    在一行中按照“(x, y): color”的格式输出所求像素点的位置以及颜色值,其中位置x和y分别是该像素在图像矩阵中的列、行编号(从1开始编号)。如果这样的点不唯一,则输出“Not Unique”;如果这样的点不存在,则输出“Not Exist”。 
    输入样例1: 
    8 6 200 
    0 0 0 0 0 0 0 0 
    65280 65280 65280 16711479 65280 65280 65280 65280 
    16711479 65280 65280 65280 16711680 65280 65280 65280 
    65280 65280 65280 65280 65280 65280 165280 165280 
    65280 65280 16777015 65280 65280 165280 65480 165280 
    16777215 16777215 16777215 16777215 16777215 16777215 16777215 16777215 
    输出样例1: 
    (5, 3): 16711680 
    输入样例2: 
    4 5 2 
    0 0 0 0 
    0 0 3 0 
    0 0 0 0 
    0 5 0 0 
    0 0 0 0 
    输出样例2: 
    Not Unique 
    输入样例3: 
    3 3 5 
    1 2 3 
    3 4 5 
    5 6 7 
    输出样例3: 
    Not Exist
    分析:首先这个点必须是唯一的,所以用map标记如果不是唯一的点就不用考虑了~接着对于每个点,判断它的周围八个点与它的差值是否大于阈值,如果有一个点没有满足大于阈值就return false~最后记得输入的时候是列、行——m、n,输出的时候也是列、行坐标.
     
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    public class Main {
        static int dir[][] = new int[][]{{-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}};
        static int[][] screen = new int[1001][1001];
        static int tol;
        static int n;
        static int m;
        public static boolean judge(int i, int j) {
            for (int k = 0; k < 8; k++) {
                int tx = i + dir[k][0];
                int ty = j + dir[k][1];
                if (tx >= 0 && tx < n && ty >= 0 && ty < m && screen[i][j] - screen[tx][ty] >= 0 - tol && screen[i][j] - screen[tx][ty] <= tol)
                    return false;
            }
            return true;
        }
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int cnt = 0, x = 0, y = 0;
            String[] s = br.readLine().split(" ");
            m = Integer.parseInt(s[0]);
            n = Integer.parseInt(s[1]);
            tol = Integer.parseInt(s[2]);
            
            Map map = new HashMap<>();
            for(int i = 0; i < n; i++) {
                String[] sp = br.readLine().split("\\s+|\t");
                for(int j = 0; j < m; j++) {
                    screen[i][j] = Integer.parseInt(sp[j]);
                    if(map.containsKey(screen[i][j]))
                        map.put(screen[i][j], map.get(screen[i][j]) + 1);
                    else
                        map.put(screen[i][j], 1);
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (map.get(screen[i][j]) == 1 && judge(i, j) == true) {
                        cnt++;
                        x = i + 1;
                        y = j + 1;
                    }
                }
            }
            if (cnt == 1)
                System.out.printf("(%d, %d): %d", y, x, screen[x-1][y-1]);
            else if (cnt == 0)
                System.out.printf("Not Exist");
            else
                System.out.printf("Not Unique");
        }
    }
    阅读全文>>

作者:小景哥哥分类:【pat浏览(388评论(0

2018-09-09

1067. 试密码(20)–PAT乙级真题java实现

    1067. 试密码(20)–PAT乙级真题java实现
     
    当你试图登录某个系统却忘了密码时,系统一般只会允许你尝试有限多次,当超出允许次数时,账号就会被锁死。本题就请你实现这个小功能。 
    输入格式: 
    输入在第一行给出一个密码(长度不超过20的、不包含空格、Tab、回车的非空字符串)和一个正整数N(<= 10),分别是正确的密码和系统允许尝试的次数。随后每行给出一个以回车结束的非空字符串,是用户尝试输入的密码。输入保证至少有一次尝试。当读到一行只有单个#字符时,输入结束,并且这一行不是用户的输入。 
    输出格式: 
    对用户的每个输入,如果是正确的密码且尝试次数不超过N,则在一行中输出“Welcome in”,并结束程序;如果是错误的,则在一行中按格式输出“Wrong password: 用户输入的错误密码”;当错误尝试达到N次时,再输出一行“Account locked”,并结束程序。 
    输入样例1: 
    Correct%pw 3 
    correct%pw 
    Correct@PW 
    whatisthepassword! 
    Correct%pw 

    输出样例1: 
    Wrong password: correct%pw 
    Wrong password: Correct@PW 
    Wrong password: whatisthepassword! 
    Account locked 
    输入样例2: 
    cool@gplt 3 
    coolman@gplt 
    coollady@gplt 
    cool@gplt 
    try again 

    输出样例2: 
    Wrong password: coolman@gplt 
    Wrong password: coollady@gplt 
    Welcome in

    分析: 
    1.如果已经是”#”了就不要继续下面的判断了,不然可能输出Wrong password: “#” 
    2.如果密码错误并且达到了尝试的次数,是先输出Wrong password那句紧接着输出Account locked那句 
    3.Wrong password: 后面有个空格。
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().split(" ");
            String pwd = s[0];
            int times = Integer.parseInt(s[1]);
            while(times > 0) {
                String pass = br.readLine();
                if(pass.equals(pwd)) {
                    System.out.println("Welcome in");
                    break;
                }else if(pass.equals("#")) {
                    break;
                }else {
                    System.out.println("Wrong password: " + pass);
                    times--;
                }
            }
            if(times <= 0)
                System.out.println("Account locked");
        }
    }
    阅读全文>>

作者:小景哥哥分类:【pat浏览(198评论(0

2018-09-09

1066. 图像过滤(15)–PAT乙级真题java实现

    1066. 图像过滤(15)–PAT乙级真题java实现
     
    图像过滤是把图像中不重要的像素都染成背景色,使得重要部分被凸显出来。现给定一幅黑白图像,要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。
    输入格式:
    输入在第一行给出一幅图像的分辨率,即两个正整数M和N(0 < M, N <= 500),另外是待过滤的灰度值区间端点A和B(0 <= A < B <= 255)、以及指定的替换灰度值。随后M行,每行给出N个像素点的灰度值,其间以空格分隔。所有灰度值都在[0, 255]区间内。
    输出格式:
    输出按要求过滤后的图像。即输出M行,每行N个像素灰度值,每个灰度值占3位(例如黑色要显示为000),其间以一个空格分隔。行首尾不得有多余空格。
    输入样例:
    3 5 100 150 0
    3 189 254 101 119
    150 233 151 99 100
    88 123 149 0 255
    输出样例:
    003 189 254 000 000
    000 233 151 099 000
    088 000 000 000 255
     
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) throws IOException{
            Scanner sc = new Scanner(System.in);
            int M = sc.nextInt(), N = sc.nextInt(), A = sc.nextInt(),
                     B = sc.nextInt(), filter = sc.nextInt();
            for(int i = 0; i < M; i++) {
                for(int j = 0; j < N; j++) {
                    int rgb = sc.nextInt();
                    if(rgb >= A && rgb <= B) {
                        rgb = filter;
                    }
                    if(j != 0)
                        System.out.print(" ");
                    System.out.printf("%03d",rgb);
                }
                System.out.println();
            }
            
        }
    }
    //solution two
    class solution{
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().split(" ");
            int M = Integer.parseInt(s[0]), N = Integer.parseInt(s[1]),
                    A = Integer.parseInt(s[2]), B = Integer.parseInt(s[3]),
                    filter = Integer.parseInt(s[4]);
            for(int i = 0; i < M; i++) {
                String[] sp = br.readLine().split(" ");
                for(int j = 0; j < N; j++) {
                    int rgb = Integer.parseInt(sp[j]);
                    if(rgb >= A && rgb <= B) {
                        rgb = filter;
                    }
                    if(j != 0)
                        System.out.print(" ");
                    System.out.printf("%03d",rgb);
                }
                System.out.println();
            }
        }
    }
    阅读全文>>

作者:Jason分类:【pat浏览(269评论(0

2018-09-09

1065.单身狗(25)–PAT乙级真题java实现

    1065.单身狗(25)–PAT乙级真题java实现
     
    “单身狗”是中文对于单身人士的一种爱称。本题请你从上万人的大型派对中找出落单的客人,以便给予特殊关爱。 
    输入格式: 
    输入第一行给出一个正整数N(<=50000),是已知夫妻/伴侣的对数;随后N行,每行给出一对夫妻/伴侣——为方便起见,每人对应一个ID号,为5位数字(从00000到99999),ID间以空格分隔;之后给出一个正整数M(<=10000),为参加派对的总人数;随后一行给出这M位客人的ID,以空格分隔。题目保证无人重婚或脚踩两条船。 
    输出格式: 
    首先第一行输出落单客人的总人数;随后第二行按ID递增顺序列出落单的客人。ID间用1个空格分隔,行的首尾不得有多余空格。 
    输入样例: 

    11111 22222 
    33333 44444 
    55555 66666 

    55555 44444 10000 88888 22222 11111 23333 
    输出样例: 

    10000 23333 44444 55555 88888

    分析: 
    设立数组couples[i] = j表示i的对象是j。一开始先设置为都是-1。设立数组appear表示某人的对象是否来到了派对上。接收数据的时候,对于每一对wife和husband,将couple的husband设置为wife,wife设置为husband,表示他俩是一对。对于每一个需要判断的人,将其存储在guest数组里面,如果它不是单身的(也就是如果它的couple[guest[i]] != -1)那么就将它对象的appear设置为1,表示他对象的对象(也就是他自己)来到了派对。这样所有appear不为1的人,对象是没有来到派对的。
     
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int N = Integer.parseInt(br.readLine());
            int couples[] = new int[100000];
            int appear[] = new int[100000];
            for(int i = 0; i < 100000; i++) {
                couples[i] = -1;
                appear[i] = -1;
            }
            for(int i = 0; i < N; i++) {
                String[] s = br.readLine().split(" ");
                int wife = Integer.parseInt(s[0]);
                int husband = Integer.parseInt(s[1]);
                couples[wife] = husband;
                couples[husband] = wife;
            }
            int M = Integer.parseInt(br.readLine());
            String[] guest = br.readLine().split(" ");
            int minus = 0;
            for(int i = 0; i < M; i++) {
                int g = Integer.parseInt(guest[i]);
                if(couples[g] != -1)
                    appear[couples[g]] = 1;
                if(couples[g]!=-1 && appear[couples[g]]==1 && appear[g]==1){
                    minus += 2;
                }
            }
            Arrays.sort(guest);   
            boolean flag = false; 
            System.out.println(guest.length - minus);
            for(int i = 0; i < guest.length;i++) {
                int g = Integer.parseInt(guest[i]);
                if(appear[g] != 1) {
                    if(flag) {
                        System.out.print(" " + guest[i]);
                    }else {
                        System.out.print(guest[i]);
                        flag = true;
                    }
                }
            }
        }
    }
    阅读全文>>

作者:Jason分类:【pat浏览(236评论(0

2018-09-09

1064.朋友数(20)–PAT乙级真题java实现

    1064.朋友数(20)–PAT乙级真题java实现

    如果两个整数各位数字的和是一样的,则被称为是“朋友数”,而那个公共的和就是它们的“朋友证号”。例如123和51就是朋友数,因为1+2+3 = 5+1 = 6,而6就是它们的朋友证号。给定一些整数,要求你统计一下它们中有多少个不同的朋友证号。注意:我们默认一个整数自己是自己的朋友。

    输入格式:

    输入第一行给出正整数N。随后一行给出N个正整数,数字间以空格分隔。题目保证所有数字小于104。

    输出格式:

    首先第一行输出给定数字中不同的朋友证号的个数;随后一行按递增顺序输出这些朋友证号,数字间隔一个空格,且行末不得有多余空格。

    输入样例:

    8

    123 899 51 998 27 33 36 12

    输出样例:

    4

    3 6 9 26

     

     

     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            Set set = new TreeSet<>();
            String[] s = br.readLine().trim().split(" ");
            for(int i = 0; i < n; i++) {
                int t = Integer.parseInt(s[i]);
                int fNum = 0;
                while(t > 0) {
                    fNum += (t % 10);
                    t /= 10;
                }
                set.add(fNum);
            }
            Iterator iter = set.iterator();
            System.out.println(set.size());
            boolean flag = false;
            while(iter.hasNext()) {
                if(flag) {
                    System.out.print(" " + iter.next());
                }else {
                    System.out.print(iter.next());
                    flag = true;
                }
            }
        }
    }
    阅读全文>>

作者:Jason分类:【pat浏览(177评论(0

2018-09-08

1063. 计算谱半径(20)–PAT乙级真题java实现

    1063. 计算谱半径(20)–PAT乙级真题java实现

    在数学中,矩阵的“谱半径”是指其特征值的模集合的上确界。换言之,对于给定的n个复数空间的特征值{a1+b1i, …, an+bni},它们的模为实部与虚部的平方和的开方,而“谱半径”就是最大模。
    现在给定一些复数空间的特征值,请你计算并输出这些特征值的谱半径。
    输入格式:
    输入第一行给出正整数N(<= 10000)是输入的特征值的个数。随后N行,每行给出1个特征值的实部和虚部,其间以空格分隔。注意:题目保证实部和虚部均为绝对值不超过1000的整数。
    输出格式:
    在一行中输出谱半径,四舍五入保留小数点后2位。
    输入样例:
    5
    0 1
    2 0
    -1 0
    3 3
    0 -3
    输出样例:
    4.24
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            double max = 0;
            for(int i = 0; i < n; i++) {
                String[] s = br.readLine().split(" ");
                int x = Integer.parseInt(s[0]);
                int y = Integer.parseInt(s[1]);
                double cur = Math.sqrt(x * x + y * y);
                if(max < cur) {
                    max = cur;
                }
            }
            System.out.printf("%.2f",max);
        }
    }

     

    阅读全文>>

作者:Jason分类:【pat浏览(184评论(0

2018-09-08
< 1 2 3 4 5 6 7 8 >