71:变幻的矩阵
描述
有一个N x N（N为奇数，且1 <= N <= 10）的矩阵，矩阵中的元素都是字符。这个矩阵可能会按照如下的几种变幻法则之一进行变幻（只会变幻一次）。现在给出一个原始的矩阵，和一个变幻后的矩阵，请编写一个程序，来判定原始矩阵是按照哪一种法则变幻为目标矩阵的。
1. 按照顺时针方向旋转90度；
如：
1 2 3 7 4 1 4 5 6 变幻为 8 5 2 7 8 9 9 6 3 2. 按照逆时针方向旋转90度； 如： 1 2 3 3 6 9 4 5 6 变幻为 2 5 8 7 8 9 1 4 7 3. 中央元素不变（如下例中的 5），其他元素（如下例中的3）与“以中央元素为中心的对应元素”（如下例中的7）互换； 如： 1 2 3 9 8 7 4 5 6 变幻为 6 5 4 7 8 9 3 2 1 4. 保持原始矩阵，不变幻； 5. 如果从原始矩阵到目标矩阵的变幻，不符合任何上述变幻，请输出5
输入
第一行：矩阵每行/列元素的个数 N；
第二行到第N+1行：原始矩阵，共N行，每行N个字符；
第N+2行到第2*N+1行：目标矩阵，共N行，每行N个字符；
输出
只有一行，从原始矩阵 到 目标矩阵 的所采取的 变幻法则的编号。
样例输入
5 a b c d e f g h i j k l m n o p q r s t u v w x y y x w v u t s r q p o n m l k j i h g f e d c b a
样例输出
3
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
String a[][]=new String[n][n];
String b[][]=new String[n][n];
int sum1=0,sum2=0,sum3=0,sum4=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
a[i][j]=in.next();
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
b[i][j]=in.next();
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
if(a[n-1-j][i].equals(b[i][j])){
sum1++;
}
if(a[j][n-1-i].equals(b[i][j])) {
sum2++;
}
if(a[n-1-i][n-1-j].equals(b[i][j])) {
sum3++;
}
if(a[i][j].equals(b[i][j])) {
sum4++;
}
}
}
if(sum1==n*n) {
System.out.println("1");
}
else if(sum2==n*n) {
System.out.println("2");
}
else if(sum3==n*n) {
System.out.println("3");
}
else if(sum4==n*n) {
System.out.println("4");
}
else {
System.out.println("5");
}
}
}72:计算矩阵边缘元素之和
描述
输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
输入
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
输出
输出对应矩阵的边缘元素和
样例输入
3 3 3 4 1 3 7 1 2 0 1
样例输出
15
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int m = in.nextInt();
int n = in.nextInt();
int sum = 0;
int[][] a = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = in.nextInt();
if (i == 0 || j == 0 || i == m - 1 || j == n - 1) {
sum += a[i][j];
}
}
}
System.out.println(sum);
}
}73:计算鞍点
描述
给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。
鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。
例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
输入
输入包含一个5行5列的矩阵
输出
如果存在鞍点，输出鞍点所在的行、列及其值，如果不存在，输出"not found"
样例输入
11 3 5 6 9 12 4 7 8 10 10 5 6 9 11 8 6 4 7 2 15 10 11 20 25
样例输出
4 1 8
import java.util.*;
public class Main {
public static void main(String[] args) {
int[][] a = new int[5][5];
int max, min, ii = 0, jj = 0, n = 5;
int q = 0;
Scanner in = new Scanner(System.in);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
a[i][j] = in.nextInt();
}
for (int i = 0; i < n; i++) {
max = a[i][0];
for (int j = 0; j < n; j++) {
if (a[i][j] >= max) {
ii = i;
jj = j;
max = a[i][j];
}
}
min = max;
for (int k = 0; k < n; k++) {
if (a[k][jj] < min)
min = a[k][jj];
}
if (max == min) {
q = 1;
System.out.println((ii + 1) + " " + (jj + 1) + " " + max);
}
}
if (q == 0)
System.out.println("not found");
}
}74:倒置排序
描述
将一些整数按倒置值排序后输出. 所谓倒置,是指把整数各位倒过来构成一个新数,例如:13倒置成了31.
输入
第一行的整数N表示后面列出的组数。每组数的第一个整数n表示后面将有n个整数。（每组数据量不超80）
输出
将每组数按倒置值进行排序输出.其每组数的结果占一行.
样例输入
2 4 83 13 24 36 4 99 100 123 12345
样例输出
13 83 24 36 100 99 123 12345
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner cin = new Scanner(System.in);
int T = cin.nextInt();
for (int q = 1; q <= T; q++) {
int n = cin.nextInt();
AA[] a = new AA[n + 1];
for (int j = 0; j < n; j++) {
a[j] = new AA();
int x = cin.nextInt();
a[j].in(x, x);
}
for (int i = 0; i < n; i++) {
int sum = 0;
int g = a[i].x;
int h = 0;
while (g != 0) {
g /= 10;
h++;
}
double k = Math.pow(10, h);
while (a[i].x != 0) {
int t = a[i].x % 10;
a[i].x /= 10;
sum += t * k;
k /= 10;
}
a[i].x = sum;
}
Arrays.sort(a, 0, n, new MyComprator());
for (int i = 0; i < n; i++) {
System.out.print(a[i].y + " ");
}
System.out.println();
}
}
}
class AA {
public int x, y;
public void in(int x, int y) {
this.x = x;
this.y = y;
}
}
class MyComprator implements Comparator<AA> {
public int compare(AA t1, AA t2) {
if (t1.x > t2.x) {
return 1;
} else
return -1;
}
}75:做游戏
描述
有M个小孩子围成一圈做游戏，每个小孩子都有一个初始的号码。游戏有X步，每一步的操作方法都相同：每个小孩子把自己手上的号码改写成自己原来的号码加上右手边的小孩子的号码除以100的余数。请问你：经过X步之后，每个小孩子手上的号码是多少？ 比如：有3个初始编号为{1，2，3}的小孩子，第一步操作完成之后，他们的编号变成了{1+2，2+3，3+1}即{3，5，4}。
输入
输入有N组测试数据。每组测试数据有2行： 第一行包含M和X。 第二行包含M个不超过100的整数。
输出
输出数据有N行，每行是一组测试数据的结果。注意：两个数字之间只有一个空格。
样例输入
2 3 1 1 2 3 3 2 1 2 3
样例输出
3 5 4 8 9 7
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[100000];
int[] b = new int[100000];
for(int i=1;i<=n;i++)
{
int M = in.nextInt();
int X = in.nextInt();
for(int j=1;j<=M;j++)
a[j] = in.nextInt();
for(int k=1;k<=X;k++)
{
for(int i1=1,j=2;i1<=M;i1++,j++)
{
if(i1==M) j=1;
b[i1]=a[i1]+a[j];
}
for(int i1=1;i1<=M;i1++)
a[i1]=b[i1];
}
for(int i1=1;i1<=M;i1++)
System.out.print(b[i1]+" ");
System.out.println();
}
}
}76:石头剪刀布
描述
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。请问，小A和小B比了N轮之后，谁赢的轮数多？
输入
输入包含三行。
第一行包含三个整数：N，NA，NB，分别表示比了N轮，小A出拳的周期长度，小B出拳的周期长度。0 < N,NA,NB < 100。
第二行包含NA个整数，表示小A出拳的规律。
第三行包含NB个整数，表示小B出拳的规律。
其中，0表示“石头”，2表示“剪刀”，5表示“布”。相邻两个整数之间用单个空格隔开。
输出
输出一行，如果小A赢的轮数多，输出A；如果小B赢的轮数多，输出B；如果两人打平，输出draw。
样例输入
10 3 4 0 2 5 0 5 0 2
样例输出
A
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int NA = in.nextInt();
int NB = in.nextInt();
int[] na = new int[NA];
int[] nb = new int[NB];
int A = 0, B = 0, j = 0, k = 0;
for (int i = 0; i < NA; i++) {
na[i] = in.nextInt();
}
for (int i = 0; i < NB; i++) {
nb[i] = in.nextInt();
}
for (int i = 0; i < N; i++, k++, j++) {
if (j == NA) {
j = 0;
}
if (k == NB) {
k = 0;
}
if (na[j] == 0 && nb[k] == 2) {
A++;
} else if (na[j] == 2 && nb[k] == 0) {
B++;
} else if (na[j] == 0 && nb[k] == 5) {
B++;
} else if (na[j] == 5 && nb[k] == 0) {
A++;
} else if (na[j] == 5 && nb[k] == 2) {
B++;
} else if (na[j] == 2 && nb[k] == 5) {
A++;
}
}
if (A > B) {
System.out.println("A");
} else if (A < B) {
System.out.println("B");
} else {
System.out.println("draw");
}
}
}77:有趣的跳跃
描述
一个长度为n（n>0）的序列中存在“有趣的跳跃”当前仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如，1 4 2 3存在“有趣的跳跃”，因为差的绝对值分别为3,2,1。当然，任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。
输入
一行，第一个数是n（0 < n < 3000），为序列长度，接下来有n个整数，依次为序列中各元素，各元素的绝对值均不超过1,000,000,000。
输出
一行，若该序列存在“有趣的跳跃”，输出"Jolly"，否则输出"Not jolly"。
样例输入
4 1 4 2 3
样例输出
Jolly
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int a[] = new int[n];
int b[] = new int[n - 1];
if (n == 1) {
System.out.println("Jolly");
} else {
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
for (int i = 0; i < n; i++) {
for (i = 0; i < n - 1; i++) {
b[i] = Math.abs(a[i + 1] - a[i]);
}
}
Arrays.sort(b);
int j = 1;
for (int i = 0; i < n - 1; i++, j++) {
if (b[i] != j) {
System.out.println("Not jolly");
break;
} else {
if (i == n - 2) {
System.out.println("Jolly");
}
}
}
}
}
}78:校门外的树
描述
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。
输入
第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。
对于20%的数据，区域之间没有重合的部分；
对于其它的数据，区域之间有重合的情况。
输出
包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。
样例输入
500 3 150 300 100 200 470 471
样例输出
298
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a[] = new int[10002];
int L = in.nextInt();
int M = in.nextInt();
for (int j = 1; j <= M; j++) {
int start = in.nextInt();
int over = in.nextInt();
for (int i = start; i <= over; i++) {
a[i] = 1;
}
}
int trees = 0;
for (int i = 0; i <= L; i++) {
if (a[i] == 0)
trees++;
}
System.out.println(trees);
}
}79:年龄与疾病
描述
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。
输入
共2行，第一行为过往病人的数目n（0 < n <= 100)，第二行为每个病人患病时的年龄。
输出
按照0-18、19-35、36-60、61以上（含61）四个年龄段输出该段患病人数占总患病人数的比例，以百分比的形式输出，精确到小数点后两位。每个年龄段占一行，共四行。
样例输入
10 1 11 21 31 41 51 61 71 81 91
样例输出
20.00% 20.00% 20.00% 40.00%
import java.text.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
int n;
double x = 0, y = 0, z = 0, p = 0;
int a[] = new int[102];
Scanner scanner = new Scanner(System.in);
n = scanner.nextInt();
for (int i = 0; i < n; i++) {
a[i] = scanner.nextInt();
}
for (int i = 0; i < n; i++) {
if (a[i] >= 0 && a[i] <= 18)
x++;
if (a[i] >= 19 && a[i] <= 35)
y++;
if (a[i] >= 36 && a[i] <= 60)
z++;
if (a[i] >= 61)
p++;
}
x = x / n;
y = y / n;
z = z / n;
p = p / n;
NumberFormat nf = NumberFormat.getPercentInstance();
nf.setMinimumFractionDigits(2);
System.out.println(nf.format(x));
System.out.println(nf.format(y));
System.out.println(nf.format(z));
System.out.println(nf.format(p));
}
}80:数组逆序重放
81:与指定数字相同的数的个数
描述
输出一个整数序列中与指定数字相同的数的个数。
输入
输入包含三行：
第一行为N，表示整数序列的长度(N <= 100)；
第二行为N个整数，整数之间以一个空格分开；
第三行包含一个整数，为指定的整数m。
输出
输出为N个数中与m相同的数的个数。
样例输入
3 2 3 2 2
样例输出
2
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[108];
int n=in.nextInt();
for(int i=1;i<=n;i++) {
a[i]=in.nextInt();
}
int t=in.nextInt();
int count=0;
for(int i=1;i<=n;i++) {
if(a[i]==t) {
count++;
}
}
System.out.println(count);
}
}82:寻找配对数
描述
在给定的n个互不相等的正整数中，寻找可以形成a*b=c的等式(a,b,c互不相等)的数目。比如在12,32,6,1,2,8,4中，只有2*4=8, 2*6=12, 4*8=32三对。
注意：给出的正整数互不相同。正整数的最大值为2^32-1，正整数的最大个数为1000.
输入
第一行输入总共的正整数数目n(n<=1000)
接下来的一行输入n个正整数，正整数之间用一个空格隔开。
输出
输出其中满足a*b=c等式的数目。
样例输入
7 8 6 3 4 10 5 2
样例输出
3
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] a = new int[1100];
int b = 0;
int n = in.nextInt();
for (int i = 1; i <= n; i++)
a[i] = in.nextInt();
for (int j = 1; j <= n; j++) {
for (int k = j + 1; k <= n; k++) {
for (int h = k + 1; h <= n; h++) {
if (a[j] * a[k] == a[h] || a[j] * a[h] == a[k] || a[k] * a[h] == a[j])
b++;
}
}
}
System.out.println(b);
}
}83:数字求和
描述
Tom最近喜欢数字加法，她最喜欢把一行数据加在一起，然后输出。
输入
第一行有一个数字n,表示后面有n行数字。
以后的每一行数字，第一个数字m表示，该行要计算从该行第2个数字到m+1个数字之和。
输出
每一行对应一组输入数据的结果。
样例输入
3 3 1 2 3 2 10 20 4 1 2 3 1
样例输出
6 30 7
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] a = new int[10000];
int n = in.nextInt();
int sum = 0;
for(int i=0;i<n;i++)
{
int m = in.nextInt();
for(int j=1;j<=m;j++)
{
int x = in.nextInt();
a[i]+=x;
}
}
for(int k=0;k<n;k++)
System.out.println(a[k]);
}
}84:向量点积计算
描述
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。
输入
第一行是一个整数n。1 <= n <= 1000。
第二行包含n个整数a1,a2,...,an。
第三行包含n个整数b1,b2,...,bn。
相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。
输出
一个整数，即两个向量的点积结果。
样例输入
3 1 4 6 2 1 5
样例输出
36
import java.util.*;
public class Main
{
public static void main(String []args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int a[]=new int[1008];
int b[]=new int[1008];
for(int i=1;i<=n;i++){
a[i]=in.nextInt();
}
for(int i=1;i<=n;i++){
b[i]=in.nextInt();
}
int count=0;
for(int i=1;i<=n;i++){
count+=a[i]*b[i];
}
System.out.println(count);
}
}
1067
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
