最近准备机试，才开始刷大名鼎鼎的CCF竞赛题（当然小白只能做第一题嘻嘻），年份逆序，越老的年份题目越简单，所以逆序刷题的时候越来越觉得所向披靡哈哈哈 :-p
大佬们喜欢用C/C++，我机试打算用Java，所以将T1合集用Java语言实现。
试题编号：201912-1
试题名称：报数
【题目描述】
甲乙丙丁决定玩一个报数的游戏来打发时间。游戏规则为四个人从1开始轮流进行报数，但如果需要报出的数是7的倍数或含有数字7则直接跳过。
此外大家约定，在总共报出了n个数后（不计入被跳过的数）游戏结束。现在需要你来帮忙统计，游戏过程中每个人各自跳过了几次
【输入格式】
从标准输入读入数据。
输入仅一行，包含一个正整数n，表示报出了多少个数后游戏结束。
【输出格式】
输出到标准输出。
输出共四行，每行一个整数，依次表示甲乙丙丁四人在游戏过程中跳过的次数。
【输入样例1】
20
【输出样例1】
2
1
1
0
【样例解释1】
报数过程为：
甲：1，乙：2，丙：3，丁：4
甲：5，乙：6，丙：跳过，丁：8
甲：9，乙：10，丙：11，丁：12
甲：13，乙：跳过，丙：15，丁：16
甲：跳过，乙：18，：19，丁：20
甲：跳过，乙：22，丙：23，丁：24
在丁报出24后，四个人总计报出了20个数，游戏结束。
【输入样例2】
66
【输出样例2】
7
5
11
5
【注意】
测试点1、2、3、4和5，保证n<=10^2；
测试点6、7、8、9和10，保证n<=666
代码实现：
import java.util.Scanner;
public class BS {
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int num=1,i,j,count=0;
int []a=new int[4];//记录每人跳过的次数
for(i=0;i<4;i++)
a[i]=0;
while(count<n){
if(num/100==7||num/10==7||num%10==7||num%7==0||(num/10)%10==7){//数字为7__或7_或_7或7的倍数或_7_
j=num%4;//计算是哪一个人跳过的
if(j==0){
a[3]+=1;
}
else{
a[j-1]+=1;
}
}
else{
count+=1;
}
num+=1;
}
for(i=0;i<4;i++){
System.out.println(a[i]);
}
}
}试题编号：201909-1
试题名称：小明种苹果/小明种树/小明疏果
【题目描述】
小明在他的果园里种了一些苹果树。为了保证苹果的品质，在种植过程中要进行若干轮疏果操作，也就是提前从树上把不好的苹果去掉。第一轮疏果操作开始前，小明记录了每棵树上苹果的个数。每轮疏果操作时，小明都记录了从每棵树上去掉的苹果个数。在最后一轮疏果操作结束后，请帮助小明统计相关的信息。
【输入格式】
从标准输入读入数据。
第 1 行包含两个正整数 N 和 M，分别表示苹果树的棵数和疏果操作的轮数。
第 1 + i 行（1 ≤ i ≤ N），每行包含 M + 1 个整数 ai0, ai1, . . . , aiM。其中 ai0 为正整数，表示第一轮疏果操作开始前第 i 棵树上苹果的个数。ai j（1 ≤ j ≤ M）为零或负整数，表示第 j 轮疏果操作时从第 i 棵树上去掉的苹果个数。如果为零，表示没有去掉苹果；如果为负，其绝对值为去掉的苹果个数。
每行中相邻两个数之间用一个空格分隔。
【输出格式】
输出到标准输出。
输出只有一行，包含三个整数 T 、k 和 P。其中：
T 为最后一轮疏果操作后所有苹果树上剩下的苹果总数（假设苹果不会因为其他原因减少）；
K 为疏果个数（也就是疏果操作去掉的苹果个数）最多的苹果树编号（如有并列， 输出满足条件的最小编号）；
P 为该苹果树的疏果个数。
相邻两个数之间用一个空格分隔。输入数据保证是正确的，也就是说，每棵树在全 部疏果操作结束后剩下的苹果个数是非负的。
【样例 1 输入】
3 3
73 -8 -6 -4
76 -5 -10 -8
80 -6 -15 0
【样例 1 输出】
167 2 23
【样例 1 解释】
第 1 棵苹果树的疏果个数为 8 + 6 + 4 = 18，第 2 棵为 5 + 10 + 8 = 23，第 3
棵为 6 + 15 + 0 = 21， 因此最后一轮疏果操作后全部苹果树上的苹果个数总和为
(73 − 18) + (76 − 23) + (80 − 21) = 167，疏果个数最多的是第 2 棵数，其疏果个数为 23。
【样例 2 输入】
2 2
10 -3 -1
15 -4 0
【样例 2 输出】
17 1 4
【样例 2 解释】
两棵树的疏果个数均为 4，应该输出编号最小的第 1 棵树
代码实现：
import java.util.Scanner;
public class XMZPG {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
int [][]a=new int[n][m+2];//第m+1列存放每棵树的疏果情况
int i,j,t=0,k=0,p=0;
for(i=0;i<n;i++){
for(j=0;j<m+1;j++){
a[i][j]=scan.nextInt();
}
}
for(i=0;i<n;i++){
a[i][m+1]=0;
for(j=1;j<m+1;j++){
a[i][m+1]+=a[i][j];//计算每棵树疏果总量
}
if(a[i][m+1]<p){
p=a[i][m+1];//找到最大疏果量
k=i+1;
}
t+=a[i][0]+a[i][m+1];//剩余苹果总数t
}
System.out.print(t+" "+k+" "+Math.abs(p));
}
}试题编号：201903-1
试题名称：最大值、最小值与中位数
题目描述：
老师给了你n个整数组成的测量数据，保证有序(可能为升序或降序)，可能存在重复的数据。请统计出这组测量效据中的最大值、中位数以及最小值，并按照从大到小的顺序输出这三个数。
[输入格式]
从标准输入读入数据。
第一行输入-一个整数n,在第二行中存在n个有序的整数，表示测量数据，可能为升序或降序排列，可能存在连续多个整数相等，整数与整数之间使用空格隔开。
[输出格式]
输出到标准输出。
包含- -行，包括最大值、中位数以及最小值共三个数，并按照从大到小的顺序输出。数据与数据之间使用空格隔开。对于整数请直接输出整数，对于可能出现的分数,请输出四舍五入保留1位小数的结果。
[样例输入]
3
-1 2 4
[样例输出]
4 2 -1
[样例解释]
4为最大值，2为中位数，-1为最小值。
代码实现：
import java.math.BigDecimal;
import java.util.Scanner;
public class MAXMINMID {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int i,j,min,max;
// float mid=0;
boolean s=true;//设定s，s为1则数组为升序，s为0则为降序
for(i=0;i<n;i++){
a[i]=scan.nextInt();
}
//mid=min=max=a[0];
for(i=0;i<n;i++){
if(a[i+1]>a[i]){
s=true;
break;
}
else if(a[i+1]<a[i]){
s=false;
break;
}
}
if(s){//数组为升序
min=a[0];
max=a[n-1];
}
else{
min=a[n-1];
max=a[0];
}
System.out.print(max+" ");
if(n%2==0){//数字个数为偶数个
if((a[n/2]+a[n/2-1])%2==0){//中位数为整数
int mid;
mid=(a[n/2]+a[n/2-1])/2;
System.out.print(mid+" ");
}
else{//中位数为分数
float data=(float)(a[n/2]+a[n/2-1])/2;
float mid =(float) new BigDecimal(data).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.print(mid+" ");
}
}
else{//数字个数为奇数
int mid=a[n/2];
System.out.print(mid+" ");
}
System.out.print(min);
}
}试题编号： 201812-1
试题名称： 小明上学
问题描述：
小明是汉东省政法大学附属中学的一名学生，他每天都要骑自行车往返于家和学校。为了能尽可能充足地睡眠，他希望能够预计自己上学所需要的时间。他上学需要经过数段道路，相邻两段道路之间设有至多一盏红绿灯。
京州市的红绿灯是这样工作的：每盏红绿灯有红、黄、绿三盏灯和一个能够显示倒计时的显示牌。假设红绿灯被设定为红灯 r 秒，黄灯 y 秒，绿灯 g 秒，那么从 0 时刻起，[0,r) 秒内亮红灯，车辆不许通过；[r, r+g) 秒内亮绿灯，车辆允许通过；[r+g, r+g+y) 秒内亮黄灯，车辆不许通过，然后依次循环。倒计时的显示牌上显示的数字 l（l > 0）是指距离下一次信号灯变化的秒数。
问题描述
一次上学的路上，小明记录下了经过每段路的时间，和各个红绿灯在小明到达路口时的颜色和倒计时秒数。希望你帮忙计算此次小明上学所用的时间。
输入格式
输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 106。
输入的第二行包含一个正整数 n（n ≤ 100），表示小明总共经过的道路段数和看到的红绿灯数目。
接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，耗时 t 秒，此处 t 不超过 106；k=1、2、3 时，分别表示看到了一个红灯、黄灯、绿灯，且倒计时显示牌上显示的数字是 t，此处 t 分别不会超过 r、y、g。
输出格式
输出一个数字，表示此次小明上学所用的时间。
样例输入
30 3 30
8
0 10
1 5
0 11
2 2
0 6
0 3
3 10
0 3
样例输出
70
样例说明
小明先经过第一段道路，用时 10 秒，然后等待 5 秒的红灯，再经过第二段道路，用时 11 秒，然后等待 2 秒的黄灯和 30 秒的红灯，再经过第三段、第四段道路，分别用时6、3秒，然后通过绿灯，再经过最后一段道路，用时 3 秒。共计 10 + 5 + 11 + 2 + 30 + 6 + 3 + 3=70 秒。
评测用例规模与约定
测试点 1, 2 中不存在任何信号灯。
测试点 3, 4 中所有的信号灯在被观察时均为绿灯。
测试点 5, 6 中所有的信号灯在被观察时均为红灯。
测试点 7, 8 中所有的信号灯在被观察时均为黄灯。
测试点 9, 10 中将出现各种可能的情况。
代码实现：
import java.util.Scanner;
public class XMSX {
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
int red=scanner.nextInt();
int yellow=scanner.nextInt();
int green=scanner.nextInt();
int n=scanner.nextInt();
int time=0;
for(int i=1;i<=n;i++){
int k=scanner.nextInt();
int t=scanner.nextInt();
if(k==0|k==1)
time+=t;
if(k==2)
time+=t+red;
if(k==3)
time+=0;
}
System.out.print(time);
}
}试题编号： 201809-1
试题名称： 卖菜
问题描述:
在一条街上有n个卖菜的商店，按1至n的顺序排成一排，这些商店都卖一种蔬菜。
第一天，每个商店都自己定了一个价格。店主们希望自己的菜价和其他商店的一致，第二天，每一家商店都会根据他自己和相邻商店的价格调整自己的价格。具体的，每家商店都会将第二天的菜价设置为自己和相邻商店第一天菜价的平均值（用去尾法取整）。
注意，编号为1的商店只有一个相邻的商店2，编号为n的商店只有一个相邻的商店n-1，其他编号为i的商店有两个相邻的商店i-1和i+1。
给定第一天各个商店的菜价，请计算第二天每个商店的菜价。
输入格式
输入的第一行包含一个整数n，表示商店的数量。
第二行包含n个整数，依次表示每个商店第一天的菜价。
输出格式
输出一行，包含n个正整数，依次表示每个商店第二天的菜价。
样例输入
8
4 1 3 1 6 5 17 9
样例输出
2 2 1 3 4 9 10 13
数据规模和约定
对于所有评测用例，2 ≤ n ≤ 1000，第一天每个商店的菜价为不超过10000的正整数。
代码实现：
import java.util.Scanner;
public class MC {
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int[] price=new int[1000];
for(int i=0;i<n;i++){
price[i]=scanner.nextInt();
}
for(int j=0;j<n;j++){
if(j==0)
System.out.print((price[j]+price[j+1])/2+" ");
else if(j==n-1)
System.out.print((price[j]+price[j-1])/2+" ");
else
System.out.print((price[j-1]+price[j]+price[j+1])/3+" ");
}
}
}试题编号： 201803-1
试题名称： 跳一跳
问题描述：
近来，跳一跳这款小游戏风靡全国，受到不少玩家的喜爱。
简化后的跳一跳规则如下：玩家每次从当前方块跳到下一个方块，如果没有跳到下一个方块上则游戏结束。
如果跳到了方块上，但没有跳到方块的中心则获得1分；跳到方块中心时，若上一次的得分为1分或这是本局游戏的第一次跳跃则此次得分为2分，否则此次得分比上一次得分多两分（即连续跳到方块中心时，总得分将+2，+4，+6，+8…）。
现在给出一个人跳一跳的全过程，请你求出他本局游戏的得分（按照题目描述的规则）。
输入格式
输入包含多个数字，用空格分隔，每个数字都是1，2，0之一，1表示此次跳跃跳到了方块上但是没有跳到中心，2表示此次跳跃跳到了方块上并且跳到了方块中心，0表示此次跳跃没有跳到方块上（此时游戏结束）。
输出格式
输出一个整数，为本局游戏的得分（在本题的规则下）。
样例输入
1 1 2 2 2 1 1 2 2 0
样例输出
22
数据规模和约定
对于所有评测用例，输入的数字不超过30个，保证0正好出现一次且为最后一个数字。
代码：
import java.util.Scanner;
public class TYT {
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
int []loc=new int[30]; //创建数组存放每一次跳的结果
//int []sco=new int[30]; //创建数组存放每一次跳的得分
int num=0;//统计连续跳到中心的次数
int score=0;
for(int i=0;i<30;i++){
loc[i]=scanner.nextInt();
if(loc[i]==0)
break;
if(loc[i]==1){
num=0;
score+=1;
}
else if(loc[i]==2){
num+=1;
score+=num*2;
}
else if(loc[i]==0){
break;
}
}
System.out.print(score);
}}试题编号： 201712-1
试题名称： 最小差值
问题描述：
给定n个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。
输入格式
输入第一行包含一个整数n。
第二行包含n个正整数，相邻整数之间使用一个空格分隔。
输出格式
输出一个整数，表示答案。
样例输入
5
1 5 4 8 20
样例输出
1
样例说明
相差最小的两个数是5和4，它们之间的差值是1。
样例输入
5
9 3 6 1 3
样例输出
0
样例说明
有两个相同的数3，它们之间的差值是0.
数据规模和约定
对于所有评测用例，2 ≤ n ≤ 1000，每个给定的整数都是不超过10000的正整数。
代码实现：
import java.util.Scanner;
public class ZXCZ {
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int []num=new int[n];
int i;
int t;//
for(i=0;i<n;i++){
num[i]=scanner.nextInt();
}
int min=Math.abs(num[0]-num[1]);
for(i=0;i<n;i++){
for(int j=i+1;j<n;j++){
t=Math.abs(num[i]-num[j]);
if(t<min)
min=t;
}
}
System.out.print(min);
}
}试题编号： 201709-1
试题名称： 打酱油
问题描述：
小明带着N元钱去买酱油。酱油10块钱一瓶，商家进行促销，每买3瓶送1瓶，或者每买5瓶送2瓶。请问小明最多可以得到多少瓶酱油。
输入格式
输入的第一行包含一个整数N，表示小明可用于买酱油的钱数。N是10的整数倍，N不超过300。
输出格式
输出一个整数，表示小明最多可以得到多少瓶酱油。
样例输入
40
样例输出
5
样例说明
把40元分成30元和10元，分别买3瓶和1瓶，其中3瓶送1瓶，共得到5瓶。
样例输入
80
样例输出
11
样例说明
把80元分成30元和50元，分别买3瓶和5瓶，其中3瓶送1瓶，5瓶送2瓶，共得到11瓶。
代码：
import java.util.Scanner;
public class DJY {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int N=scan.nextInt();
int n;
int f=N/50; //记录N中包含几个50
int t=(N-50*f)/30; //记录N中包含几个30
int o=(N-50*f-30*t)/10;//记录剩余零钱可买的瓶数
n=f*7+t*4+o;
System.out.print(n);
}
}试题编号： 201703-1
试题名称： 分蛋糕
问题描述：
小明今天生日，他有n块蛋糕要分给朋友们吃，这n块蛋糕（编号为1到n）的重量分别为a1, a2, …, an。小明想分给每个朋友至少重量为k的蛋糕。小明的朋友们已经排好队准备领蛋糕，对于每个朋友，小明总是先将自己手中编号最小的蛋糕分给他，当这个朋友所分得蛋糕的重量不到k时，再继续将剩下的蛋糕中编号最小的给他，直到小明的蛋糕分完或者这个朋友分到的蛋糕的总重量大于等于k。
请问当小明的蛋糕分完时，总共有多少个朋友分到了蛋糕。
输入格式
输入的第一行包含了两个整数n, k，意义如上所述。
第二行包含n个正整数，依次表示a1, a2, …, an。
输出格式
输出一个整数，表示有多少个朋友分到了蛋糕。
样例输入
6 9
2 6 5 6 3 5
样例输出
3
样例说明
第一个朋友分到了前3块蛋糕，第二个朋友分到了第4、5块蛋糕，第三个朋友分到了最后一块蛋糕。
评测用例规模与约定
对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ k ≤ 10000，1 ≤ ai ≤ 1000。
代码：
import java.util.Scanner;
public class FDG {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int k=scan.nextInt();
int []a=new int[n];
int count=0;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
int wei=0;
for(int i=0;i<n;i++){
wei+=a[i];
if(wei>=k){
count+=1;
wei=0;}
}
//System.out.print(wei+" ");
if(wei!=0){//蛋糕直到分完也没达到k值，剩下的全给最后一个朋友
count+=1;
}
System.out.print(count);
}
}试题编号： 201612-1
试题名称： 中间数
问题描述：
在一个整数序列a1, a2, …, an中，如果存在某个数，大于它的整数数量等于小于它的整数数量，则称其为中间数。在一个序列中，可能存在多个下标不相同的中间数，这些中间数的值是相同的。
给定一个整数序列，请找出这个整数序列的中间数的值。
输入格式
输入的第一行包含了一个整数n，表示整数序列中数的个数。
第二行包含n个正整数，依次表示a1, a2, …, an。
输出格式
如果约定序列的中间数存在，则输出中间数的值，否则输出-1表示不存在中间数。
样例输入
6
2 6 5 6 3 5
样例输出
5
样例说明
比5小的数有2个，比5大的数也有2个。
样例输入
4
3 4 6 7
样例输出
-1
样例说明
在序列中的4个数都不满足中间数的定义。
样例输入
5
3 4 6 6 7
样例输出
-1
样例说明
在序列中的5个数都不满足中间数的定义。
评测用例规模与约定
对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ ai ≤ 1000。
代码实现：
import java.util.Scanner;
public class ZJS {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int sma=0,big=0,mid=0;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[j]>a[i]){
big+=1;}
else if(a[j]<a[i]){
sma+=1;}
}
if(big==sma){
mid=a[i];}
big=sma=0;
}
//System.out.print(a[0]);
if(mid!=0)
System.out.print(mid);
else
System.out.print("-1");
}
}试题编号： 201609-1
试题名称： 最大波动
问题描述：
小明正在利用股票的波动程度来研究股票。小明拿到了一只股票每天收盘时的价格，他想知道，这只股票连续几天的最大波动值是多少，即在这几天中某天收盘价格与前一天收盘价格之差的绝对值最大是多少。
输入格式
输入的第一行包含了一个整数n，表示小明拿到的收盘价格的连续天数。
第二行包含n个正整数，依次表示每天的收盘价格。
输出格式
输出一个整数，表示这只股票这n天中的最大波动值。
样例输入
6
2 5 5 7 3 5
样例输出
4
样例说明
第四天和第五天之间的波动最大，波动值为|3-7|=4。
评测用例规模与约定
对于所有评测用例，2 ≤ n ≤ 1000。股票每一天的价格为1到10000之间的整数。
代码实现：
import java.util.Scanner;
public class ZDBD {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int def=0,max=0;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<n-1;i++){
def=Math.abs(a[i+1]-a[i]);
if(def>max)
max=def;
}
System.out.print(max);
}
}试题编号： 201604-1
试题名称： 折点计数
问题描述：
给定n个整数表示一个商店连续n天的销售量。如果某天之前销售量在增长，而后一天销售量减少，则称这一天为折点，反过来如果之前销售量减少而后一天销售量增长，也称这一天为折点。其他的天都不是折点。如下图中，第3天和第6天是折点。
给定n个整数a1, a2, …, an表示销售量，请计算出这些天总共有多少个折点。
为了减少歧义，我们给定的数据保证：在这n天中相邻两天的销售量总是不同的，即ai-1≠ai。注意，如果两天不相邻，销售量可能相同。
输入格式
输入的第一行包含一个整数n。
第二行包含n个整数，用空格分隔，分别表示a1, a2, …, an。
输出格式
输出一个整数，表示折点出现的数量。
样例输入
7
5 4 1 2 3 6 4
样例输出
2
评测用例规模与约定
所有评测用例满足：1 ≤ n ≤ 1000，每天的销售量是不超过10000的非负整数。
代码：
import java.util.Scanner;
public class ZDJS {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int zhed=0;
int def1,def2;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=1;i<n-1;i++){
def1=a[i]-a[i-1];
def2=a[i+1]-a[i];
if(def1*def2<0)
zhed+=1;
}
System.out.print(zhed);
}
}试题编号： 201512-1
试题名称： 数位之和
问题描述：
给定一个十进制整数n，输出n的各位数字之和。
输入格式
输入一个整数n。
输出格式
输出一个整数，表示答案。
样例输入
20151220
样例输出
13
样例说明
20151220的各位数字之和为2+0+1+5+1+2+2+0=13。
评测用例规模与约定
所有评测用例满足：0 ≤ n ≤ 1000000000。
代码：
import java.util.Scanner;
public class SWZH {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int sum=0;
while(n!=0){
sum+=n%10;
n=n/10;}
System.out.print(sum);
}
}试题编号： 201509-1
试题名称： 数列分段
问题描述：
给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中共有多少段？
输入格式
输入的第一行包含一个整数n，表示数列中整数的个数。
第二行包含n个整数a1, a2, …, an，表示给定的数列，相邻的整数之间用一个空格分隔。
输出格式
输出一个整数，表示给定的数列有多个段。
样例输入
8
8 8 8 0 12 12 8 0
样例输出
5
样例说明
8 8 8是第一段，0是第二段，12 12是第三段，倒数第二个整数8是第四段，最后一个0是第五段。
评测用例规模与约定
1 ≤ n ≤ 1000，0 ≤ ai ≤ 1000。
代码：
import java.util.Scanner;
public class SLFD {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int ds=1;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<n-1;i++){
if(a[i+1]!=a[i])
ds+=1;
}
System.out.print(ds);
}
}试题编号： 201503-1
试题名称： 图像旋转
问题描述：
旋转是图像处理的基本操作，在这个问题中，你需要将一个图像逆时针旋转90度。
计算机中的图像表示可以用一个矩阵来表示，为了旋转一个图像，只需要将对应的矩阵旋转即可。
输入格式
输入的第一行包含两个整数n, m，分别表示图像矩阵的行数和列数。
接下来n行每行包含m个整数，表示输入的图像。
输出格式
输出m行，每行包含n个整数，表示原始矩阵逆时针旋转90度后的矩阵。
样例输入
2 3
1 5 3
3 2 4
样例输出
3 4
5 2
1 3
评测用例规模与约定
1 ≤ n, m ≤ 1,000，矩阵中的数都是不超过1000的非负整数。
代码：
import java.util.Scanner;
public class TXXZ {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
int [][]a=new int[n][m];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
a[i][j]=scan.nextInt();
}
}
for(int i=m-1;i>=0;i--){
for(int j=0;j<n;j++){
System.out.print(a[j][i]+" ");
}
System.out.println();
}
}
}试题编号： 201412-1
试题名称： 门禁系统
问题描述：
涛涛最近要负责图书馆的管理工作，需要记录下每天读者的到访情况。每位读者有一个编号，每条记录用读者的编号来表示。给出读者的来访记录，请问每一条记录中的读者是第几次出现。
输入格式
输入的第一行包含一个整数n，表示涛涛的记录条数。
第二行包含n个整数，依次表示涛涛的记录中每位读者的编号。
输出格式
输出一行，包含n个整数，由空格分隔，依次表示每条记录中的读者编号是第几次出现。
样例输入
5
1 2 1 1 3
样例输出
1 1 2 3 1
评测用例规模与约定
1≤n≤1,000，读者的编号为不超过n的正整数。
代码：
import java.util.Scanner;
public class MJXT {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int count=1;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<n;i++){
for(int j=0;j<i;j++){
if(a[j]==a[i]){
count+=1;
}
}
System.out.print(count+" ");
count=1;
}
}
}试题编号： 201409-1
试题名称： 相邻数对
问题描述：
给定n个不同的整数，问这些数中有多少对整数，它们的值正好相差1。
输入格式
输入的第一行包含一个整数n，表示给定整数的个数。
第二行包含所给定的n个整数。
输出格式
输出一个整数，表示值正好相差1的数对的个数。
样例输入
6
10 2 6 3 7 8
样例输出
3
样例说明
值正好相差1的数对包括(2, 3), (6, 7), (7, 8)。
评测用例规模与约定
1<=n<=1000，给定的整数为不超过10000的非负整数。
代码：
import java.util.Scanner;
public class XLSD {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []a=new int[n];
int count=0;
for(int i=0;i<n;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(Math.abs(a[i]-a[j])==1)
count+=1;
}
}
System.out.print(count);
}
}试题编号： 201403-1
试题名称： 相反数
问题描述：
有 N 个非零且各不相同的整数。请你编一个程序求出它们中有多少对相反数(a 和 -a 为一对相反数)。
输入格式
第一行包含一个正整数 N。(1 ≤ N ≤ 500)。
第二行为 N 个用单个空格隔开的非零整数,每个数的绝对值不超过1000,保证这些整数各不相同。
输出格式
只输出一个整数,即这 N 个数中包含多少对相反数。
样例输入
5
1 2 3 -1 -2
样例输出
2
代码：
import java.util.Scanner;
public class XFS {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int N=scan.nextInt();
int []a=new int[N];
int count=0;
for(int i=0;i<N;i++){
a[i]=scan.nextInt();
}
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){
if(a[i]==(-(a[j])))
count+=1;
}
}
System.out.print(count);
}
}试题编号： 201312-1
试题名称： 出现次数最多的数
问题描述：
给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。
输入格式
输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。
输入的第二行有n个整数s1, s2, …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空格分隔。
输出格式
输出这n个次数中出现次数最多的数。如果这样的数有多个，输出其中最小的一个。
样例输入
6
10 1 10 20 30 20
样例输出
10
代码实现：
import java.util.Scanner;
public class CXCSZD {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int []s=new int[n];
int i,j,num=0,count=0;
for(i=0;i<n;i++){
s[i]=scan.nextInt();
}
int min=s[0];
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(s[j]==s[i])
num+=1;
}
if(num>count){
count=num;
min=s[i];}
else if(num==count){
if(s[i]<min){
min=s[i];
}
}
}
System.out.print(min);
}}
