【蓝桥杯省赛】冲刺练习题【数组】倒计时【13】天
目录
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();
}
}
}腾讯云开发者
