7-1 多数组排序 (20分)
3个整数数组进行整体排序，根据输入的三个数组的元素，输出排序后的结果（从大到小）
输入格式:
第1个数组的长度
第1个数组的各个元素
第2个数组的长度
第2个数组的各个元素
第3个数组的长度
第3个数组的各个元素
输出格式:
所有数组的整体排序
输入样例:
在这里给出一组输入。例如：
3
79 80 61
3
88 66 77
2
23 90
输出样例:
在这里给出相应的输出。例如：
90 88 80 79 77 66 61 23
将三个数组复制合并到同一个数组中，再对合并后的数组进行排序
ans：
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String []args)
{
Scanner s=new Scanner(System.in);
int a=s.nextInt();
int i;
int []arr1=new int [a];
for(i=0;i<a;i++)
{
arr1[i]=s.nextInt();
}
int b=s.nextInt();
int []arr2=new int [b];
for(i=0;i<b;i++)
{
arr2[i]=s.nextInt();
}
int c=s.nextInt();
int []arr3=new int [c];
for(i=0;i<c;i++)
{
arr3[i]=s.nextInt();
}
int [] ee = new int[a + b + c];
System.arraycopy(arr1, 0, ee, 0, a);
System.arraycopy(arr2, 0, ee, a, b);
System.arraycopy(arr3, 0, ee, a + b, c);
Arrays.sort(ee);
System.out.print(ee[ee.length-1]);
for(i=ee.length-2;i>=0;i--)
{
System.out.print(" " + ee[i]);
}
s.close();
}
}
7-2 两队PK (20分)
A、B两队进行比赛，每队各有多名队员及其分数（分数不重复），使用A、B队所有队员得分的TOP 3来判断两队输赢，在TOP 3中拥有更多人数的队获胜。写程序实现该过程。
输入格式:
A队人数
A队每人得分
B队人数
B队每人得分
输出格式:
前三甲分数
赢的队
输入样例:
5
22 33 44 55 11
4
12 32 42 52
输出样例:
55 52 44
A
import java.util.Arrays;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int numberA = in.nextInt();
int mid = 0;
int aScores[] = new int[numberA];
for (int i = 0; i < numberA; i++) {
aScores[i] = in.nextInt();
}
Arrays.sort(aScores);
int numberB = in.nextInt();
int bScores[] = new int[numberB];
for (int i = 0; i < numberB; i++) {
bScores[i] = in.nextInt();
}
int cScores[] = new int[numberA+numberB];
System.arraycopy(aScores,0,cScores,0,numberA);
System.arraycopy(bScores,0,cScores,numberA,numberB);
Arrays.sort(cScores);
int aBig = 0;//前三名中A队的人数
int flag = 1;
for (int i = numberA + numberB - 1; i >= numberA + numberB - 3; i--) {
for (int j = numberA - 1; j >= 0; j--) {
if (aScores[j] == cScores[i]) {
aBig++;
}
}
if (aBig > 1) {
flag = 0;//判定A队赢
}
}
//System.out.println(aBig);
for (int i = numberA + numberB - 1; i >= numberA + numberB - 3; i--) {
if (i == numberA + numberB - 1) {
System.out.print(cScores[i]);
} else {
System.out.print(" " + cScores[i]);
}
}
System.out.println();//换行
if (flag == 0) {
System.out.println("A");
} else {
System.out.println("B");
}
}
}
7-3 公司季度销售额以及年销售额统计 (20分)
年底了，某公司要做销售统计，请输入各月份的销售额（单位：万元），请分别统计每季度的以及全年度的公司销售总额。 要求：
1.用一个四行3列数组记录销售额
2.在Main类中写一个方法统计并输出季度以及全年度的销售总额，并输出。方法声明定义为：
public static void showTotal(int [][]sale)
3.在main方法中顶一个二维数组并通过键盘输入各月份的销售总额，然后调用showTotal方法，输出统计结果。
输入格式:
输入在一行中给出12个月份的销售额，中间用空格隔开。
输出格式:
每一行分别输出各季度的销售额总和，最后一行输出年度销售额。
输入样例:
在这里给出一组输入。例如：
22 33 44 33 44 66 77 45 64 43 34 23 45
输出样例:
在这里给出相应的输出。例如：
1季度的销售额为：99
2季度的销售额为：143
3季度的销售额为：186
4季度的销售额为：100
全年销售额为：528
ans;
import java.util.*;
public class Main {
public static void main(String []args)
{
Scanner scanner=new Scanner(System.in);
int [][]a=new int [4][3];
for(int i=0;i<4;i++)
{
for(int j=0;j<3;j++)
{
a[i][j]=scanner.nextInt();
}
}
showTotal(a);
scanner.close();
}
public static void showTotal(int [][]sale)
{
int i,j,a1=0,a2=0,a3=0,a4=0;
for(i=0;i<3;i++)
{
a1+=sale[0][i];
a2+=sale[1][i];
a3+=sale[2][i];
a4+=sale[3][i];
}
System.out.println("1季度的销售额为："+a1);
System.out.println("2季度的销售额为："+a2);
System.out.println("3季度的销售额为："+a3);
System.out.println("4季度的销售额为："+a4);
System.out.println("全年销售额为："+(a1+a2+a3+a4));
}
}
7-4 数组元素的删除 (20分)
完成数组元素的移动功能：假设数组有n个元素，输入一个数x，把数组的第x个位置的元素删除了，后面的元素依次前进一个位置。 重复若干次这样的删除，得到最后的结果。
输入格式:
第一行包括一个整数n（1<=n<=100），表示数组元素的个数。 第二行输入n个数组元素，均为整数，用空格隔开。 第三行输入一个数k（1<=k<=100），表示要进行k次删除。 接下来k行，每行一个数x，表示要删除第x个元素。
输出格式:
输出经过k次删除后的数组，每两个元素之间用空格隔开。
输入样例:
10
1 2 3 4 5 6 7 8 9 10
4
3
2
4
6
输出样例:
1 4 5 7 8 10
容器：
import java.util.Scanner;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
LinkedList<Integer> list = new LinkedList<Integer>();
int n = s.nextInt();
int []a=new int [n];
for(int i=0;i<n;i++) {
list.add(s.nextInt());
}
int k = s.nextInt();
for(int i=0;i<k;i++) {
int index = s.nextInt();
list.remove(index-1);
s.close();
for(int i=0;i<list.size();i++) {
System.out.print(list.get(i));
if(i<list.size()-1) {
System.out.print(" ");
}
}
}
}
数组：
//完成数组元素的移动功能：假设数组有n个元素，输入一个数x，
// 把数组的第x个位置的元素删除了，后面的元素依次前进一个位置。
// 重复若干次这样的删除，得到最后的结果。
//第一行包括一个整数n（1<=n<=100），表示数组元素的个数。
//第二行输入n个数组元素，均为整数，用空格隔开。
//第三行输入一个数k（1<=k<=100），表示要进行k次删除。
//接下来k行，每行一个数x，表示要删除第x个元素。
import java.util.Scanner;
public class ArrayDelete {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int []a=new int [n];
for(int i=0;i<n;i++) {
a[i]=s.nextInt();
}
int k = s.nextInt();
for(int i=0;i<k;i++) {
int x = s.nextInt();
for(int j=x-1;j<n-1;j++)//从第x个元素到第n个元素依次前移
{
a[j]=a[j+1];
}
}
s.close();
System.out.print(a[0]);
for(int i=1;i<n-k;i++)
{
System.out.print(" "+a[i]);
}
}
}
7-5 369寝室 (20分)
369寝室是比较特殊的寝室，因为别的寝室都住了四个人，而369寝室只有三个人。也因为这个原因，寝室里的三位同学感情特别好。但是，毕业在即，三位小伙伴马上要分别。为了在未来的某个日子可以见面，三位小伙伴有了一个约定，假设在未来的某一年，三位小伙伴的年龄的末尾正好出现3、6、9三个数，那么他们会再次相聚。
现在问题来了，假设今年三位小伙伴的年龄分别是x，y，z，那么，他们三人最早几年后可以相聚呢?
输入格式:
输入数据包括三个整数x，y，z，分别表示三位伙伴的年龄。
输出格式:
如果小伙伴最早在n年后可以相见(不包括当前这一年)，那么请输出这个n；如果100年内都不存在这样的情况，输出:so sad!
输入样例:
25 22 28
输出样例:
1
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean sad;
boolean situation1 ,situation2 ,situation3 ;
while (scanner.hasNextInt()) {
sad = false;
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
for(int i = 1; i <= 100; i++) {
situation1 = false;
situation2 = false;
situation3 = false;
if (i == 100) {
sad = true;
}
if ((x + i) % 10 == 3 || (y + i) % 10 == 3 || (z + i) % 10 == 3) {
situation1 = true;
}
if ((x + i) % 10 == 6 || (y + i) % 10 == 6 || (z + i) % 10 == 6) {
situation2 = true;
}
if ((x + i) % 10 == 9 || (y + i) % 10 == 9 || (z + i) % 10 == 9) {
situation3 = true;
}
if (situation1&&situation2&&situation3) {
System.out.println(i);
break;
}
}
if(sad) {
System.out.println("so sad!");
}
}
}
}
7-1 N个数的排序与查 (20分)
从键盘输入N个整数，并输出指定的某个整数在这N个整数中的按照由小到大的顺序排列的位次（最小的位次是1，最大的位次是N，指定的整数如果不在这N个数中，则其位次是-1）
输入格式:
整数个数，指定的整数值
输出格式:
指定的整数的位次
输入样例:
在这里给出一组输入。例如：
3
12 4 7
4
输出样例:
在这里给出相应的输出。例如：
1
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner SC=new Scanner(System.in);
int N=SC.nextInt();
int []a=new int [N];
int i;
for(i=0;i<N;i++)
{
int b=SC.nextInt();
a[i]=b;
}
Arrays.sort(a);
int c=SC.nextInt();
int j=0,flag=0;
while(j<N)
{
if(a[j]==c) {
System.out.print(j+1);
flag=1;
break;
}
j++;
}
if(flag==0)
System.out.print("-1");
SC.close();
}
}
7-2 整数数组比较 (20分)
给定两个整型数组A和B，将A的元素复制到B中，使得两个数组完全相同。再将B数组从小到大排列，将两数组的同一位置上对应的元素进行比较，统计出A中大于B的元素个数，等于B中元素的个数，小于B中的元素的个数。 提示：可用Arrays.sort排序
输入格式:
数组A的个数 数组A元素
输出格式:
A大于B的个数 A等于B的个数 A小于B的个数
输入样例:
在这里给出一组输入。例如：
10
23 1 32 87 65 12 21 9 76 45
输出样例:
在这里给出相应的输出。例如：
4
1
5
ans:
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String []args)
{
Scanner s=new Scanner(System.in);
int n=s.nextInt();
int[] a=new int[n];
int[] b=new int[n];
int eq=0,gt=0,lt=0;
//数据输入
int i;
for(i=0;i<n;i++)
{
int e=s.nextInt();
a[i]=e;
}
b=Arrays.copyOf(a, n);
Arrays.sort(b);
for(i=0;i<n;i++)
{
if(a[i]>b[i])
{
gt++;
}
else if(a[i]<b[i])
{
lt++;
}
else eq++;
}
System.out.println(gt);
System.out.println(eq);
System.out.println(lt);
s.close();
}
}
7-4 购买第3便宜的商品 (20分)
小熊买东西，太便宜的怕质量不好，太贵的买不起。每种东西N个商品（价格可能相同），小熊决定都买第三便宜的东西，输出价格。编写程序，要求：首先输入一个正整数N（N <= 50），接下来输入N个数表示每个商品的价格（价格均是正整数，且小于等于10000）。如果存在第3便宜的商品，则输出这个价格是多少，否则输出-1。
输入格式:
商品的个数N，每个商品的价格
输出格式:
第3便宜的商品的价格
输入样例:
在这里给出一组输入。例如：
10 40 10 10 10 10 20 20 30 30 40
输出样例:
在这里给出相应的输出。例如：
30
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int n=s.nextInt();
int []arr=new int[n];
int []newarr = new int[n];
int i;
for(i=0;i<n;i++)
{
arr[i]=s.nextInt();
}
Arrays.sort(arr);
// for(int j=0;j<arr.length;j++)
// {
// System.out.println(arr[j]);
// }
newarr =deRepetition(arr);
// System.out.println( Arrays.toString(newarr));
if(newarr.length>=3)
System.out.println(newarr[2]);
else
System.out.println(-1);
s.close();
}
//去重
public static int[] deRepetition(int[] arr){
int[] newArr = null;
for (int i = 0; i < arr.length; i++) {
boolean flag = true;
for (int j = i+1; j < arr.length; j++) {
if (arr[i] == arr[j]) {
flag = false;
break;
}
}
if (flag) {
if (newArr == null) {
newArr = new int[1];
newArr[0] = arr[i];
continue;
}
newArr = Arrays.copyOf(newArr,newArr.length+1);
newArr[newArr.length-1] = arr[i];
}
}
return newArr;
}
}
7-5 集合求交 (20分)
从键盘录入1行包含6个整数（整数可以重复）的字符串，前3个整数和后3个整数分别构成2个集合。编写程序，输出这两个集合的交集中的元素个数。
输入格式:
键盘录入的1行包含6个整数（整数可以重复）的字符串
输出格式:
前3个整数和后3个整数构成的2个集合的交集中的元素个数
输入样例:
在这里给出一组输入。例如：
12 14 22 12 16 22
输出样例:
在这里给出相应的输出。例如：
2
//从键盘录入1行包含6个整数（整数可以重复）的字符串，前3个整数和后3个整数分别构成2个集合。编写程序，输出这两个集合的交集中的元素个数。
import java.util.Arrays;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
String s = cin.nextLine();
String[] t = s.split(" ");
int[] a = new int[t.length];
int i;
for (i = 0; i < a.length; i++) {
a[i] = Integer.parseInt(t[i]);
// System.out.print(a[i]+" ");
}
int[] arr1 = new int[3];
int[] arr2 = new int[3];
for (i = 0; i < 3; i++) {
arr1[i] = a[i];
}
for (i = 0; i < 3; i++) {
arr2[i] = a[i + 3];
}
int[]newarr1=deRepetition(arr1);//剔除数组中的重复元素
int[]newarr2=deRepetition(arr2);
int count = 0, j;
for (i = 0; i < newarr1.length; i++) {
for (j = 0; j < newarr2.length; j++) {
if (newarr1[i] == newarr2[j])
count++;
}
}
System.out.print(count);
cin.close();
}
public static int[] deRepetition(int[] arr){
int[] newArr = null;
for (int i = 0; i < arr.length; i++) {
boolean flag = true;
for (int j = i+1; j < arr.length; j++) {
if (arr[i] == arr[j]) {
flag = false;
break;
}
}
if (flag) {
if (newArr == null) {
newArr = new int[1];
newArr[0] = arr[i];
continue;
}
newArr = Arrays.copyOf(newArr,newArr.length+1);
newArr[newArr.length-1] = arr[i];
}
}
return newArr;
}
}
7-3 解析二维数组 (20分)
读入一个字符串，该字符串表示一个整型二维数组d，数组中的元素通过解析字符串参数获得。例如，字符串参数：“1,2;3,4,5;6,7,8”，对应的数组为： d[0,0] = 1 d[0,1] = 2
d[1,0] = 3 d[1,1] = 4 d[1,2] = 5 d[2,0] = 6 d[2,1] = 7 d[2,2] = 8 打印这个数组各元素的内容
输入格式:
字符串
输出格式:
二维数组各元素
输入样例:
在这里给出一组输入。例如：
1,2;3,4,5;6,7,8
输出样例:
在这里给出相应的输出。例如：
d[0,0] = 1 d[0,1] = 2
d[1,0] = 3 d[1,1] = 4 d[1,2] = 5
d[2,0] = 6 d[2,1] = 7 d[2,2] = 8
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
String a=s.nextLine();
String [] a1=a.split(";");//将a以;分为几个数组，存入a1
int [][] arr=new int [a1.length][];//分配第一维空间
int i,j;
for(i=0;i<a1.length;i++)
{
String[] a2=a1[i].split(",");//将a1[i]以,分割，存入a2
arr[i]=new int[a2.length]; //分配第二维空间
}
for(i=0; i<a1.length;i++)
{
String[] a2=a1[i].split(",");
for(j=0;j<a2.length;j++)
{
arr[i][j]=Integer.parseInt(a2[j]);//将字符串转化为int
}
}
for(i=0;i<arr.length;i++)
{
for(j=0;j<arr[i].length;j++)
{
if(j==0)
System.out.print("d["+i+","+j+"]"+" "+"="+" "+arr[i][j]);
else
System.out.print(" "+"d["+i+","+j+"]"+" "+"="+" "+arr[i][j]);
}
System.out.println();
}
s.close();
}
}
7-6 矩阵类 (20分)
利用二维数组（int[]）实现一个矩阵类：Matrix。要求提供以下方法：（1）set（int row, int col, int value）：将第row行第col列的元素赋值为value；（2）get（int row，int col）：取第row行第col列的元素；（3）width()：返回矩阵的列数；（4）height()：返回矩阵的行数；（5）Matrix add（Matrix b）：返回当前矩阵与矩阵b相加后的矩阵；（6）Matrix multiply（Matrix b）：返回当前矩阵与矩阵b相乘后的矩阵。（7）Matrix transpose()：返回当前矩阵的转置矩阵；（8）toString()：以行和列的形式打印出当前矩阵。
输入格式:
矩阵的行列数 矩阵的数据 设置矩阵值的行、列和值 获取矩阵值的行、列 待相加矩阵的行列数 待相加矩阵的值 待相乘矩阵的行列数 待相乘矩阵的值
输出格式:
矩阵的行、列数 设置矩阵值后的矩阵 某行某列的矩阵值 矩阵相加结果 矩阵相乘结果 矩阵转置结果
输入样例:
在这里给出一组输入。例如：
3 3
1 2 3
4 5 6
7 8 9
2 3 8
1 3
3 3
1 2 3
4 5 6
7 8 9
3 2
1 2
1 2
1 2
输出样例:
在这里给出相应的输出。例如：
row:3 column:3
after set value:
1 2 3
4 5 8
7 8 9
value on (1,3):3
after add:
2 4 6
8 10 14
14 16 18
after multiply:
6 12
17 34
24 48
after transpose:
1 4 7
2 5 8
3 8 9
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
int r=cin.nextInt();//输入行
int c=cin.nextInt();//输入列
Matrix matrix=new Matrix(r,c);
System.out.println("row:"+matrix.height()+" "+"column:"+matrix.width());
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
int v=cin.nextInt();
matrix.set(i,j,v);
}
}
int r1=cin.nextInt();
int c1=cin.nextInt();
int v1=cin.nextInt();
int nr1=r1-1;int nc1=c1-1;
matrix.set(nr1,nc1,v1);
System.out.println("after set value:");
matrix.print();
int r2=cin.nextInt();
int c2=cin.nextInt();
int va=matrix.get(r2,c2);
System.out.println("value on ("+r2+","+c2+"):"+va);
//输入相加矩阵
int r3=cin.nextInt();//输入行
int c3=cin.nextInt();//输入列
Matrix matrix1=new Matrix(r3,c3);
for (int i = 0; i < r3; i++) {
for (int j = 0; j < c3; j++) {
int v3=cin.nextInt();
matrix1.set(i,j,v3);
}
}
Matrix matrix2= matrix.add(matrix1);
System.out.println("after add:");
matrix2.print();
//输入相乘矩阵
int r4=cin.nextInt();//输入行
int c4=cin.nextInt();//输入列
Matrix matrix3=new Matrix(r4,c4);
for (int i = 0; i < r4; i++) {
for (int j = 0; j < c4; j++) {
int v4=cin.nextInt();
matrix3.set(i,j,v4);
}
}
Matrix matrix4= matrix.multiply(matrix3);
System.out.println("after multiply:");
matrix4.print();
System.out.println("after transpose:");
Matrix matrix5=matrix.transpose();
matrix5.print();
cin.close();
}
}
class Matrix
{
private final int R=3;
private final int C=3;
private int row;//行
private int col;//列
//private int value;//值
private int[][] matrix;
public Matrix()//构造函数
{
matrix=new int[row][col];
row=R;
col=C;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
matrix[i][j]=0;
}
}
}
public Matrix(int row,int col)//构造函数
{
matrix=new int[row][col];
this.col=col;
this.row=row;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
matrix[i][j]=0;
}
}
}
public boolean set(int row,int col,int value)
{
if(row>this.row||col>this.col)
return false;
else
{
matrix[row][col]=value;
return true;
}
}
public int get(int row,int col)
{
return matrix[row-1][col-1];
//java.lang.ArrayIndexOutOfBoundsException数组越界
}
public int width()
{
return col;
}
public int height()
{
return row;
}
public Matrix add(Matrix b) {
if (b.row == row && b.col == col) {
Matrix m = new Matrix(row, col);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
m.matrix[i][j] = matrix[i][j] + b.matrix[i][j];
}
}
return m;
}
else {
System.out.println("ERRPR!");
return null;
}
}
public Matrix multiply(Matrix b){
if(b.row!=col)
return null;
else
{
Matrix c=new Matrix(row,b.col);
for (int i = 0; i < row; i++) {
for (int j = 0; j < b.col; j++) {
for (int k = 0; k <row; k++) {
c.matrix[i][j]+=matrix[i][k]*b.matrix[k][j];
}
}
}
return c;
}
}
public Matrix transpose()
{
Matrix d=new Matrix(row,col);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
d.matrix[i][j]=matrix[j][i];
}
}
return d;
}
public void print()
{
for (int i = 0; i < row; i++) {
for (int j = 0; j <col ; j++) {
if(j==0)
System.out.print(matrix[i][j]);
else
System.out.print(" "+matrix[i][j]);
}
System.out.println();
}
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
