小景哥哥

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

强烈推荐

1060. 爱丁顿数(25)–PAT乙级真题java实现

    1060. 爱丁顿数(25)–PAT乙级真题java实现

    英国天文学家爱丁顿很喜欢骑车。据说他为了炫耀自己的骑车功力,还定义了一个“爱丁顿数”E,即满足有E天骑车超过E英里的最大整数E。据说爱丁顿自己的E等于87。

    现给定某人N天的骑车距离,请你算出对应的爱丁顿数E(<=N)。

    输入格式:

    输入第一行给出一个正整数N(<=105),即连续骑车的天数;第二行给出N个非负整数,代表每天的骑车距离。

    输出格式:

    在一行中给出N天的爱丁顿数。

    输入样例:

    10

    6 7 6 9 3 10 8 2 7 8

    输出样例:

    6

    package top.jinglisen.pat;
    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());
            String[] s = br.readLine().trim().split(" ");
            int i = 0;
            for(i = N ; i > 0; i--) {
                int cur = 0;
                for(int j = 0; j < N; j++) {
                    if(Integer.parseInt(s[j]) > i)
                        cur++;
                }
                if(cur >= i) {
                    break;
                }
            }
            System.out.println(i);
        }
    }

     

    阅读全文>>

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

2018-09-08

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

1020.月饼(25)--浙大PAT乙级真题java实现

    1020. 月饼 (25)
    月饼是中国人在中秋佳节时吃的一种传统食品,不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量,请你计算可以获得的最大收益是多少。
    注意:销售时允许取出一部分库存。样例给出的情形是这样的:假如我们有3种月饼,其库存量分别为18、15、10万吨,总售价分别为75、72、45亿元。如果市场的最大需求量只有20万吨,那么我们最大收益策略应该是卖出全部15万吨第2种月饼、以及5万吨第3种月饼,获得 72 + 45/2 = 94.5(亿元)。
    输入格式:
    每个输入包含1个测试用例。每个测试用例先给出一个不超过1000的正整数N表示月饼的种类数、以及不超过500(以万吨为单位)的正整数D表示市场最大需求量。随后一行给出N个正数表示每种月饼的库存量(以万吨为单位);最后一行给出N个正数表示每种月饼的总售价(以亿元为单位)。数字间以空格分隔。
    输出格式:
    对每组测试用例,在一行中输出最大收益,以亿元为单位并精确到小数点后2位。
    输入样例:
    3 20
    18 15 10
    75 72 45
    输出样例:
    94.50


    阅读全文>>

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

2018-01-17

1030. 完美数列(25)-浙大PAT乙级真题java实现

    1030. 完美数列(25) 
    给定一个正整数数列,和正整数p,设这个数列中的最大值是M,最小值是m,如果M <= m * p,则称这个数列是完美数列。 
    现在给定参数p和一些正整数,请你从中选择尽可能多的数构成一个完美数列。 
    输入格式: 
    输入第一行给出两个正整数N和p,其中N(<= 10^5)是输入的正整数的个数,p(<= 10^9)是给定的参数。第二行给出N个正整数,每个数不超过10^9。 
    输出格式: 
    在一行中输出最多可以选择多少个数可以用它们组成一个完美数列。 
    输入样例: 
    10 8 
    2 3 20 4 5 1 6 7 8 9 
    输出样例: 
    8


    阅读全文>>

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

2018-01-19

变态跳台阶

    9.变态跳台阶

    题目描述
    一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

    解题思路:

    关于本题,前提是n个台阶会有一次n阶的跳法。分析如下:

            f(1) = 1

            f(2) = f(2-1) + f(2-2)         //f(2-2) 表示2阶一次跳2阶的次数。

            f(3) = f(3-1) + f(3-2) + f(3-3) 

            ...

            f(n) = f(n-1) + f(n-2) + f(n-3) + ... + f(n-(n-1)) + f(n-n) 

            说明: 

            1)这里的f(n) 代表的是n个台阶有一次1,2,...n阶的 跳法数。

            2)n = 1时,只有1种跳法,f(1) = 1

            3) n = 2时,会有两个跳得方式,一次1阶或者2阶,这回归到了问题(1) ,f(2) = f(2-1) + f(2-2) 

            4) n = 3时,会有三种跳得方式,1阶、2阶、3阶,

                那么就是第一次跳出1阶后面剩下:f(3-1);第一次跳出2阶,剩下f(3-2);第一次3阶,那么剩下f(3-3)

                因此结论是f(3) = f(3-1)+f(3-2)+f(3-3)

            5) n = n时,会有n中跳的方式,1阶、2阶...n阶,得出结论:

                f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)  

            6) 由以上已经是一种结论,但是为了简单,我们可以继续简化:

                f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)

                f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)

                可以得出:

                f(n) = 2*f(n-1)

            7) 得出最终结论,在n阶台阶,一次有1、2、...n阶的跳的方式时,总得跳法为:

                       | 1       ,(n=0 ) 

            f(n) =  | 1       ,(n=1 )

                       | 2*f(n-1),(n>=2)

    //java代码实现
      public class Solution {

      public int JumpFloorII(int target) {
            if (target <= 0) {
                return -1;
            } else if (target == 1) {
                return 1;
            } else {
                return 2 * JumpFloorII(target - 1);
            }
        }

        //Another solution
        public int JumpFloorII2(int target){
            int a=1; 
            return a<<(target-1);
        }
    }

    阅读全文>>

作者:Jason分类:【offer浏览(168评论(0

2018-08-10

1046. 划拳(15)-浙大PAT乙级真题java实现

    1046. 划拳(15) 
    划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为:每人口中喊出一个数字,同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和,谁就赢了,输家罚一杯酒。两人同赢或两人同输则继续下一轮,直到唯一的赢家出现。 
    下面给出甲、乙两人的划拳记录,请你统计他们最后分别喝了多少杯酒。 
    输入格式: 
    输入第一行先给出一个正整数N(<=100),随后N行,每行给出一轮划拳的记录,格式为: 
    甲喊 甲划 乙喊 乙划 
    其中“喊”是喊出的数字,“划”是划出的数字,均为不超过100的正整数(两只手一起划)。 
    输出格式: 
    在一行中先后输出甲、乙两人喝酒的杯数,其间以一个空格分隔。 
    输入样例: 

    8 10 9 12 
    5 10 5 10 
    3 8 5 12 
    12 18 1 13 
    4 16 12 15 
    输出样例: 
    1 2


    阅读全文>>

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

2018-01-24

1009. 说反话 (20)-浙大PAT乙级真题java实现

    1009. 说反话 (20)
    给定一句英语,要求你编写程序,将句中所有单词的顺序颠倒输出。
    输入格式:测试输入包含一个测试用例,在一行内给出总长度不超过80的字符串。字符串由若干单词和若干空格组成,其中单词是由英文字母(大小写有区分)组成的字符串,单词之间用1个空格分开,输入保证句子末尾没有多余的空格。
    输出格式:每个测试用例的输出占一行,输出倒序后的句子。
    输入样例:
    Hello World Here I Come
    输出样例:
    输入样例:
    Come I Here World Hello 


    阅读全文>>

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

2018-01-04

1022. D进制的A+B (20)-浙大PAT乙级真题java实现

    1022. D进制的A+B (20) 
    输入两个非负10进制整数A和B(<=2^30-1),输出A+B的D (1 < D <= 10)进制数。 
    输入格式: 
    输入在一行中依次给出3个整数A、B和D。 
    输出格式: 
    输出A+B的D进制数。 
    输入样例: 
    123 456 8 
    输出样例: 
    1103


    阅读全文>>

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

2018-01-17

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

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