【蓝桥杯省赛】冲刺练习题【数组】倒计时【13】天

​ ????????距离​【第十三届蓝桥杯4月9日省赛】仅剩​【13天】????????​

????今日题型：【数组】????

⭐️????循环是一切暴力的基础，暴力基础，转起来。????⭐️

????国一镇楼????

????比赛题目与分数比例????

​确认范围：​

结果填空题5道，共计45分。

程序设计题5道，共计105分。

⭐️????刷题安排????⭐️

​目录​

​​1、逆序输出数组元素​​

​​2、数组求和​​

​​3、数列排序​​

​​4、打印杨辉三角​​

​​5、芯片测试​​

​​6、矩形靶​​

​​附加1、最大获利​​

​​附加2、比较​​

1、逆序输出数组元素

资源限制

时间限制：1.0s   内存限制：512.0MB

　　编写一个程序，输入10个整数（为100以内非负整数）存入一维数组，按逆序重新存放后再输出。

样例输入

0 1 4 2 3 5 8 9 7 6

样例输出

6 7 9 8 5 3 2 4 1 0

import java.util.Scanner;

public class demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arr = new int[10];
    for (int i = 0; i < arr.length; i++) {
      arr[i] = sc.nextInt();
    }
    sc.close();
    for (int j = arr.length - 1; j >= 0; j--) {
      System.out.print(arr[j] + " ");
    }
  }
}

2、数组求和

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　输入n个数，围成一圈，求连续m（m<n）个数的和最大为多少？

输入格式

　　输入的第一行包含两个整数n, m。第二行，共n个整数。

输出格式

　　输出1行，包含一个整数，连续m个数之和的最大值。

样例输入

10 3

9 10 1 5 9 3 2 6 7 4

样例输出

23

数据规模和约定

　　0<m<n<1000, -32768<=输入的每个数<=32767。

import java.util.Scanner;

public class demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m = sc.nextInt();
    int[] num = new int[n + m];
    for (int i = 0; i < n; i++) {
      num[i] = sc.nextInt();
    }
    sc.close();
    for (int i = n; i < n + m; i++) {
      num[i] = num[i - n];
    }
    int max = 0, sum = 0;
    for (int i = 0; i < m; i++)
      sum += num[i];
    for (int i = m; i < m + n; i++) {
      sum = sum - num[i - m] + num[i];
      max = Math.max(max, sum);
    }
    System.out.println(max);
  }
}

3、数列排序

资源限制

时间限制：1.0s   内存限制：512.0MB

问题描述

　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

　　第一行为一个整数n。

　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式

　　输出一行，按从小到大的顺序输出排序后的数列。

样例输入

5

8 3 6 4 9

样例输出

3 4 6 8 9

import java.util.Arrays;
import java.util.Scanner;

public class demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int nums[] = new int[n];
    for (int x = 0; x < n; x++) {
      nums[x] = sc.nextInt();
    }
    sc.close();
    Arrays.sort(nums);
    for (int x : nums) {
      System.out.print(x + " ");
    }
  }
}

4、打印杨辉三角

杨辉三角的特点：

1、有多少行就有多少列

2、每一行的第一列和最后一列都为1

3、每个数等于它上方两个数的和（也就是每个数等于这一列上一行的数和这一列上一行前一个数的和）

import java.util.Scanner;

public class demo {
  public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    sc.close();
    int[][] arr = new int[n][n];
    for (int i = 0; i < arr.length; i++) {
      for (int j = 0; j < arr.length; j++) {
        arr[i][0] = 1;
        arr[i][j] = 1;
      }
    }

    for (int i = 2; i < arr.length; i++) {
      for (int j = 1; j < i; j++) {
        arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
      }
    }

    for (int i = 0; i < arr.length; i++) {
      for (int j = 0; j < i + 1; j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}

5、芯片测试

问题描述

　　有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。

　　每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。

　　给出所有芯片的测试结果，问哪些芯片是好芯片。

输入格式

　　输入数据第一行为一个整数n，表示芯片个数。

　　第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。

输出格式

　　按从小到大的顺序输出所有好芯片的编号

样例输入

3

1 0 1

0 1 0

1 0 1

样例输出

1 3

import java.util.Scanner;

public class demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m[][] = new int[20][20];

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        m[i][j] = sc.nextInt();
      }
    }
    sc.close();
    for (int j = 0; j < n; j++) {
      int ref = 0;
      for (int i = 0; i < n; i++) {
        if (i != j)
          ref += m[i][j];
      }
      if (ref >= n / 2) {
        System.out.print((j + 1) + " ");
      }
    }
  }
}

6、矩形靶

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　在矩形的世界里任何事物都是矩形的，矩形的枪靶，甚至矩形的子弹。现在给你一张N*M的枪靶，同时告诉你子弹的大小为(2l+1)*(2r+1)。读入一张01的图每个点的01状态分别表示这个点是否被子弹的中心击中（1表示被击中，0则没有）一旦一个点被子弹的中心击中，那么以这个点为中心 (2l+1)*(2r+1) 范围内靶子上的点都会被击毁。要求输出最终靶子的状态。

输入格式

　　第一行为N，M，L,R表示靶子的大小，以及子弹的大小。

　　下面读入一个N*M的01矩阵表示每个点是否被子弹的中心击中

输出格式

　　N*M的01矩阵表示靶子上的每个点是否被破坏掉

样例输入

4 4 1 1

1000

0000

0000

0010

样例输出

1100

1100

0111

0111

样例输入

7 4 1 1

1000

0000

0010

0000

0000

0000

0100

样例输出

1100

1111

0111

0111

0000

1110

1110

数据规模和约定

　　N,M<=600,l,r<=5

package test;

import java.util.Scanner;

public class demo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m = sc.nextInt();
    int l = sc.nextInt();
    int r = sc.nextInt();
    char[][] str = new char[n][m];
    char[][] a = new char[n][m];
    for (int i = 0; i < n; i++) {
      String s = sc.nextLine();
      if (s.equals("")) {
        s = sc.nextLine();
      }
      str[i] = s.toCharArray();
      a[i] = s.toCharArray();
    }
    sc.close();
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (str[i][j] == '1') {
          for (int i1 = i - l < 0 ? 0 : i - l; i1 <= i + l && i1 < n; i1++) {
            for (int j1 = j - r < 0 ? 0 : j - r; j1 <= j + r && j1 < m; j1++) {
              a[i1][j1] = '1';
            }
          }
        }
      }
    }
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        System.out.print(a[i][j]);
      }
      System.out.println();
    }
  }
}

附加1、最大获利

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　Chakra是一位年轻有为的企业家，最近他在进军餐饮行业。他在各地开拓市场，共买下了N个饭店。在初期的市场调研中，他将一天划分为M个时间段，并且知道第i个饭店在第j个时间段内，会有Aij位服务员当值和Bij位客户光临。他还分析了不同饭店不同时间段客户的需求，得到第i个饭店在第j个时间段内，平均每位客户消费Cij元。为了创设品牌形象，Chakra决定每个饭店每天只选择一个时间段营业，每个服务员至多接待一位顾客（若顾客数多于服务员数，超过部分的顾客当天就无法在该店消费了）。

　　企业家的目的终究还是获利。请你安排营业时间，并告诉Chakra每天消费总额最多为多少。

输入格式

　　第一行两个整数，N、M。

　　第二行开始依次给出三个矩阵A(N*M)、B(N*M)、C(N*M)。

输出格式

　　一行一个整数，最大消费总额。

样例输入

2 3

1 2 3

3 2 1

3 2 1

1 2 3

4 5 2

3 1 6

样例输出

16

数据规模和约定

　　1 <= M,N <= 100

　　1 <= Aij, Bij <= 5000

　　0 <= Cij <= 10^9

​题解：​

import java.io.*;
import java.util.*;

public class Main{
  public static void main(String[] arge) throws IOException{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String[] data = reader.readLine().split(" ");
    
    int N = Integer.parseInt(data[0]);
    int M = Integer.parseInt(data[1]);
    
    long[][] A = new long[N][M];
    long[][] B = new long[N][M];
    long[][] C = new long[N][M];
    
    for(int i = 0; i < N; ++i){
      String[] temp = reader.readLine().split(" ");
      for(int j = 0; j < M; ++j){
        long num = Long.parseLong(temp[j]);
        A[i][j] = num;
      }
    }
    
    for(int i = 0; i < N; ++i){
      String[] temp = reader.readLine().split(" ");
      for(int j = 0; j < M; ++j){
        long num = Long.parseLong(temp[j]);
        B[i][j] = num;
      }
    }
    
    for(int i = 0; i < N; ++i){
      String[] temp = reader.readLine().split(" ");
      for(int j = 0; j < M; ++j){
        long num = Long.parseLong(temp[j]);
        C[i][j] = num;
      }
    }
    long res = 0;
    for(int i = 0; i < N; ++i){
      long max = 0;
      for(int j = 0; j < M; ++j){
        long a = A[i][j];
        long b = B[i][j];
        long c = C[i][j];
        max = Math.max(max,Math.min(a,b)*c);
      }
      
      res += max;
    }
    
    System.out.println(res);
    
    reader.close();
    
  }
  
}

附加2、比较

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　给出一个n长的数列，再进行m次询问，每次询问询问两个区间[L1,R1]，[L2,R2]，

　　询问数列第L2到R2个数字每一个数在数列第L1到R1个数中有多少个数字不大于它。

输入格式

　　第一行两个整数n,m

　　第二行n个整数，表示数列。

　　接下来m行，每行四个整数L1,R1,L2,R2，意义如上

输出格式

　　m行，每行R2-L2+1个整数，第一个整数表示第L2个数在数列第L1到R1个数中不大于它的个数，第一个整数表示第L2+1个数在数列第L1到R1个数中不大于它的个数，以此类推

样例输入

5 3

5 2 3 4 1

1 2 3 4

2 3 1 5

1 5 2 3

样例输出

1 1

2 1 2 2 0

2 3

数据规模和约定

　　n,m<=1000，数列的数字非负且小于1000。

import java.io.*;
import java.util.*;
public class Main {
    static int n,m,k,arr[],idx;
    static List<Integer> list=new ArrayList<>();
    static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in = new StreamTokenizer(bf);
    static PrintWriter out = new PrintWriter(System.out);
    public static void main(String[] args) throws IOException {
        solve();
        out.flush();
    }
    static void solve() throws IOException {
        in.nextToken();n=(int)in.nval;
        in.nextToken();m=(int)in.nval;
        in.nextToken();k=(int)in.nval;
        arr=new int[n];idx=0;
        for(int i=0;i<n;++i){
            in.nextToken();arr[i]=(int)in.nval;
        }
        for(int i=0;i<m;++i){
            in.nextToken();int move=(int)in.nval;
            idx+=move;
            while(idx<0) idx+=n;
            idx%=n;
            for(int j=idx;j<idx+k;++j){
                out.print(arr[j%n]+" ");
            }
            out.println();
        }
    }
}