省赛 蓝桥杯 2019 Java c

#A 求和

问题描述

小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包 括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。 请问，在 1 到 2019 中，所有这样的数的和是多少？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分

package Java2019;

import java.awt.Checkbox;

public class 第一题 {

  public static void main(String[] args) {
    int a = 2019 ,sum = 0;
    for (int i = 1; i <= a; i++) {
      if (Check(i)) {
        sum=sum+i;
      }  
    }
    System.out.println(sum);
  }

  private static boolean Check(int n) {
    do switch (n % 10) {
    case 2:
    case 0:  
    case 1:
    case 9:return true;  
  }while(0 != (n /= 10));
    return false;
  }
}

#B 矩形切割

问题描述

小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。
当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为 5 和 3 的材料（记为 5×3），小明会依次切出 3×3、2×2、1×1、1×1 共 4 个正方形。 现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会 切出多少个正方形？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

package Java2019;

public class 第二题 {

  public static void main(String[] args) {
    int x = 2019;
    int y = 324;
    int count = 0;
    
    while (x != 0 && y != 0) {
      if (x>y) {
        x = x - y;
      }else {
        y = y - x; 
      }
      count ++;
    }
    System.out.println(count);
  }
}

#C 不同子串

问题描述

一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？

package Java2019;

import java.awt.List;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class 第三题 {
  static Set<String> set;
  static String string = "0100110001010001";
  
  public static void main(String[] args) {
    set = new HashSet(); 
    dfs(0,0);
    set.remove("");
    System.out.println(set.size());
  }

  private static void dfs(int d, int start) {
    if (d == string.length()) set.add(string.substring(start));
    else {
      set.add(string.substring(start,d));
      dfs(d+1, d);
      dfs(d+1, start);
    }
  }
  
  /*
  public static void main(String[] args) {
    
    String string = "0100110001010001";
    
     java.util.List<String> list = new ArrayList<String>();
    
    for (int i = 1; i < 16; i++) {
      for (int j = 1; j < 17 - i; j++) {
        string.substring(j,j+i);
      }
      if (!list.contains(string)) {
        list.add(string);
      }
    }
    System.out.println(list.size());
  }*/
     
}

#D 质数

问题描述

我们知道第一个质数是 2、第二个质数是 3、第三个质数是 5……请你计算 第 2019 个质数是多少？

package Java2019;

public class 第四题 {

  public static void main(String[] args) {
    int count = 0;
    for (int i = 2; i < 10000000; i++) {
      if (zhi(i)) {
        count++;
      }
      if (count == 2019) {
        System.out.println(i);
        return;
      }
    }
  } 
  
  public static boolean zhi(int a) {
    
    for (int i = 2; i < a; i++) {
      if (a % i == 0) {
        return false;
      }
    }
    return true;
  }
}

#E 最大降雨量

问题描述

由于沙之国长年干旱，法师小明准备施展自己的一个神秘法术来求雨。 这个法术需要用到他手中的 49 张法术符，上面分别写着 1 至 49 这 49 个 数字。法术一共持续 7 周，每天小明都要使用一张法术符，法术符不能重复使 用。 每周，小明施展法术产生的能量为这周 7 张法术符上数字的中位数。法术 施展完 7 周后，求雨将获得成功，降雨量为 7 周能量的中位数。 由于干旱太久，小明希望这次求雨的降雨量尽可能大，请大最大值是多少？

package Java2019;

public class 第五题 {

  public static void main(String[] args) {
    System.out.println(7 * 7 - 4 *4 +1);
  }

}

#F 旋转

问题描述

图片旋转是对图片最简单的处理方式之一，在本题中，你需要对图片顺时 针旋转 90 度。 我们用一个 n×m 的二维数组来表示一个图片，例如下面给出一个 3×4 的 图片的例子：

1 3 5 7
9 8 7 6
3 5 9 7

这个图片顺时针旋转 90 度后的图片如下：

3 9 1
5 8 3
9 7 5
7 6 7

给定初始图片，请计算旋转后的图片。

输入格式

输入的第一行包含两个整数 n 和 m，分别表示行数和列数。 接下来 n 行，每行 m 个整数，表示给定的图片。图片中的每个元素（像 素）为一个值为 0 至 255 之间的整数（包含 0 和 255）。

---

输出格式

输出 m 行 n 列，表示旋转后的图片。

测试样例1

Input：
3 4
1 3 5 7
9 8 7 6
3 5 9 7

Output：
3 9 1
5 8 3
9 7 5
7 6 7 

评测用例规模与约定

对于 30% 的评测用例，1≤n,m≤10。
对于 60% 的评测用例，1≤n,m≤30。
对于所有评测用例，1≤n,m≤100。

package Java2019;

import java.util.Scanner;

public class 第六题 {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m = sc.nextInt();
    int[][] arr = new int[n][m];
    
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = sc.nextInt();
      }
      System.out.println();
    }
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        System.out.print(arr[n-j-1][i]+" ");
      }
      System.out.println();
    }
  }
}

#G 外卖店优先级

问题描述

“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。 每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。 如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。 给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优 先缓存中。

输入格式

第一行包含 3 个整数 N、M 和 T。
以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。

输出格式

输出一个整数代表答案。

package Java2019;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class 第七题 {

    static final int TMod = 131071;

    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        int res = 0;
        in.nextToken();
        in.nextToken();
        int m = (int)in.nval;
        in.nextToken();
        int t = (int)in.nval;
        int[] queue = new int[m + 1];
        queue[m] = Integer.MAX_VALUE;
        for (int i = 0, T; i < m; i++) {
            in.nextToken();
            T = (int)in.nval;
            in.nextToken();
            queue[i] = ((int)in.nval << 17) | T;
        }
        Arrays.sort(queue);
        boolean last = false;
        for (int i = 0, pre = 0, now, preI = 0, preT = 0, cnt = 0; i <= m; i++) {
            now = queue[i];
            if (pre == now) cnt += 2;
            else if (now >> 17 > preI) {
                if (t > preT) cnt -= t - preT;
                if (cnt > 5 || (last && cnt > 3)) res++;
                preT = now & TMod;
                preI = now >> 17;
                cnt = 2;
                continue;
            } else {
                cnt += preT;
                preT = now & TMod;
                cnt -= preT - 1;
                if (cnt <= 3) last = false;
                if (cnt <= 0) cnt = 2;
                else cnt += 2;
            }
            if (cnt > 5) last = true;
            else if (cnt < 0) cnt = 0;
            else if (cnt <= 3) last = false;
            pre = now;
        }
        System.out.print(res);
    }
}

#H 人物相关性分析

问题描述

小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob有多少次同时出现。
更准确的说，小明定义 Alice 和 Bob“同时出现”的意思是：在小说文本中 Alice 和 Bob 之间不超过 K 个字符。
例如以下文本：
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
假设 K = 20，则 Alice 和 Bob 同时出现了 2 次，分别是”Alice and Bob”和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符，后者有 2 个字符。
注意:

Alice 和 Bob 是大小写敏感的， alice 或 bob 等并不计算在内。
Alice 和 Bob 应为单独的单词，前后可以有标点符号和空格，但是不能有字母。例如 Bobbi 並不算出现了 Bob。

输入格式

第一行包含一个整数 K。
第二行包含一行字符串，只包含大小写字母、标点符号和空格。长度不超过 1000000。

输出格式

输出一个整数，表示 Alice 和 Bob 同时出现的次数。

package Java2019;

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class 第八题 {

    static final char[] bob = { 'B', 'o', 'b' };
    static final char[] alice = { 'A', 'l', 'i', 'c', 'e' };

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int k = Integer.parseInt(in.readLine()), cnt = 0;
        Queue<Integer> preA = new LinkedList();
        Queue<Integer> preB = new LinkedList();
        String story = in.readLine();
        int high = story.length();
        for (int i = 0, a = 0, b = 0; i < high; i++) {
            char now = story.charAt(i);
            if (preA.size() > 0 && preA.peek() + k + 3 < i) preA.poll();
            if (preB.size() > 0 && preB.peek() + k + 5 < i) preB.poll();
            if (now == alice[a++]) {
                if (a == 1 &&  isLetter(i > 0? story.charAt(i - 1): ' ')) a = 0;
                else if (a == 5) {
                    a = 0;
                    preA.offer(i);
                    cnt += preB.size();
                }
            } else if (now == bob[b++]) {
                a = 0;
                if (b == 1 &&  isLetter(i > 0? story.charAt(i - 1): ' ')) b = 0;
                else if(b == 3) {
                    b = 0;
                    preB.offer(i);
                    cnt += preA.size();
                }
            } else a = b = 0;
        }
        System.out.println(cnt);
    }

    static boolean isLetter(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); }
}