2013
package test_one;
import java.util.*;
/*出现次数最多的数
* 给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个.*/
public class ccf20131201 {
static int n;
static int[] s;
public static void main(String[] args) {
// TODO Auto-generated method stub
getNum();
getResult();
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
s=new int[n];
for(int i=0;i<n;i++)
s[i]=sc.nextInt();
sc.close();
}
private static void getResult(){
int max=0,sum=0,result=0;
for(int i=0;i<n;i++){
if(result!=s[i]){
sum=0;
for(int j=0;j<n;j++)
if(s[i]==s[j]) sum++;
if(sum==max&&result>s[i]) result=s[i];
if(sum>max) { max=sum; result=s[i]; }
}
}
System.out.print(result);
}
}
package test_one;
/*ISBN号码
* 这个题不难，但是第一次提交打80分，就是因为少考虑了当输入正确的ISBN号码后面带X的情况
* 如：1-030-00000-X，该情况应该输出Right
* 后来改了之后又打了一次60分，因为忘记删除测试用的println，导致结果成：
* 如：输入0-000-00000-1，输出：
* 0-000-00000-
* 0
* 在做题的时候要全方面考虑，尤其要测试比较特殊的数据
* 改了之后，最后提交的时候所有的特例都要测试通过再提交
* 2017-11-30*/
import java.util.*;
public class ccf20131202 {
static String s;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
s=sc.nextLine();
int sum=0,num=1;
sc.close();
for(int i=0;i<s.length()-1;i++){
char c=s.charAt(i);
if(c>='0'&&c<='9'){
int t=c-'0';
sum+=t*num;
num++;
}
}
int temp=sum%11;
if(temp==(s.charAt(12)-'0')) //输入正确的ISBN号码
System.out.print("Right");
else if(temp==10&&(s.charAt(12))=='X'){//当输入正确的ISBN号码后面带X的情况
System.out.print("Right");
}
else if(temp==10){//当输入正确错误的ISBN号码结果为10时后面接X
getS();
System.out.print('X');
}
else{ //当输入正确错误的ISBN号码，输出正确的
getS();
System.out.print(temp);
}
}
private static void getS(){
for(int i=0;i<s.length()-1;i++)
System.out.print(s.charAt(i));
}
}
package test_one;
import java.util.*;
/*最大矩阵*/
public class ccf20131203 {
public static void main(String[] args) {
int j,low,temp,max=-1;
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int h[]=new int[n];
for(int i=0;i<n;i++)
h[i]=sc.nextInt();
sc.close();
for(int i=0;i<n;i++){ //将矩形i与矩形i+1...i+n进行遍历
low=h[i];
for(j=i;j<n;j++){
if(h[j]<low) low=h[j];
temp=(j-i+1)*low;
if(temp>max) max=temp;
}
}
System.out.print(max);
}
}
package test_one;
import java.util.*;
public class ccf20131204 {
/*有趣的数
* 我们把一个数称为有趣的，当且仅当：
1. 它的数字只包含0, 1, 2, 3，且这四个数字都出现过至少一次。
2. 所有的0都出现在所有的1之前，而所有的2都出现在所有的3之前。
3. 最高位数字不为0。
因此，符合我们定义的最小的有趣的数是2013。除此以外，4位的有趣的数还有两个：2031和2301。
请计算恰好有n位的有趣的数的个数。由于答案可能非常大，只需要输出答案除以1000000007的余数。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
long mod = 1000000007;
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();
long [][] status = new long[number + 1][6];
for (int i = 0; i < 6; i ++)
status[0][i] = 0;
sc.close();
for (int i = 1; i < number + 1; i ++){
status[i][0] = 1;
status[i][1] = (status[i - 1][1] * 2 + status[i - 1][0]) % mod;
status[i][2] = (status[i - 1][2] + status[i - 1][0]) % mod;
status[i][3] = (status[i - 1][3] * 2 + status[i - 1][1]) % mod;
status[i][4] = (status[i - 1][4] * 2 + status[i - 1][2] + status[i - 1][1]) % mod;
status[i][5] = (status[i - 1][5] * 2 + status[i - 1][4] + status[i - 1][3]) % mod;
}
System.out.println(status[number][5]);
}
}
2014
package test_one;
import java.util.*;
/*相反数,相加等于0*/
public class ccf20140301 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int sum=0;
int num[]=new int[n];
for(int i=0;i<n;i++){
num[i]=sc.nextInt();
}
sc.close();
for(int i=0;i<n-1;i++){
if(num[i]!=0){
for(int j=i+1;j<n;j++){
if(num[i]+num[j]==0){
sum+=1;
num[j]=0;
}
}
}
}
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/*窗口。学会多方位思考问题，该题虽然要动态移动窗口，但是并不复杂，
* 不用纠结输入的点怎么判断在那个窗口中，解决方法就是从最上层开始搜索输入的点，
* 选中的窗口再用交换法替换位置即可*/
public class ccf20140302 {
static int N,M;
static int[][] dote;
static Scanner sc;
public static void main(String[] args) {
getNum();
getResult();
}
private static void getNum(){
sc=new Scanner(System.in);
N=sc.nextInt();
M=sc.nextInt();
dote=new int[N][5];
for(int i=0;i<N;i++){
dote[i][0]=i+1;
for(int j=1;j<5;j++)
dote[i][j]=sc.nextInt();
}
}
private static void getResult(){
int[] result=new int[M];
int[] arr=new int[5];
for(int i=0;i<M;i++){
int x=sc.nextInt();
int y=sc.nextInt();
for(int j=N-1;j>=0;j--){//从最后一行搜索
if(x>=dote[j][1]&&x<=dote[j][3]
&&y>=dote[j][2]&&y<=dote[j][4]){//判断点是否在范围窗口范围内
result[i]=dote[j][0];
for(int k=0;k<5;k++) //将选中的窗口坐标保存
arr[k]=dote[j][k];
for(int m=j;m<N-1;m++){ //将上层窗口往下移动
for(int k=0;k<5;k++)
dote[m][k]=dote[m+1][k];
}
for(int k=0;k<5;k++) //将选中窗口置于顶层
dote[N-1][k]=arr[k];
break;
}else{
result[i]=0;
}
}
}
for(int i=0;i<M;i++){
if(result[i]==0)
System.out.println("IGNORED");
else
System.out.println(result[i]);
}
}
}
package test_one;
import java.util.*;
public class ccf20140901 {
/*相邻数对*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int sum=0;
int n=sc.nextInt();
int[] num=new int[n];
for(int i=0;i<n;i++)
num[i]=sc.nextInt();
sc.close();
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(num[i]-num[j]==1) sum++;
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/* 在一个定义了直角坐标系的纸上，画一个(x1,y1)到(x2,y2)的矩形指将横坐标范围从x1到x2，
* 纵坐标范围从y1到y2之间的区域涂上颜色。
* 问题不要想复杂了，将每一个图形（即方块，看成一个数组，）将所有数组加入到一个新的数组
* 在100*100的方格区域中，方格区域用数组接收，每画一个图相当于在相应区域上填充了颜色，
* 每个填充颜色的方格标记为1，而数组元素的默认值为0，所以填充之后，把数组元素之和相加就好了。*/
public class ccf20140902 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int x1,x2,y1,y2;
int[][] f=new int[100][100];
int count=0;
for(int i=0;i<100;i++)
for(int j=0;j<100;j++)
f[i][j]=0;
for(int i=0;i<n;i++){
x1=sc.nextInt();
y1=sc.nextInt();
x2=sc.nextInt();
y2=sc.nextInt();
for(int x=x1;x<x2;x++)
for(int y=y1;y<y2;y++)
f[x][y]=1;
}
for(int i=0;i<100;i++)
for(int j=0;j<100;j++)
if(f[i][j]==1) count++;
System.out.print(count);
sc.close();
}
}
package test_one;
/*字符串匹配*/
import java.util.*;
public class ccf20140903 {
static String str;
static int Switch,line;
static String[] s;
public static void main(String[] args) {
getNum();
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
str=sc.nextLine();
Switch=sc.nextInt();
line=sc.nextInt();
s=new String[line];
for(int i=0;i<line;i++)
s[i]=sc.next(); //这里最开始写的是nextline，导致不能正确赋值，改成next就好了
for(int i=0;i<line;i++)
find(s[i]);
sc.close();
}
private static void find(String s){
int i=0,b;
for(int j=0;j<s.length();j++){
if(Switch==1){ //大小写敏感
for(i=0;i<str.length()&&j+i<s.length();i++)
if(s.charAt(j+i)!=str.charAt(i)) break;
}
if(Switch==0){ //大小写不敏感
for(i=0;i<str.length()&&j+i<s.length();i++){
b=s.charAt(j+i)-str.charAt(i);
if(b<0) b=b*-1;
if(b!=32&&b!=0) break;
//b!=0这里之前写成了s.charAt(j+i)!=str.charAt(i)导致找了一会儿错误
//后来将i、b、s.charAt(j+i)、str.charAt(i)这四个值都分别输出查看，找到问题所在
}
}
//这种情况时HELLOisNOTHello会输出两次,测试为40分，经过调试发现少了break，再测试70分
//if(i==str.length()) System.out.println(s);
if(i==str.length()) {System.out.println(s);break;}
}
}
//少了j+i<s.length()测试用例能通过，但是打了70分
//然后试了下当输入的字符串长度少于要匹配的字符串时，如str=Hello，s=hhhh。
//s.charAt(j+i)数组越界，在自己测试的时候多试下特殊的用例，考虑清楚下标边界。
}
package test_one;
import java.util.*;
/*门禁系统, 一次写对。
* 涛涛最近要负责图书馆的管理工作，需要记录下每天读者的到访情况。
* 每位读者有一个编号，每条记录用读者的编号来表示。给出读者的来访记录，
* 请问每一条记录中的读者是第几次出现。
* 样例输入
* 5
* 1 2 1 1 3
* 样例输出
* 1 1 2 3 1
* */
public class ccf20141201 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] a=new int[n];
for(int i=0;i<n;i++)
a[i]=0;
for(int i=0;i<n;i++){
int t=sc.nextInt();
a[t]++;
System.out.print(a[t]+" ");
}
sc.close();
}
}
package test_one;
import java.util.*;
/*Z字形扫描,这个题目是自己根据矩形的变化寻找规律解出来的。
* 第一次提交只有20分，4*4和5*5都测试了没有错
* 然后在没有改程序的情况下，又重新提交了一次就100分了，笑哭*/
public class ccf20141202 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[][] a=new int[n][n];
int[] r=new int[n*n];
int index=0,t=0;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
a[i][j]=sc.nextInt();
sc.close();
//左上三角形变化
for(int j=0;j<n;j++){
for(int k=0,f=j;f>=0;f--,k++){
if(t%2==0||k==f) r[index++]=a[f][k];//t为偶数时，反向存储；20 11 02
else r[index++]=a[k][f];//t为奇数的时候，正向存储；00 01 10，03 12 21 30
}
t++;
}
//右下三角形变化
for(int i=1;i<n;i++){
for(int k=i,f=n-1;k<n;k++,f--){
if(t%2==0||k==f) r[index++]=a[f][k];
else r[index++]=a[k][f];
}
t++;
}
for(int i=0;i<n*n;i++)
System.out.print(r[i]+" ");
}
}
2015
package test_one;
/*图像旋转90度，一次提交成功100分，用时20分钟
* 样例输入
2 3
1 5 3
3 2 4
样例输出
3 4
5 2
1 3
*/
import java.util.*;
public class ccf20150301 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[][] line=new int[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
line[i][j]=sc.nextInt();
sc.close();
//寻找矩阵下标变化规律
for(int j=m-1;j>=0;j--){
for(int i=0;i<n;i++)
System.out.print(line[i][j]+" ");
System.out.println();
}
}
}
package test_one;
/*
* 数字排序
* 给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。
* 输出多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。
* 如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的。
* 第一次提交100分，用时1小时*/
import java.util.*;
public class ccf20150302 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] a=new int[n];
int[] num=new int[n];
int count=1;
for(int i=0;i<n;i++)
a[i]=sc.nextInt();
sc.close();
Arrays.sort(a);//升序，从小到大
num[0]=a[0];
for(int i=1;i<n;i++){ //存入不重复的输入值
if(num[count-1]!=a[i])
num[count++]=a[i];
}
int sum=0;
int[][] result=new int[count][2];
//将输入数字对应的次数存入一个二维数组
for(int i=0;i<count;i++){
for(int j=00;j<n;j++)
if(num[i]==a[j]) sum++;
result[i][0]=num[i];//存输入数字
result[i][1]=sum;//存次数
sum=0;
}
//冒泡排序法，将次数降序排序
for(int i=0;i<count;i++){
for(int j=0;j<count-1;j++){
if(result[j][1]<result[j+1][1]) { //两两比较，i每次循环都会将小的值往后移
int t=result[j+1][1];
int temp=result[j+1][0];
result[j+1][1]=result[j][1];
result[j+1][0]=result[j][0];
result[j][1]=t;
result[j][0]=temp;
}
}
}
for(int i=0;i<count;i++)
System.out.println(result[i][0]+" "+result[i][1]);
}
}
package test_one;
import java.util.*;
/*数列分段，提交一次成功100分，9分钟
* 给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中共有多少段？*/
public class ccf20150901 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int a[]=new int[n];
int sum=1; //注意第一段不能落了，sum的初始值应该为1
for(int i=0;i<n;i++)
a[i]=sc.nextInt();
sc.close();
for(int i=0;i<n-1;i++){ //注意下标不要越界，n-1
if(a[i]!=a[i+1]) sum++;
}
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/*日期计算,一次提交100分，总用时40分钟。
* 给定一个年份y和一个整数d，问这一年的第d天是几月几日？
* */
public class ccf20150902 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int y=sc.nextInt();
int d=sc.nextInt();
int date[]={31,28,31,30,31,30,31,31,30,31,30,31};
int sum=0;
sc.close();
if((y%4==0&&y%100!=0)||y%400==0) date[1]=29;
else date[1]=28;
for(int i=0;i<12;i++){
sum+=date[i];
if(sum>=d) {
int r=date[i]-(sum-d);
System.out.print(i+1+"\n"+r);
break;
}
}
}
}
package test_one;
import java.util.*;
/*数位之和，提交一次成功100分，10分钟
* 给定一个十进制整数n，输出n的各位数字之和。*/
public class ccf20151201 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
long n=sc.nextInt();
sc.close();
int sum=0;
while(n!=0){
sum+=n%10;
n=n/10;
}
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/*消除类游戏,一次提交100分，用时60分钟
* 棋子为1-9编号，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除，值为0
* */
public class ccf20151202 {
static int n;
static int m;
static int a[][];
static int b[][];
public static void main(String[] args) {
// TODO Auto-generated method stub
getNum();
getResult();
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
m=sc.nextInt();
a=new int[n][m];
b=new int[n][m]; //用来保存需要消除的行列
for(int i=0;i<n;i++)
for(int j=0;j<m;j++){
a[i][j]=sc.nextInt();
b[i][j]=0;
}
sc.close();
for(int i=0;i<n;i++)
for(int j=0;j<m;j++){
fun(i,j);
}
}
private static void fun(int i,int j){
for(int y=j,s=0;y<m;){ //行
if(a[i][j]==a[i][y]) {s++;y++;}
else break;
if(s>=3) fun2(i,j,s); //当行中有连续三个或三个以上相同的，则将b中对应的值赋值1
}
for(int x=i,s=0;x<n;){ //列
if(a[i][j]==a[x][j]) {s++;x++;}
else break;
if(s>=3) fun3(i,j,s);
}
}
private static void fun2(int x,int y,int s){
for(int j=y,n=s;n>0;j++,n--){
b[x][j]=1;
}
}
private static void fun3(int x,int y,int s){
for(int i=x,n=s;n>0;i++,n--)
b[i][y]=1;
}
private static void getResult(){
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(b[i][j]==1) a[i][j]=0;//进行消除
for(int i=0;i<n;i++){
for(int j=0;j<m;j++)
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
2016
package test_one;
import java.util.*;
/*折点计数,提交一次成功100分，10分钟。
* 给定n个整数表示一个商店连续n天的销售量。如果某天之前销售量在增长，而后一天销售量减少，则称这一天为折点，
* 反过来如果之前销售量减少而后一天销售量增长，也称这一天为折点。其他的天都不是折点。
* */
public class ccf20160401 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int a[]=new int[n];
int sum=0;
for(int i=0;i<n;i++)
a[i]=sc.nextInt();
sc.close();
for(int i=1;i<n-1;i++){
if(a[i-1]>a[i]&&a[i+1]>a[i]) sum++;
else if(a[i-1]<a[i]&&a[i+1]<a[i])sum++;
}
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/*俄罗斯方块
* 用时3个多小时，最开始的思路是从底层开始搜索，打40分，这种思路是错的。
* 应该从头搜索，改了之后打70分，后来发现没有考虑到初始方格图全为0的情况
* 经过一次次修改总算打100分了*/
public class ccf20160402 {
static int a[][]=new int[15][10];
static int b[][]=new int[4][4];
static int bb[][]=new int[4][4];
static int bbb[]=new int[8];
static int n;
public static void main(String[] args) {
// TODO Auto-generated method stub
getNum();
getResult();
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
for(int i=0;i<15;i++)
for(int j=0;j<10;j++)
a[i][j]=sc.nextInt();
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
b[i][j]=sc.nextInt();
bb[i][j]=0;
}
n=sc.nextInt();
sc.close();
}
private static void getResult(){
int x=0;
for(int i=0;i<4;i++){ //将所有的图形都从0下标开始重新存入一个数组
int y=0;
for(int j=0;j<4;j++)
if(b[i][j]==1) {bb[x][j]=1;y++;}
if(y!=0) x++;
}
int index=0;
for(int i=0;i<4;i++){ //将方块下标都记录在bbb数组中
for(int j=0;j<4;j++)
if(bb[i][j]==1){
bbb[index++]=i;
bbb[index++]=j;
}
}
for(int i=0,j=n-1;i<15-bbb[6];i++)
//初始全为0的情况，
if(a[i+bbb[0]][j+bbb[1]]==0&&a[i+bbb[2]][j+bbb[3]]==0
&&a[i+bbb[4]][j+bbb[5]]==0&&a[i+bbb[6]][j+bbb[7]]==0&&i==15-bbb[6]-1){
a[i+bbb[0]][j+bbb[1]]=1;
a[i+bbb[2]][j+bbb[3]]=1;
a[i+bbb[4]][j+bbb[5]]=1;
a[i+bbb[6]][j+bbb[7]]=1;
break;
}
//判断是否存在一个四连通方块都等于0，一直往下寻找，知道找到一个不全是等于0的位置就是方块的终点
//那么上一个位置就是存放图形的位置
else
if(a[i+bbb[0]][j+bbb[1]]==0&&a[i+bbb[2]][j+bbb[3]]==0
&&a[i+bbb[4]][j+bbb[5]]==0&&a[i+bbb[6]][j+bbb[7]]==0)
{
continue;
}
else{
a[i+bbb[0]-1][j+bbb[1]]=1;
a[i+bbb[2]-1][j+bbb[3]]=1;
a[i+bbb[4]-1][j+bbb[5]]=1;
a[i+bbb[6]-1][j+bbb[7]]=1;
break;
}
for(int i=0;i<15;i++){
for(int j=0;j<10;j++)
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
package test_one;
import java.util.*;
public class ccf20160901 {
/*最大波动
* 小明正在利用股票的波动程度来研究股票。小明拿到了一只股票每天收盘时的价格，
* 他想知道，这只股票连续几天的最大波动值是多少，即在这几天中某天收盘价格与前一天收盘价格之差的绝对值最大是多少。*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int max=0;
int[] price=new int[n];
for(int j=0;j<n;j++)
price[j]=sc.nextInt();
sc.close();
for(int i=0;i<n-1;i++){
int p=price[i+1]-price[i];
if(p<0) p=p*-1;
if(p>max) max=p;
}
System.out.print(max);
}
}
package test_one;
import java.util.*;
/*火车票，请实现一个铁路购票系统的简单座位分配算法，来处理一节车厢的座位分配。
假设一节车厢有20排、每一排5个座位。为方便起见，我们用1到100来给所有的座位编号，第一排是1到5号，第二排是6到10号，
依次类推，第20排是96到100号。购票时，一个人可能购一张或多张票，最多不超过5张。
如果这几张票可以安排在同一排编号相邻的座位，则应该安排在编号最小的相邻座位。
否则应该安排在编号最小的几个空座位中（不考虑是否相邻）。
假设初始时车票全部未被购买，现在给了一些购票指令，请你处理这些指令。
* 做的时候忽略了第二个条件：安排在编号最小的几个空座位中（不考虑是否相邻），所以第一次只有90分，
*/
public class ccf20160902 {
static int sum=0,n;
static int site[][]=new int[20][5];
static int Num[];
static boolean flag ;
public static void main(String[] args) {
getNum();
getResult();
// flag = true;
// fun(0);
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
Num=new int[n];
int num=1;
for(int i=0;i<n;i++)
Num[i]=sc.nextInt();
sc.close();
for(int i=0;i<20;i++)
for(int j=0;j<5;j++){
site[i][j]=num;
num+=1;
}
}
private static void getResult(){
for(int t=0;t<n;t++){
flag = true;
fun(t);
}
}
private static void fun(int t){
int i=0;
for(i=0;i<20&&flag;i++) {
for(int j=0,b=0;j<5;j++){
if(site[i][j]!=0&&b<Num[t]){
b++;
if(b==Num[t]){
for(int f=j-b+1;b>0;f++)
{
System.out.print(site[i][f]+" ");
site[i][f]=0;
b--;
}
System.out.println();
flag=false;
break;
}
}
}
}
if(i==20){
feifun(t);
}
}
private static void feifun(int t){ //安排在编号最小的几个空座位中（不考虑是否相邻）
int i=0;int b=0;
for(i=0;i<20&&b<Num[t];i++) {
for(int j=0;j<5&&b<Num[t];j++){
if(site[i][j]!=0){
b++;
System.out.print(site[i][j]+" ");
site[i][j]=0;
}
}
}
}
}
package test_one;
import java.util.*;
/*中间数
* 在一个整数序列a1, a2, …, an中，如果存在某个数，大于它的整数数量等于小于它的整数数量，则称其为中间数。在一个序列中，可能存在多个下标不相同的中间数，这些中间数的值是相同的。
给定一个整数序列，请找出这个整数序列的中间数的值。
*先排序，从中间开始判断，这个题目开始只打了80分，该程序参考别人的100分*/
public class ccf20161201{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0;i<n ;i++ ) {
arr[i] = sc.nextInt();
}
sc.close();
Arrays.sort(arr); //排序
int time = 0;
if(n%2==0){ //数量为偶数时，有两个相等的中间数
int mid = arr[n/2-1];
for (int i = 0; i < arr.length; i++) {
if(mid == arr[i]) time++;
}
if(time%2==0) System.out.println(mid);
else System.out.println("-1");
}else{
int mid = arr[n/2]; //数量为奇数时，只有一个中间数
for (int i = 0; i < arr.length; i++) {
if(arr[i]==mid) time++;
}
if(time%2==1) System.out.println(mid);
else System.out.println("-1");
}
}
}
package test_one;
import java.util.*;
public class ccf20161202 {
/*2017-11-30
* 个人所得税起征点为3500元，若S不超过3500，则不交税，3500元以上的部分才计算个人所得税，令A=S-3500元
* 例如，如果小明的税前工资为10000元，则A=10000-3500=6500元，其中不超过1500元部分应缴税1500×3%=45元，
* 超过1500元不超过4500元部分应缴税(4500-1500)×10%=300元，超过4500元部分应缴税(6500-4500)×20%=400元。
* 总共缴税745元，税后所得为9255元。*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int t=sc.nextInt(); //税后工资
sc.close();
if(t<=3500) System.out.print(t);
else{
for(int i=3600;i<200000;i+=100){ //税前工资
int x=0; //记录扣掉的钱
if(i>=3600&&i<=5000) // A中不超过1500元的部分，税率3%
x+=(i-3500)*0.03;
if(i>=5100&&i<=8000) //A中超过1500元未超过4500元的部分，税率10%
x+=(i-5000)*0.1+45;
if(i>=8100&&i<=12500) //A中超过4500元未超过9000元的部分，税率20%
x+=(i-8000)*0.2+45+300;
if(i >=12600 && i <= 38500) //A中超过9000元未超过35000元的部分，税率25%
{
x += (i-12500)*0.25+45+300+900;
}
if(i >= 38600 && i <= 58500) //A中超过35000元未超过55000元的部分，税率30%
{
x += (i-38500)*0.3+45+300+900+6500;
}
if(i >= 58600 && i <= 83500) //A中超过55000元未超过80000元的部分，税率35%
{
x += (i-58500)*0.35+45+300+900+6500+6000;
}
if(i >= 83600) // A中超过80000元的部分，税率45%
{
x += (i-83500)*0.45+45+300+900+6500+6000+8750;
}
if(i-x==t)
{ System.out.print(i);break;}
}
}
}
}
2017
package test_one;
import java.util.*;
/*分蛋糕
* 小明今天生日，他有n块蛋糕要分给朋友们吃，这n块蛋糕（编号为1到n）的重量分别为a1, a2, …, an。
* 小明想分给每个朋友至少重量为k的蛋糕。小明的朋友们已经排好队准备领蛋糕，对于每个朋友，
* 小明总是先将自己手中编号最小的蛋糕分给他，当这个朋友所分得蛋糕的重量不到k时，
* 再继续将剩下的蛋糕中编号最小的给他，直到小明的蛋糕分完或者这个朋友分到的蛋糕的总重量大于等于k。*/
public class ccf20170301 {
public static void main(String[] arg){
@SuppressWarnings("resource")
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int k=sc.nextInt();
int weight[]=new int[1000];
int i,j,number=0,sum=0;
for(i=0;i<n;i++)
weight[i]=sc.nextInt();
for(j=0;j<n;j++){
sum+=weight[j]; //将分给每个小朋友的蛋糕重量相加
if(sum>k||sum==k){ //这个朋友分到的蛋糕的总重量大于等于k
sum=0;
number++;
}
}
if(sum>0&&j==n){number++;} //如果最后一个小朋友分到了蛋糕，但是总重量不满足大于等于k的情况
System.out.print(number);
}
}
package test_one;
import java.util.*;
/*学生排队
* 初始队列中学生的学号依次为1, 2, 3, 4, 5, 6, 7, 8；
* 输入的第一行包含一个整数n，表示学生的数量，学生的学号由1到n编号。
第二行包含一个整数m，表示调整的次数。
接下来m行，每行两个整数p, q，如果q为正，表示学号为p的同学向后移动q，
如果q为负，表示学号为p的同学向前移动-q。
*/
public class ccf20170302 {
static int n,m,p,q;
static int[] student_num;
public static void main(String arg[]){
getNum();
showArray();
}
private static void showArray(){
for(int i=0;i<n;i++)
System.out.print(student_num[i]+" ");
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
n=sc.nextInt(); //学生的数量
m=sc.nextInt(); //表示调整的次数
student_num=new int[n];
for(int i=0;i<n;i++){
student_num[i]=i+1;
}
for(int i=0;i<m;i++){
p=sc.nextInt();
q=sc.nextInt();
moveStudent(p,q);
}
sc.close();
}
private static void moveStudent(int p,int q){
int t = 0,a = 0;
for(int i=0;i<n;i++) {
if(student_num[i]==p) {
t=student_num[i];
a=i; //每调用一次这个函数studen_num中值的顺序将会改变，所以a！=p-1
}
}
if(q<0){ //如果q为负，表示学号为p的同学向前移动-q
for(int j=-q;j>0;j--,a--)
student_num[a]=student_num[a-1];
student_num[a]=t;
}else{
for(int j=0;j<q;j++,a++)
student_num[a]=student_num[a+1];
student_num[a]=t;
}
}
}
package test_one;
/* 小明带着N元钱去买酱油。酱油10块钱一瓶，商家进行促销，
* 每买3瓶送1瓶，或者每买5瓶送2瓶。请问小明最多可以得到多少瓶酱油。
* 第一次用时20分钟提交50分，改了将近15分钟第二次提交100分
* 测试的时候多测试一些用例，不然这个题可能就打50分了*/
import java.util.*;
public class ccf20170901 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int N=sc.nextInt();
sc.close();
int sum=0;
while(N>0){
if(N>=50) {sum+=7;N-=50;}
else if(N>=30){sum+=4;N-=30;}
else if(N>0) {sum+=1;N-=10;} //开始这里没有想到N-=10；
}
System.out.print(sum);
}
}
package test_one;
import java.util.*;
/*公共钥匙盒，用时一个小时五十分钟，第一次提交0分是因为多的输出忘记注释，
* 第二次提交50分是因为排序少考虑了一个条件:如果多把钥匙同时还，按从小到大的顺序。
* */
public class ccf20170902 {
static int N,K;
static int a[][],aa[][];
static int key[];
public static void main(String[] args) {
// TODO Auto-generated method stub
getNum();
fun();
sort();
getResult();
}
private static void getNum(){
Scanner sc=new Scanner(System.in);
N=sc.nextInt();
K=sc.nextInt();
a=new int[K][4];//每行三个整数w, s, c，分别表示一位老师要使用的钥匙编号、开始上课的时间和上课的时长。
aa=new int[K*2][3];//用一个K*2行3列的数组存放取钥匙和还钥匙的时间以及钥匙的编号
key=new int[N]; //钥匙编号
for(int i=0;i<K;i++)
for(int j=0;j<3;j++)
a[i][j]=sc.nextInt();
sc.close();
for(int i=0;i<N;i++)
key[i]=i+1;
}
private static void fun(){
for(int i=0;i<K;i++){
a[i][3]=a[i][1]+a[i][2]; //将每个老师还钥匙的时间保存在a[i][3]
}
for(int i=0;i<K;i++){
aa[i][0]=0; //取钥匙用0标识
aa[i][1]=a[i][0];//存钥匙的编号
aa[i][2]=a[i][1];// 存取钥匙的时间
}
for(int i=K;i<K*2;i++){
aa[i][0]=1; //还钥匙用1标识
aa[i][1]=a[i-K][0]; //存钥匙的编号
aa[i][2]=a[i-K][3]; //还钥匙的时间
}
// for(int i=0;i<K*2;i++){
// for(int j=0;j<3;j++)
// System.out.print(aa[i][j]+" ");
// System.out.println();
// }
}
private static void sort(){ //冒泡排序
int b[]=new int[3];
for(int i=K*2-1;i>0;i--){
for(int j=0;j<i;j++){
if(aa[j][2]>aa[j+1][2]){
b=aa[j];
aa[j]=aa[j+1];
aa[j+1]=b;
}
//如果统一时间又还又取，则先还再取
else if(aa[j][2]==aa[j+1][2]&&aa[j][0]<aa[j+1][0]){
b=aa[j];
aa[j]=aa[j+1];
aa[j+1]=b;
}
//如果同一时间多把钥匙同时还，按从小到大的顺序
else if(aa[j][2]==aa[j+1][2]&&aa[j][1]>aa[j+1][1]&&aa[j][0]==aa[j+1][0]){
b=aa[j];
aa[j]=aa[j+1];
aa[j+1]=b;
}
}
}
// System.out.println("sort");
// for(int i=0;i<K*2;i++){
// for(int j=0;j<3;j++)
// System.out.print(aa[i][j]+" ");
// System.out.println();
// }
}
private static void getResult(){
for(int i=0;i<K*2;i++){
if(aa[i][0]==0) { //取钥匙
for(int y=0;y<N;y++){
if(aa[i][1]==key[y]) {key[y]=0; break; }
}
}
else
if(aa[i][0]==1) { //还钥匙
for(int x=0;x<N;x++){
if(key[x]==0) //找最左边的空缺
{key[x]=aa[i][1];break;}
}
}
}
for(int i=0;i<N;i++)
System.out.print(key[i]+" ");
}
}
other
package test_one;
import java.util.*;
/*给定两个整数M，N，生成一个M*N的矩阵，矩阵中元素取值为A至Z的26个字母中的一个，A在左上角，
* 其余各数按顺时针方向旋转前进，依次递增放置，当超过26时又从A开始填充。例如，当M=5，N=8时，矩阵中的内容如下：
* A B C D E F G H
V W X Y Z A B I
U J K L M N C J
T I H G F E D K
S R Q P O N M L
*/
public class test3 {
static int M;//行
static int N;//列
static char[][] a;
static int t1,t2,t3,t4;
static char temp='A';
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
M=sc.nextInt();
N=sc.nextInt();
sc.close();
a=new char[M][N];
//t1 t2右下角，t3 t4左上角
t1=M; //管下行的变化(向左)
t2=N; //管右列的变化(向下)
t3=0; //管左列的变化(向上)
t4=0; //管上行的变化(向右)
fun();
getResult();
}
private static void fun(){
while(jude(M,N)){
for(int i=t3;i<t2;i++){ //向右
if(temp>'Z') temp='A';
a[t4][i]=temp;
temp++;
}
t4++; //每赋值一次少一行（上）
for(int i=t4;i<t1;i++){ //向下
if(temp>'Z') temp='A';
a[i][t2-1]=temp;
temp++;
}
if(!jude(M,N)) break;
t2--; //每赋值一次少一列（右）
for(int i=t2-1;i>=t3;i--){ //向左
if(temp>'Z') temp='A';
a[t1-1][i]=temp;
temp++;
}
if(!jude(M,N)) break;
t1--; //每赋值一次少一行（下）
for(int i=t1-1;i>=t4;i--){ //向上
if(temp>'Z') temp='A';
a[i][t3]=temp;
temp++;
}
if(!jude(M,N)) break;
t3++; //每赋值一次少一列（左）
}
}
private static boolean jude(int n,int m){
for(int i=0;i<M;i++)
for(int j=0;j<N;j++){
if(a[i][j]==0) return true;
}
return false;
}
private static void getResult(){
for(int i=0;i<M;i++){
for(int j=0;j<N;j++)
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
