过年弄得也没写代码了,最近开始继续奋斗  * * * 问题描述  Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。  输入格式：输入有两行，分别为两个单词。  输出格式：输出只有一个字母Y或N，分别表示Yes和No。  输入输出样例  样例输入  Unclear  Nuclear  样例输出  Y ## 笨方法 一开始没看懂题目,用了笨方法,就是把每个字母出现的次数记录下来,得了80分,错了两组数据,因为不是VIP暂时看不到数据,想了想也不知道错在哪 ~~~ import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String str1 = input.next(); String str2 = input.next(); str1 = str1.toLowerCase(); str2 = str2.toLowerCase(); if (str1.length()!=str2.length()){ System.out.println("N"); System.exit(0); } input(str1,str2); } /** *接收两个串,然后比较 */ private static void input(String str1,String str2){ int[] arr1 = new int[str1.length()]; int[] arr2 = new int[str2.length()]; for (int i = 0; i < str1.length(); i++) { arr1[i] = judge(str1.charAt(i),str1); } for (int i = 0; i < str2.length(); i++) { arr2[i] = judge(str2.charAt(i),str2); } for (int i = 1; i < str1.length(); i++) { if (arr1[0] !=arr1[i]){ System.out.println("N"); return; } } for (int i = 1; i < str2.length(); i++) { if (arr2[0] !=arr2[i]){ System.out.println("N"); return; } } System.out.println("Y"); } /* 计算字母在一个字符串中出现的次数 */ private static int judge(char a,String str){ int start = 0,count = 0; while ((start = str.indexOf(a, start)) >= 0){ start++; count++; } return count; } } ~~~ ## 简单方法 先排序,然后直接比较排序后的数组是否相等即可 ~~~ private static void judge1(String str1,String str2){ char[] a = str1.toCharArray(); char[] b = str2.toCharArray(); Arrays.sort(a); Arrays.sort(b); if (Arrays.equals(a,b)){ System.out.println("Y"); }else { System.out.println("N"); } } ~~~

又是递归题目,每次递归题目都有点饶人,但是一旦发现规律后就写起来简单了很多. * * * 问题描述  每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。  每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）  输入格式  两个整数，表示m和n  输出格式  一个整数，表示队伍的排法的方案数。  样例输入  3 2  样例输出  5  数据规模和约定  　　m,n∈［0,18］  　　问题分析  * * * 就四种情况, 抽象一下,m是还鞋的,n是租鞋的,  1.m小于么是肯定不够租的,所以次数是0  2.m大于等于n,这个时候开始排队,第一个肯定排m还鞋的人,此时第二个任意,要么排m,要么排n.如果第二个排n那么第三个肯定是m,就这样一直排下去即可  代码: ~~~ import java.util.Scanner; public class Main { static int m,n; public static void main(String[] args) { Scanner input = new Scanner(System.in); m = input.nextInt(); n = input.nextInt(); if (m<n){ System.out.println(0); }else { System.out.println(fun(m,n)); } } private static int fun(int x,int y){ if (x ==0 ||y ==0){ return 1; }//排队人数中还鞋的等于租谢的 else if (m-x == n-y){ return fun(x-1,y); }//排队人数中还鞋的大于租谢的 else if (m-x>n-y){ return fun(x-1,y)+fun(x,y-1); }else { return 0; } } } ~~~

这个挺简单的,就是就是注意下当范围小于等于0的时候是不输出的 * * * 问题描述  编写一个程序，读入一组整数，这组整数是按照从小到大的顺序排列的，它们的个数N也是由用户输入的，最多不会超过20。然后程序将对这个数组进行统计，把出现次数最多的那个数组元素值打印出来。如果有两个元素值出现的次数相同，即并列第一，那么只打印比较小的那个值。  输入格式：第一行是一个整数N，N £ 20；接下来有N行，每一行表示一个整数，并且按照从小到大的顺序排列。  输出格式：输出只有一行，即出现次数最多的那个元素值。  输入输出样例  样例输入  5  100  150  150  200  250  样例输出  150 ~~~ import java.util.Scanner; public class Main { public static void main(String[] args) { int max = 0;//定义最大次数 int num = 0;//定义最大次数对应的数 int count = 1;//定义临时计数器 Scanner input = new Scanner(System.in); int n = input.nextInt(); if(n<=0){ System.exit(0); } int[] a = new int[n]; for (int i = 0; i < a.length; i++) { a[i] = input.nextInt(); //当输入数据等于前一个数据时,计数器自加 if (i>=1 &&a[i]==a[i-1]) { count++; //当计数器大于max时候赋值给max if (max<count){ max = count; num = a[i]; } continue; } //每一轮计数器归1 count = 1; } if (num==0){ System.out.println(a[0]); }else { System.out.println(num); } } } ~~~

这道题因为格式限定所以比较简单,自己用正则表达式就给扩展了下,写成了多项匹配的代码,顺便复习了正则,测试数据少,可能有没发现的错误,如有发现请指出 [**点此直达扩展代码**](#) ### 题目 问题描述 编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。输入格式为：“运算符 对象1 对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除法），运算对象为不超过10的整数，它们之间用一个空格隔开。要求：对于加、减、乘、除这四种运算，分别设计相应的函数来实现。 输入格式：输入只有一行，即一个前缀表达式字符串。 输出格式：输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果为整数）。 输入输出样例 样例输入 + 5 2 样例输出 7 ### 题目要求的代码 ~~~ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); //获得输入串 String str = input.nextLine(); //把输入串以空格分成数组 String[] arr = str.split(" "); //提取出算术运算符 char[] letter = arr[0].toCharArray(); //依次计算 switch (letter[0]){ case '+': System.out.println(Integer.parseInt(arr[1])+Integer.parseInt(arr[2])); break; case '-': System.out.println(Integer.parseInt(arr[1])-Integer.parseInt(arr[2])); break; case '*': System.out.println(Integer.parseInt(arr[1])*Integer.parseInt(arr[2])); break; case '/': System.out.println(Integer.parseInt(arr[1])/Integer.parseInt(arr[2])); break; } } } ~~~ ### 扩展的通用代码 ~~~ import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Created by nl101 on 2016/1/22. */ public class Main1 { public static void main(String[] args) { //测试数据((12+2)-6)/2 String str = "/ - + 12 2 6 2"; System.out.println(prefix(str)); } private static String prefix(String str){ //用于匹配 运算符 空格 数字 空格 数字的正则 Pattern p = Pattern.compile("[\\+\\-\\*\\/][\\s]\\d{1,}[\\s]\\d{1,}"); Matcher matcher = p.matcher(str); //开始匹配 while (matcher.find()){ //计算匹配的值 如,+ 12 2 则返回14 String temp = calculate(matcher.group()); StringBuffer sb = new StringBuffer(); //替换上面的为计算出来的数值 matcher.appendReplacement(sb,temp); //追加剩余子串 matcher.appendTail(sb); str = sb.toString(); //或者上面都注释掉用下面一句话都可以了 // str = matcher.replaceFirst(calculate(matcher.group())); //递归循环 return prefix(str); } return str; } /** * 和第一个程序一样,计算出来+ 12 2这种类型数值 * @param str * @return */ private static String calculate(String str){ String[] arr = str.split(" "); int i = 0; char[] letter = arr[0].toCharArray(); switch (letter[0]){ case '+': i = Integer.parseInt(arr[1])+Integer.parseInt(arr[2]); break; case '-': i = Integer.parseInt(arr[1])-Integer.parseInt(arr[2]); break; case '*': i = Integer.parseInt(arr[1])*Integer.parseInt(arr[2]); break; case '/': i = Integer.parseInt(arr[1])/Integer.parseInt(arr[2]); break; } return String.valueOf(i); } } ~~~ 水平不高,有好的建议欢迎留言

首先这道题目的测试答案官方是有问题的哈,所以最高只能得到60分 问题描述 已知一个正整数N，问从1~N中任选出三个数，他们的最小公倍数最大可以为多少。 输入格式 输入一个正整数N。 输出格式 输出一个整数，表示你找到的最小公倍数。 样例输入 9 样例输出 504 数据规模与约定 1 <= N <= 106。 ### 分析 博主傻乎乎的暴力方法搞了半天,无奈唉,数学差,百度了一下发现了数论知识,总结如下: **1:**若n 和 n-1和n-2 三个数 两两互质的话，那么结果就是这三个数的积 **2:**当n是奇数时，n 和n-2都是奇数，n-1是偶数,那么他们三个的公约数肯定不是2,而因为这三个数是连续的，所以大于2的数都不可能成为他们或其中任意两个数的公约数了.结果就是他们三个的乘积. **3:**当n为偶数时，n*(n-1)*(n-2)肯定不行了，因为n和n-2都是偶数，那么只能将n-2改成n-3，即n*(n-1)*(n-3),如果这三个数两两互质那么肯定就是结果了. **4:**如果n能整除3，那么，n*(n-1)*(n-3)就肯定不行了，因为n和n-3有了公约数3，结果肯定小了，那么就只能继续判下一个即n*(n-1)*(n-4)而这样n-4又是偶数，不行继续下一个n*(n-1)*(n-5) = n^3 -6*n^2 + 5*n 而如果这个可以 那个其值肯定要小于(n-1)*(n-2)*(n-3) = n^3 -6*n^2+11n-6(对于n>1来说都成立),而(n-1)*(n-2)*(n-3)由上一个奇数结论可知是一个符合要求的，因此到n-5就不用判断了。直接选答案为(n-1)*(n-2)*(n-3)； 代码如下: ~~~ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); double n = input.nextDouble(); getMaxCommon(n); } private static void getMaxCommon(double n) { if (n<3) { System.out.printf("%.0f",n); }else if (n%2!=0) { System.out.printf("%.0f",n*(n-1)*(n-2)); }else{ if (n%3!=0) { System.out.printf("%.0f",n*(n-1)*(n-3)); }else { System.out.printf("%.0f",(n-3)*(n-1)*(n-2)); } } } } ~~~

问题描述 任何一个正整数都可以用2进制表示，例如：137的2进制表示为10001001。 将这种2进制表示写成2的次幂的和的形式，令次幂高的排在前面，可得到如下表达式：137=2^7+2^3+2^0 现在约定幂次用括号来表示，即a^b表示为a（b） 此时，137可表示为：2（7）+2（3）+2（0） 进一步：7=2^2+2+2^0 （2^1用2表示） 3=2+2^0 所以最后137可表示为：2（2（2）+2+2（0））+2（2+2（0））+2（0） 又如：1315=2^10+2^8+2^5+2+1 所以1315最后可表示为： 2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0） 输入格式 正整数（1<=n<=20000） 输出格式 符合约定的n的0，2表示（在表示中不能有空格） 样例输入 137 样例输出 2(2(2)+2+2(0))+2(2+2(0))+2(0) 样例输入 1315 样例输出 2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0) 提示 用递归实现会比较简单，可以一边递归一边输出 分析: 按照递归程序设计,基本情况,指数为0,1,2的时候分别输出2(0),2,2(2),指数大于2的时候输出2(,然后递归,递归结束输出),最后还剩一个+号问题,当不是最后一位的时候就需要输出+号了,具体看程序 ~~~ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int num = input.nextInt(); getIndex(num);//调用程序 } private static void getIndex(int n) { int num = 0; int i = 0; int[] a = new int[32]; //把为1的位置都放入到a数组中 while(n>0){ int j = n%2; if (j==1) { a[num++] = i; } i++; n /=2; } //循环遍历数组,分四种情况 for (i = num - 1; i >=0; i--) { if (a[i]==0) { System.out.print("2(0)"); }else if (a[i]==1) { System.out.print("2"); }else if (a[i]==2) { System.out.print("2(2)"); }else if (a[i]>2) {//当大于2的时候就需要递归了 System.out.print("2("); getIndex(a[i]); System.out.print(")"); } if (i!=0) {//只要不是最后一位都需要输出+号 System.out.print("+"); } } } } ~~~

~~~ 总体来说递归基本可表述成以下类似的结构： 递归调用(参数) { if (基本情形) { // ... // 完成，收工 } else { // 递归情形 // ... 递归调用( 新参数 ); } } 因此，写递归程序一是明确基本情形，二是找出递归情形。 ~~~ ### eg1:求阶乘 也就是输入一个数,然后求出他的阶乘,例如输入5,则求5!=120 **分析:** 画出示意图如下:  可以看出基本情形就是1!=1,特殊情形就等于f(n-1),所以程序如下 ~~~ private static int getIndex(int n) { if (n==1) { return 1;//基本情况 }else{ return n * getIndex(n-1);//特殊情况 } } ~~~ ### eg2:斐波那契数列 输入一个数表示斐波那契数列的第几项,然后找出这一项的值 **分析:**  可以看出基本情景就是f(2)=1,f(1)=1,特殊情景就是f(n-1)+f(n-2) 所以程序如下 ~~~ private static int getIndex(int n) { if (n==1||n==2) { return 1;//基本情况 }else{ return getIndex(n-1)+getIndex(n-2);//特殊情况 } } ~~~ ### eg3:汉诺塔问题 大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。 **分析**三个柱子分别是ABC,现在要从A移动到C 当只有一个盘子时,只需要A->C 当有两个盘子的时候,先A->B,再A->C,再B->C 当有三个盘子的时候,先把前两个借助C移动到B,然后再把第三个移动到C,剩下两个再如此进行 当有N个盘子的时候,先把N-1个盘子借助C移动到B,再把第N个移动到C,剩下N-1个盘子,再借助C移动到AN-2个,再把第N-1个盘子移动到C,如此循环  对于图片又要解释的就是,移动分两步,一步是移动到目标,另一步则是借助一个柱子,移动N-1个到空闲柱子,那基本情况就是当盘子为1的时候,直接移动到目标,代码如下 ~~~ private static void move(int n,char from,char to,int i){ System.out.println("移动第"+n+"个盘子从"+from+"-->"+to+"--"+i); } private static void hanoi(int n,char from,char depand_on,char to){ if (n==1) { move(n, from, to,1);//如果只剩最后一个盘子就将盘子移动到指定位置 }else { hanoi(n-1, from, to, depand_on); move(n, from, to,0); hanoi(n-1, depand_on, from, to); } } ~~~  看输入,每动其他盘子,后面必要动第一个盘子,也就是执行N==1这个情况

问题描述 给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。 输入格式 第一行包含一个数n，表示序列长度。 第二行包含n个正整数，表示给定的序列。 第三个包含一个正整数m，表示询问个数。 接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。 输出格式 总共输出m行，每行一个数，表示询问的答案。 样例输入 5 1 2 3 4 5 2 1 5 2 2 3 2 样例输出 4 2 数据规模与约定 对于30%的数据，n,m<=100； 对于100%的数据，n,m<=1000； 保证k<=(r-l+1)，序列中的数<=106。 正常思维写代码即可 ~~~ import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] arg) { Scanner input = new Scanner(System.in); int n = input.nextInt();//数组长度 int[] a = new int[n]; for (int i = 0; i < a.length; i++) { a[i] = input.nextInt(); } n = input.nextInt();//输入要查找的数量 int[][] b = new int[n][3]; for (int i = 0; i < b.length; i++) { for (int j = 0; j < 3; j++) { b[i][j] = input.nextInt(); } } //循环打印出第k大的数 for (int i = 0; i < b.length; i++) { System.out.println(findMax(a, b[i][0], b[i][1], b[i][2])); } } /** * 查找指定长度数组数值排行 * @param a 要查的数组 * @param start 数组起始位置 * @param end 数组结束位置 * @param k 要查找第k大的数 * @return 第k大的数值 */ public static int findMax(int[] a,int start,int end,int k){ int[] temp = Arrays.copyOfRange(a, start-1, end); Arrays.sort(temp); return temp[temp.length-k]; } } ~~~

问题描述 给定n个十六进制正整数，输出它们对应的八进制数。 输入格式 输入的第一行为一个正整数n （1<=n<=10）。 接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。 输出格式 输出n行，每行为输入对应的八进制正整数。 【注意】 输入的十六进制数不会有前导0，比如012A。 输出的八进制数也不能有前导0。 样例输入 　　2 　　39 　　123ABC 样例输出 　　71 　　4435274 【提示】 先将十六进制数转换成二进制数，再由二进制数转换成八进制。 　　 难点就是数值太大了,10w个F啊, 思路就是换成二进制再换成八进制,用java大数类一直超时,所以不能用大数方法 ### 先来超时的方法 ~~~ import java.math.BigInteger; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int n = input.nextInt(); String[] arr = new String[n]; for (int i = 0; i < n; i++) { String temp = input.next(); BigInteger num = new BigInteger(temp,16); arr[i] = num.toString(8).toUpperCase(); } for (String string : arr) { System.out.println(string); } } } ~~~ ### 下面是正确的方法 ~~~ package com.day7; import java.util.Scanner; public class Main { //定义16进制需要的二进制码 static String[] hex = {"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"}; public static void main(String[] args) { Scanner input = new Scanner(System.in); int n = input.nextInt(); String[] arrs = new String[n]; for (int i = 0; i < n; i++) { arrs[i] = input.next(); } for (int i = 0; i < arrs.length; i++) { translateToOct(translateToBin(arrs[i])); } } //把得到的二进制串转换成八进制 private static void translateToOct(StringBuilder builder){ StringBuilder builder2 = new StringBuilder(); for (int i = 0; i < builder.length()-1; i = i+3) { switch (builder.substring(i, i+3)) { case "000": builder2.append("0"); break; case "001": builder2.append("1"); break; case "010": builder2.append("2"); break; case "011": builder2.append("3"); break; case "100": builder2.append("4"); break; case "101": builder2.append("5"); break; case "110": builder2.append("6"); break; case "111": builder2.append("7"); break; } } if (builder2.charAt(0) == '0') { builder2.deleteCharAt(0); } System.out.println(builder2.toString()); } //把输入的字符串变成二进制串 private static StringBuilder translateToBin(String str){ StringBuilder builder = new StringBuilder(); //转换后补0凑成3的倍数 if ((str.length()*4)%3 != 0) { if ((str.length()*4)%3 == 1) { builder.append("00"); }else { builder.append("0"); } } //接下来开始转换 for (int i = 0; i < str.length(); i++) { switch (str.charAt(i)) { case '0': builder.append(hex[0]); break; case '1': builder.append(hex[1]); break; case '2': builder.append(hex[2]); break; case '3': builder.append(hex[3]); break; case '4': builder.append(hex[4]); break; case '5': builder.append(hex[5]); break; case '6': builder.append(hex[6]); break; case '7': builder.append(hex[7]); break; case '8': builder.append(hex[8]); break; case '9': builder.append(hex[9]); break; case 'A': builder.append(hex[10]); break; case 'B': builder.append(hex[11]); break; case 'C': builder.append(hex[12]); break; case 'D': builder.append(hex[13]); break; case 'E': builder.append(hex[14]); break; case 'F': builder.append(hex[15]); break; } } return builder; } } ~~~

问题描述 十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。 给出一个非负整数，将它表示成十六进制的形式。 输入格式 输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647 输出格式 输出这个整数的16进制表示 样例输入 30 样例输出 1E 数据范围有点大哈,所以用BigInteger ~~~ import java.math.BigInteger; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String temp = input.nextLine(); BigInteger num = new BigInteger(temp); //toString方法可以直接设置精度 System.out.println(num.toString(16).toUpperCase()); } } ~~~

问题描述 123321是一个非常特殊的数，它从左边读和从右边读是一样的。 输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。 输入格式 输入一行，包含一个正整数n。 输出格式 按从小到大的顺序输出满足条件的整数，每个整数占一行。 样例输入 52 样例输出 899998 989989 998899 数据规模和约定 1<=n<=54。 ~~~ //思路是把这个数当成字符串翻转,翻转后和原字符串相同即可 import java.util.Scanner; public class Main{ public static void main(String[] args) { int n = 0; Scanner input = new Scanner(System.in); n = input.nextInt(); for (int i = 10000; i < 1000000; i++) { if (translate(i,n)) { System.out.println(i); } } } private static boolean translate(int i,int n){ String temp = String.valueOf(i); if (sum(temp) != n) { return false; } StringBuilder builder = new StringBuilder(temp); builder = builder.reverse(); if (temp.equals(builder.toString())) { return true; } return false; } private static int sum(String temp){ int sum = 0; for (int i = 0; i < temp.length(); i++) { sum += (temp.charAt(i)-'0'); } return sum; } } ~~~

 1. ~~~ public class Main { public static void main(String[] args) { String A = "Hello World"; String B = "Welcome to attend the contest"; String C = "Achieve good mark"; System.out.println(Translatestr(A)); System.out.println(Translatestr(B)); System.out.println(Translatestr(C)); } private static StringBuilder Translate(String str) { String[] data = str.split(" "); StringBuilder temp = new StringBuilder(); for (int i = 0; i < data.length; i++) { data[i] = Translatestr(data[i]); temp.append(data[i]); } return temp; } private static String Translatestr(String data) { char [] temp = data.toCharArray(); char c; for (int i = 0; i < temp.length/2; i++) { c = temp[i]; temp[i] = temp[temp.length-i-1]; temp[temp.length-i-1] = c; if (i == temp.length-i) { break; } } return new String(temp); } } ~~~ 2. ~~~ public class Sort { public static void main(String[] args) { int a[] = {8,21,7,9,10,13}; sort(a); for (int i : a) { System.out.print(i+" "); } } private static void sort(int[] a) { for (int i = 0; i < a.length-1; i++) { for (int j = 0; j < a.length-1-i; j++) { if (a[j]>a[j+1]) { a[j] = a[j] ^ a[j+1]; a[j+1] = a[j] ^ a[j+1]; a[j] = a[j] ^ a[j+1]; } } } } } ~~~ 3. ~~~ import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class Main { public static void main(String[] args) { SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd"); SimpleDateFormat sdf2 = new SimpleDateFormat("E"); String str = "2014-11-28"; Date date = null; try { date = sdf.parse(str); } catch (ParseException e) { e.printStackTrace(); } if (date.getDate()!=13||date.getDate()!=5) { // if (sdf2.format(date).equals("星期五")) { // System.out.println("这天是黑色星期五"); // } if (date.getDay()==5) { System.out.println("这天是黑色星期五"); } } } } ~~~ 4. ~~~ public class Main { public static void main(String[] args) { int a = 15; findOrder(a); } private static void findOrder(int a) { String str = ""; int sum = 0; for (int i = a-1; i > 0; i--) { sum = 0; str = ""; for (int j = i; j > 0; j--) { sum += j; str += String.valueOf(j) + "+"; if (sum == 15) { System.out.println(str.substring(0, str.length()-1)); break; }else if(sum < 15) { continue; }else { break; } } } } } ~~~

问题描述 从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。 注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。 样例输入 FFFF 样例输出 65535 分析 本题不可以用integer自带的方法转,因为8个F会超出界限,报出NumberFormatException异常,所以需要用其他方法,本题思路,高位*16+低位,直到到个位 ~~~ import java.math.BigInteger; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String str = input.next(); String a[] = new String[str.length()]; for (int i = 0; i < str.length(); i++) { switch (str.charAt(i)) { case '1': a[i] = "1"; break; case '2': a[i] = "2"; break; case '3': a[i] = "3"; break; case '4': a[i] = "4"; break; case '5': a[i] = "5"; break; case '6': a[i] = "6"; break; case '7': a[i] = "7"; break; case '8': a[i] = "8"; break; case '9': a[i] = "9"; break; case 'A': a[i] = "10"; break; case 'B': a[i] = "11"; break; case 'C': a[i] = "12"; break; case 'D': a[i] = "13"; break; case 'E': a[i] = "14"; break; case 'F': a[i] = "15"; break; default: a[i] = "0"; break; } } BigInteger bigInteger = new BigInteger(a[0]); BigInteger bigInteger2 = new BigInteger("16"); for (int i = 1; i < a.length; i++) { bigInteger = bigInteger.multiply(bigInteger2).add(new BigInteger(a[i])); } System.out.println(bigInteger); } } ~~~ 备注:还可以用二进制串的方法

这道题不想写的那么麻烦,就百度了一下.java有现成的API可以使用,这里"yyyy/MM/dd"中的M必须大写,否则解析失败,害了我找错误找了好久... 另外,scanner的next不能输入空格,他是以空格作为结束标志,而nextline则是以enter作为结束标志 ~~~ SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd");//M是大写 df.setLenient(false); //设置是否严格解析日期,不合法则则不可解析 ~~~ 完整代码如下: ~~~ /** * 用比较复杂的方法来实现,主要目的来熟悉dateformat */ import java.text.SimpleDateFormat; import java.util.Scanner; public class Main { public static void main(String[] args) { SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd");//M是大写 Scanner input = new Scanner(System.in); String dateStr = input.nextLine();//next则不能接收空格 dateStr = dateStr.replaceAll(" ", "/"); try { df.setLenient(false); //设置是否严格解析日期,不合法则则不可解析 df.parse(dateStr); } catch (Exception e) { System.out.println(0); System.exit(0); } System.out.println(1); } } ~~~

这道题花了很多时间,主要博主比较菜,花了很多时间去看这个动态规划,了解的不够深入,花了点心思写了出来这个程序. 动态规划,就是避免重复的计算,把上一次计算的结果直接拿来用,比如这道题目,如果最大值是负的,那说明整个数组都是负数.如果不是,则输入的第一个数是第一组的最大值,第二个数的判断就是为正还是为负,根据第一个数的正负来判断下一步操作,同样,每输入一个数都是如此判断. ~~~ import java.util.Scanner; /* * 如果最大值为负数,说明里面所有数都是负数,因此只要找到最大的素数即可 * 简单的动态规划的运用,把上一次比较结果存储下来,用于下一次比较 */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int num,sum = 0,max = 0,max_; //max为最终的输出结果.sum存储比较的结果 //max_存储全是负数情况的最大值 boolean flag = false; num = input.nextInt(); int a[] = new int[num]; for (int i = 0; i < num; i++) { a[i] = input.nextInt(); sum = sum+a[i]; if(a[i] > 0){//确定是否为全负的数组 flag = true; } if(sum < 0){//动态规划 sum = 0; } if(sum > max){ max = sum; } } if(!flag){ max_ = a[0]; for (int i = 0; i < a.length; i++) { if(a[i] > max_){ max_ = a[i]; } } System.out.println(max_); }else { System.out.println(max); } } } ~~~

这个程序一开始没考虑到全9的特殊情况,导致提交一直不通过,程序写的有点多,不太符合题目的本意要求,后续找到优秀的算法,再改正 ~~~ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static void main(String[] args) { List<Integer> bList = new ArrayList<Integer>(); Scanner input = new Scanner(System.in); int num,temp; num = input.nextInt(); for (int i = 0; i < num; i++) { temp = input.nextInt(); bList.add(temp); } temp = judge(bList, num); if((num-1-temp>-1)&&(bList.get(num-1-temp)!=9)){ bList.set(num-1-temp, bList.get(num-1-temp)+1); }else { bList.set(num - temp, 0); } for (int i = (num-1); i >num - temp - 1 ; i--) { bList.set(i, 0); } if (judgezero(bList) == 0) { bList.add(0,1); } for (int i : bList) { System.out.print(i + " "); } } public static int judge(List<Integer> bList,int num) { int temp = 0; for (int i = (num-1); i >-1; i--) { if (bList.get(i) == 9) { temp++; }else { break; } } return temp; } public static int judgezero(List<Integer> bList) { int sum = 0; for (int i = 0; i < bList.size(); i++) { sum = sum + bList.get(i); } return sum; } } ~~~

做这道题的过程中,了解到java的二维数组实际上就是多个一维数组的数组,所以类似下面这样的赋值是可以实现的. ~~~ public static void upturn(int d[][],int a,int b) { int[] e = new int[b]; for (int i = 0; i < a/2; i++) { e = d[i]; d[i] = d[a-i-1]; d[a-i-1] = e; } } ~~~ 有了这个特性,那么矩阵翻转就变得很方便了,不过左右翻转,这个倒是没法实现 完整代码如下: ~~~ import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner input = new Scanner(System.in); int a,b,c; a = input.nextInt(); b = input.nextInt(); c = input.nextInt(); int[][] d = new int[a][b]; for (int i = 0; i < a; i++) { for (int j = 0; j < b; j++) { d[i][j] = input.nextInt(); } } if(c == 1){ upturn(d, a, b); }else { leftturn(d, a, b); } for (int[] is : d) { for (int i : is) { System.out.print(i+" "); } System.out.println(); } } public static void upturn(int d[][],int a,int b) { int[] e = new int[b]; for (int i = 0; i < a/2; i++) { e = d[i]; d[i] = d[a-i-1]; d[a-i-1] = e; } } public static void leftturn(int d[][],int a,int b) { int temp; for (int i = 0; i < b/2; i++) { for (int j =0 ; j < a; j++) { temp = d[j][i]; d[j][i] = d[j][b-i-1]; d[j][b-i-1] = temp; } } } } ~~~

原文出处：[程序设计训练](http://blog.csdn.net/column/details/practicedayday.html) 作者：[u012706811](http://blog.csdn.net/u012706811) **本系列文章经作者授权在看云整理发布，未经作者允许，请勿转载！** # 程序设计训练 > 做一些程序设计题目,训练编程能力,申请专栏,督促自己