华为上机题汇总

Full Stack Developme

于 2017-10-16 09:36:49 发布

阅读量543

点赞数

文章标签：算法与数据结构

—————————————————————————————————————————————————————————————————

转载自：http://blog.csdn.net/sheepmu/article/details/20941803

——————————————————————————————————————————————————————————————————

以下华为上机题目都是网上整理得到的，代码都是自己调试过的，由于网上java答案较少，欢迎大家批评指正，也希望对准备华为上机的童鞋们有一点点帮助。在练习的过程中成长，加油！~~

第1题：输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。从后向前比较，以最短字符串为标准，输出不同的元素的个数。
例如: 输入：s1="1,3,5" len1=3 s2="2,4,1,7,5" len2=5
输出：1

[java] view plain copy print ?

package com.sheepmu.text;
/**
* 输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。从后向前比较，以最短字符串为标准，输出不同的元素的个数。例如: 输入：s1="1,3,5" len1=3 s2="2,4,1,7,5" len2=5
输出：1
函数原型 public int getDiffNum(int len1, String s1, int len2, String s2)
* @author sheepmu
*
*/
public class HWText {
public static void main(String[] args){
String s1="1,3,5";
int len1=3;
String s2="2,4,1,7,5";
int len2=5;
int diffNum= getDiffNum(s1,len1,s2,len2);
System.out.println("不同的数目："+diffNum);
}
public static int getDiffNum(String s1,int len1,String s2,int len2){
String[] str1=s1.split(",");
String[] str2=s2.split(",");
int len=len1>len2? len2:len1;
int count=0;
for(int i=0;i<len;i++){
if(!str1[len1-1-i].equals(str2[len2-1-i]))
count++;
}
return count;
}
}

package com.sheepmu.text;
 /**
  *  输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。从后向前比较，以最短字符串为标准，输出不同的元素的个数。 例如:  输入：s1="1,3,5"   len1=3        s2="2,4,1,7,5"   len2=5  
  			输出：1 
 
    函数原型 public int getDiffNum(int len1, String s1, int len2, String s2)
  * @author sheepmu
  *
  */
public class HWText {
	 public static void main(String[] args){
	 String s1="1,3,5";
	 int len1=3;
	 String s2="2,4,1,7,5";
	 int len2=5;
	 int diffNum= getDiffNum(s1,len1,s2,len2);
	 System.out.println("不同的数目："+diffNum);
	 }
	 public static int getDiffNum(String s1,int len1,String s2,int len2){
		 String[] str1=s1.split(",");
		 String[] str2=s2.split(",");
		 int len=len1>len2? len2:len1;
		 int count=0;
		 for(int i=0;i<len;i++){
			 if(!str1[len1-1-i].equals(str2[len2-1-i]))
				 count++;
		 }
		 return count;
	 }
}

第2题：输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
例如: 输入：3+8×2/9-2
输出：2

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.List;
/****
*输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
例如: 输入：3+8×2/9-2
输出：2
函数原型 . public int getMyRet(String str)
* @author sheepmu
*
*/
public class HWText {
public static void main(String[] args){
String s="3+8×2/9-2 ";
int result=getMyRet(s);
System.out.println("最后结果："+result);
}
public static int getMyRet(String s1 ){
int len=s1.length();
List<String> list=new ArrayList<String>();
for(int i=0;i<len;i++)
list.add(s1.charAt(i)+"");//!!!!!
System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2, ]
for(int j=0;j<list.size();j++){
if(list.get(j).equals("×")){
int ji=Integer.parseInt(list.get(j-1))*Integer.parseInt(list.get(j+1));
list.add(j-1,ji+"");//把ji插入到原来x的前一位，原来的后移。从8开始往后移
list.remove(j);//删除8；remove是删除当前位置后后面的前移；故x到了j这个下标位置。
list.remove(j);//删除x
list.remove(j);//删除9
System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2, ]
j--;//相当于这次循环木有跳动下一个下标，因为马上要对ji参与运算，而不是跳过
}
else if(list.get(j).equals("/")){
int shang=Integer.parseInt(list.get(j-1))/Integer.parseInt(list.get(j+1));
list.add(j-1,shang+"");
list.remove(j);
list.remove(j);
list.remove(j);
System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2, ]
j--;
}
}
for(int k=0;k<list.size();k++){//这个时候是新的size
if(list.get(k).equals("+")){
int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));
list.add(k-1,he+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list--+后->"+ list); //list--+后->[4, -, 2, ]
k--;
}
if(list.get(k).equals("-")){
int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));
list.add(k-1,cha+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list-- -后->"+ list); //list-- -后->[2, ]
k--;
}
}
int sum=Integer.parseInt(list.get(0));
return sum;
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.List;

/****
 *输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
 
    例如:  输入：3+8×2/9-2  
  			输出：2  
 
    函数原型  . public int getMyRet(String str)  
 * @author sheepmu
 *
 */
public class HWText {
	 public static void main(String[] args){
		 String s="3+8×2/9-2 ";
		 int result=getMyRet(s);
		 System.out.println("最后结果："+result);
	 }
	 public static int getMyRet(String s1 ){
		 int len=s1.length();
		  List<String> list=new ArrayList<String>();
		  for(int i=0;i<len;i++)
			  list.add(s1.charAt(i)+"");//!!!!!
		  System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,  ]
		  for(int j=0;j<list.size();j++){
			   
			  if(list.get(j).equals("×")){
				   
				  int ji=Integer.parseInt(list.get(j-1))*Integer.parseInt(list.get(j+1));
				  list.add(j-1,ji+"");//把ji插入到原来x的前一位，原来的后移。从8开始往后移
				  list.remove(j);//删除8；remove是删除当前位置后后面的前移；故x到了j这个下标位置。
				  list.remove(j);//删除x
				  list.remove(j);//删除9
				  System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2,  ]
				  j--;//相当于这次循环木有跳动下一个下标，因为马上要对ji参与运算，而不是跳过
			  }
			  else if(list.get(j).equals("/")){
				  
				  int shang=Integer.parseInt(list.get(j-1))/Integer.parseInt(list.get(j+1));
				  list.add(j-1,shang+""); 
				  list.remove(j); 
				  list.remove(j); 
				  list.remove(j); 
				  System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2,  ]
				  j--;
			  }
		  }
		  
		  for(int k=0;k<list.size();k++){//这个时候是新的size
			  if(list.get(k).equals("+")){
				  int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));
				  list.add(k-1,he+""); 
				  list.remove(k); 
				  list.remove(k); 
				  list.remove(k); 
				  System.out.println("list--+后->"+ list); //list--+后->[4, -, 2,  ]
				 k--; 
			  }
			  if(list.get(k).equals("-")){
				  int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));
				  list.add(k-1,cha+""); 
				  list.remove(k); 
				  list.remove(k); 
				  list.remove(k); 
				  System.out.println("list--  -后->"+ list); //list--  -后->[2,  ]
				 k--;
			  }
		  }
		  int sum=Integer.parseInt(list.get(0));
		 return sum;
	 }
}

第3题：找出字符串中出现次数最多的字母和出现的次数

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/****
* 找出字符串中出现次数最多的字母和出现的次数
* @author SheepMu
*/
public class HWText {
public static void main(String[] args){
String s1="sheepmusheepmummmm";
List<String> list=new ArrayList<String>();
for(int i=0;i<s1.length();i++)
list.add(s1.charAt(i)+"");
System.out.println("排序前的list--->"+list);// 排序前的list--->[s, h, e, e, p, m, u, s, h, e, e, p, m, u, m, m, m, m]
Collections.sort(list);
System.out.println("排序后的list--->"+list);// 排序后的list--->[e, e, e, e, h, h, m, m, m, m, m, m, p, p, s, s, u, u]
int[] count=new int[list.size()];
for(int i=0;i<count.length;i++)
count[i]=1;
System.out.println("初始定义每个字母出现的次数count--->"+Arrays.toString(count)); //list可以直接打印出来；但数组不行！打印数组的方法！！不然会[I@4a9a1ac
for(int j=0;j<list.size();j++)
for(int k=j+1;k<list.size();k++)
if(list.get(j).equals(list.get(k))){
count[j]++;
list.remove(k);
k--;
}
System.out.println("循环后的list--->"+list); //循环后的list--->[e, h, m, p, s, u]
System.out.println("list变化后每个字母出现的次数count--->"+Arrays.toString(count)); //因为数组长度这儿没有变化，所以后面还是保留了原本为每个字母定义的数量1
int maxTimes=count[0];//比较数组里面的最大值!
String maxStr=list.get(0);
for(int i=0;i<list.size();i++){
if(maxTimes<count[i]){
maxTimes=count[i];
maxStr=list.get(i);
}
}
System.out.println("出现次数最多的字母："+maxStr+"出现次数："+maxTimes);
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**** 
 * 找出字符串中出现次数最多的字母和出现的次数 
 * @author SheepMu
 */  
public class HWText {
	 public static void main(String[] args){
	 String s1="sheepmusheepmummmm";
	 List<String> list=new ArrayList<String>();
	 for(int i=0;i<s1.length();i++)
		 list.add(s1.charAt(i)+"");
	 System.out.println("排序前的list--->"+list);// 排序前的list--->[s, h, e, e, p, m, u, s, h, e, e, p, m, u, m, m, m, m]
	 Collections.sort(list);
	 System.out.println("排序后的list--->"+list);// 排序后的list--->[e, e, e, e, h, h, m, m, m, m, m, m, p, p, s, s, u, u]
	 int[] count=new int[list.size()];
	 for(int i=0;i<count.length;i++)
		 count[i]=1;
	 
	 System.out.println("初始定义每个字母出现的次数count--->"+Arrays.toString(count)); //list可以直接打印出来；但数组不行！打印数组的方法！！不然会[I@4a9a1ac
	 for(int j=0;j<list.size();j++)
		 for(int k=j+1;k<list.size();k++)
			 if(list.get(j).equals(list.get(k))){
				  count[j]++;
				 list.remove(k);	 
				 k--;
			 }
	 System.out.println("循环后的list--->"+list);	 //循环后的list--->[e, h, m, p, s, u]
	 System.out.println("list变化后每个字母出现的次数count--->"+Arrays.toString(count));  //因为数组长度这儿没有变化，所以后面还是保留了原本为每个字母定义的数量1
	
	 int maxTimes=count[0];//比较数组里面的最大值!
	 String maxStr=list.get(0);
	 for(int i=0;i<list.size();i++){
		 if(maxTimes<count[i]){
			 maxTimes=count[i];
			 maxStr=list.get(i);
		 }

	 }
	 
	 System.out.println("出现次数最多的字母："+maxStr+"出现次数："+maxTimes);
	 }
	 
}

方法二：

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.List;
  /*     
  * @author sheepmu
  */ 
public class HWCompetition {
	public static void main(String[] args) {        
       String s1="sheepmusheepmummmm";   
       getStr(s1 ) ;
    }    
    public  static void getStr(String s1 ){ 
    	char[] cs=s1.toCharArray();  	 
    	List<Character> list=new ArrayList<Character>( );
    	for(int i=0;i<cs.length;i++){
    		list.add(cs[i]);
    	}
    	int maxcount=1;
    	char maxc=cs[0]; 
    	for(int i=0;i<list.size()-1;i++){
    		int count=1;
    		for(int j=i+1;j<list.size();j++){
    			if(list.get(i)==list.get(j)){
    				list.remove(j);
    				j--;
    				count++;
    			}
    			if(count>maxcount){
    				maxc=list.get(i);
    				maxcount=count;
    			}			
    		}
    	}
    	System.out.println(maxc+" "+maxcount);
    	 
     
    }
     
}

第4题：拆分字符串，字符串中含有逗号和数字，对数字排序并输出

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/****
* 拆分字符串，字符串中含有逗号和数字，对数字排序并输出
* @author SheepMu
*/
public class HWText {
public static void main(String[] args){
String s0="123,45,25,85";
String[] s1=s0.split(",");
// for(int i=0;i<s1.length;i++)
// System.out.print(s1[i]+" ");//123 45 25 85 !!!!!!!!!!!!
System.out.println(Arrays.toString(s1));//[123, 45, 25, 85] !!!!数组本身就会有,分隔的
int[] a=new int[s1.length];
for(int i=0;i<a.length;i++)
a[i]=Integer.parseInt(s1[i]);
Arrays.sort(a);
System.out.println(Arrays.toString(a));
for(int number:a)
System.out.print(number+" ");//25 45 85 123
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**** 
 * 拆分字符串，字符串中含有逗号和数字，对数字排序并输出
 * @author SheepMu
 */  
public class HWText {
	 public static void main(String[] args){
		 	String s0="123,45,25,85";
			String[] s1=s0.split(",");
//			 for(int i=0;i<s1.length;i++)
//			System.out.print(s1[i]+" ");//123 45 25 85       !!!!!!!!!!!!
			System.out.println(Arrays.toString(s1));//[123, 45, 25, 85]  !!!!数组本身就会有,分隔的
			int[] a=new int[s1.length];
 
			for(int i=0;i<a.length;i++)
			a[i]=Integer.parseInt(s1[i]);
			Arrays.sort(a);
			System.out.println(Arrays.toString(a));
			for(int number:a)
 		  System.out.print(number+" ");//25 45 85 123 	 
	 }	 
}

第5题：选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家
评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分 *
0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则总分 = 专家评委平均分，总分取整。函数最终返回选手得分。函数接口 int cal_score(int score[], int judge_type[], int n)

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/****
* 选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家
评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分 *
0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则总分 = 专家评委平均分，总分取整。函数最终返回选手得分
函数接口 int cal_score(int score[], int judge_type[], int n)
* @author SheepMu
*/
public class HWText {
public static void main(String[] args){
int[] score={60,70,80,70,90,60,80};
int[] judge_type={1,2,1,2,2,1,2};
int n=7;
int result_core=cal_score(score,judge_type,n);
System.out.println("最后结果："+ result_core);
}
public static int cal_score(int score[],int judge_type[],int n){
double sum_all=0;
double sum_specilist=0;
double sum_common=0;
int average_specialist=0;
int average_common=0;
int result=0;
List<Integer> specilist_index=new ArrayList<Integer>();
for(int i=0;i<judge_type.length;i++)
if(judge_type[i]==1)
specilist_index.add(i);
System.out.println("专家的下标："+ specilist_index);//专家的下标：[0, 2, 5]
for(int i=0;i< specilist_index.size();i++)//!!!!!!!!!!
for(int j=0;j< score.length;j++)//!!!!!!!!!!
if(specilist_index.get(i)==j)
sum_specilist+=score[j];
System.out.println("专家的总分："+ sum_specilist);//专家的总分：200.0
for(int k=0;k< score.length;k++)
sum_all+=score[k];
System.out.println("全部总分："+ sum_all);//全部总分：510.0
sum_common= sum_all-sum_specilist;
System.out.println("大众点评总分："+ sum_common);//大众点评总分：310.0
average_specialist=(int)(sum_specilist/specilist_index.size());
System.out.println("专家平均分："+ average_specialist);//专家平均分：66
average_common=(int)(sum_common/(n-specilist_index.size()));
System.out.println("大众平均分："+ average_common);//大众平均分：77
result=(int)(average_specialist*0.6+average_common*0.4);
return result;
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**** 
 * 选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家
 评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分  * 
 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分
  函数接口   int cal_score(int score[], int judge_type[], int n) 
 * @author SheepMu
 */  
public class HWText {
	 public static void main(String[] args){
		 	 int[] score={60,70,80,70,90,60,80};
		 	 int[] judge_type={1,2,1,2,2,1,2};
		 	 int n=7;
		 	int result_core=cal_score(score,judge_type,n);
		 	 System.out.println("最后结果："+ result_core);
	 }	 
	 public static int cal_score(int score[],int judge_type[],int n){
		 double sum_all=0;
		 double sum_specilist=0;
		 double sum_common=0;
		 int average_specialist=0;
		 int average_common=0;
		 int result=0;
		  List<Integer> specilist_index=new ArrayList<Integer>();
		 for(int i=0;i<judge_type.length;i++)
			 if(judge_type[i]==1)
				 specilist_index.add(i);
		 System.out.println("专家的下标："+ specilist_index);//专家的下标：[0, 2, 5]
		
		 for(int i=0;i< specilist_index.size();i++)//!!!!!!!!!!
			 for(int j=0;j< score.length;j++)//!!!!!!!!!!
				 if(specilist_index.get(i)==j)
					 sum_specilist+=score[j];		 
		 System.out.println("专家的总分："+ sum_specilist);//专家的总分：200.0
		 
		 for(int k=0;k< score.length;k++)
			 sum_all+=score[k];
		 System.out.println("全部总分："+ sum_all);//全部总分：510.0
		 sum_common= sum_all-sum_specilist;
		 System.out.println("大众点评总分："+  sum_common);//大众点评总分：310.0
		 average_specialist=(int)(sum_specilist/specilist_index.size());
		 System.out.println("专家平均分："+ average_specialist);//专家平均分：66
		 average_common=(int)(sum_common/(n-specilist_index.size()));
		 System.out.println("大众平均分："+ average_common);//大众平均分：77
		 result=(int)(average_specialist*0.6+average_common*0.4);
		 return result;
	 }
}

[java] view plain copy print ?

public class HWText {
public static void main(String[] args){
int[] score={60,70,80,70,90,60,80};
int[] judge_type={1,2,1,2,2,1,2};
int n=7;
int result_core=cal_score(score,judge_type,n);
System.out.println("最后结果："+ result_core);
}
public static int cal_score(int score[],int judge_type[],int n){
double sum_all=0;
double sum_specilist=0;
double sum_common=0;
int specialist_size=0;
int average_specialist=0;
int average_common=0;
int result=0;
for(int i=0;i<judge_type.length;i++){
if(judge_type[i]==1){
specialist_size++;
sum_specilist+=score[i];
}
}
System.out.println("专家总分"+sum_specilist+"专家人数"+specialist_size);
//....省略
return result;
}
}

public class HWText {
	 public static void main(String[] args){
		 	 int[] score={60,70,80,70,90,60,80};
		 	 int[] judge_type={1,2,1,2,2,1,2};
		 	 int n=7;
		 	int result_core=cal_score(score,judge_type,n);
		 	 System.out.println("最后结果："+ result_core);
	 }	 
	 public static int cal_score(int score[],int judge_type[],int n){
		 double sum_all=0;
		 double sum_specilist=0;
		 double sum_common=0;
		 int specialist_size=0;
		 int average_specialist=0;
		 int average_common=0;
		 int result=0;
		 for(int i=0;i<judge_type.length;i++){
			 if(judge_type[i]==1){
				 specialist_size++;
				 sum_specilist+=score[i]; 
			 }
		 }
		 System.out.println("专家总分"+sum_specilist+"专家人数"+specialist_size);
		 //....省略
		 return result;
	 }
}

第6题：将大写字母转换成其对应小写字母后的第五个字母，大于z的从头开始数;如果是小写则不变。

[java] view plain copy print ?

package SheepMu;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 将大写字母转换成其对应小写字母后的第五个字母，大于z的从头开始数;如果是小写则不变。
* author SheepMu
*/
public class HWText {
public static void main(String[] args){
String str0="ABcYZ";
char[] c0=str0.toCharArray();
for(int i=0;i<c0.length;i++){
if(c0[i]>='A'&&c0[i]<='Z'){
c0[i]= (char) (c0[i]+32+5);
if(c0[i]>'z')
c0[i]-=26;
}
}
System.out.println(Arrays.toString(c0));//[f, g, c, d, e]
}
}

package SheepMu;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
	/**
	 * 将大写字母转换成其对应小写字母后的第五个字母，大于z的从头开始数;如果是小写则不变。
	 * author SheepMu
	 */
public class HWText {
 	public static void main(String[] args){
 		 String  str0="ABcYZ";
 		 char[] c0=str0.toCharArray();
 		 for(int i=0;i<c0.length;i++){
 			 if(c0[i]>='A'&&c0[i]<='Z'){
 				 c0[i]= (char) (c0[i]+32+5);
 				 if(c0[i]>'z')
 					 c0[i]-=26;
 			 }
 		 }
  System.out.println(Arrays.toString(c0));//[f, g, c, d, e]
 	}
 	
}

第7题: 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
比如字符串“abacacde”过滤结果为“abcde”。
要求实现函数：
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr：输入字符串
         lInputLen：输入字符串长度
【输出】 pOutputStr：输出字符串，空间已经开辟好，与输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入：“deefd”        输出：“def”
输入：“afafafaf”     输出：“af”
输入：“pppppppp”     输出：“p”

[java] view plain copy print ?

package SheepMu;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
/**
* 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
比如字符串“abacacde”过滤结果为“abcde”。
要求实现函数：
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
【输入】 pInputStr：输入字符串
lInputLen：输入字符串长度
【输出】 pOutputStr：输出字符串，空间已经开辟好，与输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入：“deefd” 输出：“def”
输入：“afafafaf” 输出：“af”
输入：“pppppppp” 输出：“p”
* author SheepMu
*/
public class HWText {
public static void main(String[] args){
Scanner input0=new Scanner(System.in);
Scanner input1=new Scanner(System.in);
String str0=input0.nextLine();
long len=input1.nextLong();
String output="";
HWText text=new HWText();
text.stringFilter(str0,len,output);
}
public void stringFilter(String pInputStr,long len,String pOutputStr){
List<String> list=new ArrayList<String>();
for(int i=0;i<len;i++)
list.add(pInputStr.charAt(i)+"");//！！！！双引号不要空开，不然就是一个空格了。
for(int i=0;i<list.size();i++)
for(int j=i+1;j<list.size();j++){
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
StringBuffer sb=new StringBuffer();
for(String s:list)
sb.append(s);
System.out.println(sb.toString());
}
}

package SheepMu;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
	/**
	 * 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
比如字符串“abacacde”过滤结果为“abcde”。
要求实现函数： 
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr：  输入字符串
         lInputLen：  输入字符串长度         
【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例 
输入：“deefd”        输出：“def”
输入：“afafafaf”     输出：“af”
输入：“pppppppp”     输出：“p”
	 * author SheepMu
	 */
public class HWText {
 	public static void main(String[] args){
 		 Scanner input0=new Scanner(System.in);
 		 Scanner input1=new Scanner(System.in);
 		 String str0=input0.nextLine();
 		 long len=input1.nextLong();
 		 String output="";
 		 HWText text=new HWText();
 		text.stringFilter(str0,len,output);
 	 
 	}
 	public void stringFilter(String pInputStr,long len,String pOutputStr){
 		List<String> list=new ArrayList<String>();
 		for(int i=0;i<len;i++) 
 			list.add(pInputStr.charAt(i)+"");//！！！！双引号不要空开，不然就是一个空格了。
 		 
 		for(int i=0;i<list.size();i++) 
 			 for(int j=i+1;j<list.size();j++){
 				 if(list.get(i).equals(list.get(j))){
 					 list.remove(j);
 					 j--;
 				 }
 			 }
 		
 		 StringBuffer sb=new  StringBuffer();
 		 for(String s:list)
 			 sb.append(s);
 		 System.out.println(sb.toString());
 	}
}

第8题：通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。（和第3题类似）
压缩规则：

    1、仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。
    2、压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"。
要求实现函数：
     void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);
    输入pInputStr：输入字符串lInputLen：输入字符串长度
    输出 pOutputStr：输出字符串，空间已经开辟好，与输入字符串等长；
注意：只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
    输入：“cccddecc”   输出：“3c2de2c”
    输入：“adef”     输出：“adef”
    输入：“pppppppp” 输出：“8p”

[java] view plain copy print ?

package SheepMu;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
/**
* 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。
压缩规则：
1、仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。
2、压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"。
要求实现函数：
void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);
输入pInputStr：输入字符串lInputLen：输入字符串长度
输出 pOutputStr：输出字符串，空间已经开辟好，与输入字符串等长；
注意：只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入：“cccddecc” 输出：“3c2de2c”
输入：“adef” 输出：“adef”
输入：“pppppppp” 输出：“8p”
* author SheepMu
*/
public class HWText {
public static void main(String[] args){
Scanner input0=new Scanner(System.in);
Scanner input1=new Scanner(System.in);
String str0=input0.nextLine();
long len=input1.nextLong();
String output="";
HWText text=new HWText();
text.stringZip(str0,len,output);
}
public void stringZip(String pInputStr,long len,String pOutputStr){
List<String> list=new ArrayList<String>();
for(int i=0;i<len;i++)
list.add(pInputStr.charAt(i)+"");//！！！！双引号不要空开，不然就是一个空格了。
int[] count=new int[(int)len];//定义一个数组，装每个字母出现的次数，然后初始定义没个出现的次数为1；
for(int i=0;i<len;i++)
count[i]=1;
StringBuffer sb=new StringBuffer();//来装新的string
for(int i=0;i<list.size();i++){ //!!!!
for(int j=i+1;j<list.size();j++){//!!!
if(list.get(i).equals(list.get(j))){
count[i]++;
list.remove(j);
j--;
}
else{break;}//!!!!一旦list.get(i).equals(list.get(j))为false，即某个j时为false,即一旦出现不等的字母，就跳出里面这个循环！！！
}
if(count[i]!=1) //内循环结束后把数目和该字母append进sb,如果数量只是1，不加“1”
sb.append(count[i]);
sb.append(list.get(i));
System.out.println("count["+i+ "]" +count[i]);
}
System.out.println("最后结果---->"+sb.toString());
}
}

package SheepMu;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
	/**
	 * 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。
压缩规则：
    1、仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。
    2、压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"。
要求实现函数： 
     void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);
    输入pInputStr：  输入字符串lInputLen：  输入字符串长度
    输出 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
注意：只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例 
    输入：“cccddecc”   输出：“3c2de2c”
    输入：“adef”     输出：“adef”
    输入：“pppppppp” 输出：“8p”
	 * author SheepMu
	 */
public class HWText {
 	public static void main(String[] args){
 		 Scanner input0=new Scanner(System.in);
 		 Scanner input1=new Scanner(System.in);
 		 String str0=input0.nextLine();
 		 long len=input1.nextLong();
 		 String output="";
 		 HWText text=new HWText();
 		text.stringZip(str0,len,output);
 	 
 	}
 	public void stringZip(String pInputStr,long len,String pOutputStr){
 		List<String> list=new ArrayList<String>();
 		for(int i=0;i<len;i++) 
 			list.add(pInputStr.charAt(i)+"");//！！！！双引号不要空开，不然就是一个空格了。
 		
 		 int[] count=new int[(int)len];//定义一个数组，装每个字母出现的次数，然后初始定义没个出现的次数为1；
  		for(int i=0;i<len;i++) 
  			count[i]=1;
  		StringBuffer sb=new  StringBuffer();//来装新的string
 		for(int i=0;i<list.size();i++){ //!!!!
 			 for(int j=i+1;j<list.size();j++){//!!!
 				 if(list.get(i).equals(list.get(j))){
 					 count[i]++;
 					 list.remove(j);
 					 j--;
 				 }
 				 else{break;}//!!!!一旦list.get(i).equals(list.get(j))为false，即某个j时为false,即一旦出现不等的字母，就跳出里面这个循环！！！			
 			 }
 			 if(count[i]!=1) //内循环结束后把数目和该字母append进sb,如果数量只是1，不加“1”
					 sb.append(count[i]);
				 sb.append(list.get(i));
 			 System.out.println("count["+i+ "]" +count[i]);	 
 			 }
  
 		 System.out.println("最后结果---->"+sb.toString());
 	}
}

第9题：将一个十进制（byte型）转换为二进制，讲二进制数前后颠倒，再算出颠倒后对于的十进制数。

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
text.change((char)10);
}
public void change(char c){
int ic=c;
String sc=Integer.toBinaryString(ic);//十进制---->二进制 !!!!!!!!!!!!!!!!!!
System.out.println("二进制为--->"+sc);//二进制为--->1010
char[] scc=sc.toCharArray();
StringBuffer sb=new StringBuffer();
for(int i=scc.length-1;i>=0;i--){
sb.append(scc[i]);
}
System.out.println("二进制前后颠倒后--->"+sb.toString());//二进制前后颠倒后--->0101
Integer it=Integer.valueOf(sb.toString(), 2);//二进制----->十进制 !!!!!!!!!!!!!!
System.out.println(" 颠倒后的二进制对应的十进制--->"+it );// 颠倒后的二进制对应的十进制--->5
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  text.change((char)10);	
	 }	 
	 public void change(char c){
			int ic=c;
			String sc=Integer.toBinaryString(ic);//十进制---->二进制  !!!!!!!!!!!!!!!!!!
			System.out.println("二进制为--->"+sc);//二进制为--->1010
			char[] scc=sc.toCharArray();
			StringBuffer sb=new StringBuffer();
			for(int i=scc.length-1;i>=0;i--){
				sb.append(scc[i]);
			}
			System.out.println("二进制前后颠倒后--->"+sb.toString());//二进制前后颠倒后--->0101
			Integer it=Integer.valueOf(sb.toString(), 2);//二进制----->十进制   !!!!!!!!!!!!!!
			System.out.println(" 颠倒后的二进制对应的十进制--->"+it );// 颠倒后的二进制对应的十进制--->5

		}
	 
	 }

第10题：输入一段字符串，字符串中只包含大小写字母。要求完成函数删除给定字符串中出现次数最少的字符。输出删除完的字符串。如果有多个出现次数一样的字符，都为最少时，一并删除。
例如：输入:abbccd，输出为bbcc。

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* 输入一段字符串，字符串中只包含大小写字母。要求完成函数删除给定字符串中出现次数最少的字符。输出删除完的字符串。如果有多个出现次数一样的字符，都为最少时，一并删除。
例如：输入:abbccd，输出为bbcc。
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
String result=text.getMinString("abbccd");
System.out.println(result);
}
public String getMinString(String input){
System.out.println("原字符串--->"+input);
char[] c=input.toCharArray();
List<String> list=new ArrayList<String>();
for(int i=0;i<c.length;i++)
list.add(c[i]+"");
//求出字母出现的最小次数（不能对list排序，会影响最后输出结果）
int minTime=0;
int[] count=new int[list.size()];
for(int i=0;i<count.length;i++)
count[i]=0;
for(int i=0;i<list.size();i++){
for(int j=0;j<list.size();j++){
if(list.get(i).equals(list.get(j)))
count[i]++;
}
minTime=count[1];//把第一个字母出现的次数初始为最小次数。!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!此题关键！！！
if(minTime>=count[i])
minTime=count[i];
}
System.out.println("每个下标的字母对应的出现次数---->"+Arrays.toString(count));
System.out.println("字母出现的最小次数---->"+minTime);
StringBuffer sb=new StringBuffer();
for(int i=0;i<count.length;i++){
if(count[i]>minTime)
sb.append(list.get(i));
}
return sb.toString();
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * 输入一段字符串，字符串中只包含大小写字母。要求完成函数删除给定字符串中出现次数最少的字符。输出删除完的字符串。如果有多个出现次数一样的字符，都为最少时，一并删除。
例如：输入:abbccd，输出为bbcc。
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  String result=text.getMinString("abbccd");
		  System.out.println(result);
	 }	 
	 public String getMinString(String input){  
		 System.out.println("原字符串--->"+input);
		 char[] c=input.toCharArray();
		 List<String> list=new ArrayList<String>();
		 for(int i=0;i<c.length;i++)
			 list.add(c[i]+"");
		 //求出字母出现的最小次数（不能对list排序，会影响最后输出结果）
		 int minTime=0; 
		 int[] count=new int[list.size()];
		 for(int i=0;i<count.length;i++)
			 count[i]=0;
		 
		 for(int i=0;i<list.size();i++){
			 for(int j=0;j<list.size();j++){
				 if(list.get(i).equals(list.get(j)))
					  count[i]++;  
			 }
			 minTime=count[1];//把第一个字母出现的次数初始为最小次数。!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!此题关键！！！
			 if(minTime>=count[i])
				 minTime=count[i];
		 }
		 System.out.println("每个下标的字母对应的出现次数---->"+Arrays.toString(count));
		System.out.println("字母出现的最小次数---->"+minTime);
		
		 StringBuffer sb=new StringBuffer();
		 for(int i=0;i<count.length;i++){
			 if(count[i]>minTime)
				 sb.append(list.get(i));
		 }
		 return  sb.toString();  
 
	 }
	 
	 }

第11题：StringReverse（char *strIn，char *output）找出 strIn 里面所有大写字母，将其逆序输出
如输入：strIn："abcHDLmnkKl"，输出：output:"KLDH"

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* StringReverse（char *strIn，char *output）找出 strIn 里面所有大写字母，将其逆序输出
如输入：strIn："abcHDLmnkKl"，输出：output:"KLDH"，
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
Scanner input=new Scanner(System.in);
String str0=input.next();
String result=text.StringReverse( str0);
System.out.println(result);
}
public String StringReverse(String input){
System.out.println("原字符串--->"+input);
char[] c=input.toCharArray();
StringBuffer sb=new StringBuffer();
for(int i=0;i<c.length;i++){
if(c[i]>='A'&&c[i]<='Z')//细心，是&&
sb.append(c[i]);
else{}
}
System.out.println("大写字母--->"+sb.toString());
// StringBuffer sb1=new StringBuffer();//这三行就可直接用StringBuffer里面的sb.reverse()!!熟悉源码会省很多事呀~，String木有次方法
// for(int i=sb.length()-1;i>=0;i--)
// sb1.append(sb.charAt(i));
return sb.reverse() .toString();
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * StringReverse（char *strIn，char *output）找出 strIn 里面所有大写字母，将其逆序输出
 如输入：strIn："abcHDLmnkKl"，输出：output:"KLDH"，
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  Scanner input=new Scanner(System.in);
		  String str0=input.next();
		  String result=text.StringReverse( str0);
		  System.out.println(result);
	 }	 
	 public String StringReverse(String input){  
		 System.out.println("原字符串--->"+input);
		 char[] c=input.toCharArray();
		 StringBuffer sb=new StringBuffer();
		 for(int i=0;i<c.length;i++){
			 if(c[i]>='A'&&c[i]<='Z')//细心，是&&
				 sb.append(c[i]);
			 else{}
		 }
		 System.out.println("大写字母--->"+sb.toString());
//		 StringBuffer sb1=new StringBuffer();//这三行就可直接用StringBuffer里面的sb.reverse()!!熟悉源码会省很多事呀~，String木有次方法
//		 for(int i=sb.length()-1;i>=0;i--)
//			 sb1.append(sb.charAt(i));
		return  sb.reverse() .toString();	 
	 }	 
	 }

第12题：通过键盘输入任意一个字符串序列，字符串可能包含多个子串，子串以空格分割。请编写一个程序，自动分离出各个子串，并使用','将其分离，并且在最后也补充一个','，并将子串存储。
要求实现函数：
void DivideString (const char *pInputStr, long IInputLen, char
*pOutputStr );
【输入】 pInputStr：输入字符串
IInputLen：输入字符串长度
【输出】 pOutputStr：输出字符串，空间已经开劈好，与输入输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例：
输入："abc def ghi d"
输出："abc,def,ghi,d"

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* 通过键盘输入任意一个字符串序列，字符串可能包含多个子串，子串以空
格分割。请编写一个程序，自动分离出各个子串，并使用','将其分离，并
且在最后也补充一个','，并将子串存储。
要求实现函数：
void DivideString (const char *pInputStr, long IInputLen, char
*pOutputStr );
【输入】 pInputStr：输入字符串
IInputLen：输入字符串长度
【输出】 pOutputStr：输出字符串，空间已经开劈好，与输入输
入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例：
输入："abc def ghi d"
输出："abc,def,ghi,d"
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
Scanner input=new Scanner(System.in);
String str0=input.nextLine();
long len=str0.length();
String newStr=new String();
String result=text.DivideString( str0,len,newStr);
System.out.println(result);
}
public String DivideString(String input,long len,String newStr){
input.trim();//!!!!!去掉首尾空格，免得匹配出来首尾都有个逗号;尾巴需要的时候在代码添一个
System.out.println("原字符串--->"+input);
newStr= input.replaceAll("\\s+", ",");// \s匹配任意空格，+表示一个或多于一个。这种情况都要多添一个 \ ;比如匹配.号时就要\\.
System.out.println("原来的---->"+input);//!!!!!!在原来的replace后原来的并没有变，而是生成了一个新的以input.replaceAll（）为结果的字符串，注意与arraylist的remove这些相区分！
System.out.println("原来的replace后的，即新的---->"+newStr);
if( newStr.charAt(newStr.length()-1)!=',')//单个字符的比较就用==or!=，不是用equals()
newStr+=',';//!!!!
return newStr;
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * 通过键盘输入任意一个字符串序列，字符串可能包含多个子串，子串以空
格分割。请编写一个程序，自动分离出各个子串，并使用','将其分离，并
且在最后也补充一个','，并将子串存储。
要求实现函数：
void DivideString (const char *pInputStr, long IInputLen, char
*pOutputStr );
【输入】   pInputStr：       输入字符串
                   IInputLen：       输入字符串长度
【输出】   pOutputStr：     输出字符串，空间已经开劈好，与输入输
入字符串等长；
【注意】   只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例：
输入："abc def ghi       d"
输出："abc,def,ghi,d"
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  Scanner input=new Scanner(System.in);
		  String str0=input.nextLine();
		  long len=str0.length();
		  String newStr=new String();
		  String result=text.DivideString( str0,len,newStr);
		  System.out.println(result);
	 }	 
	 public String DivideString(String input,long len,String newStr){  
 		 input.trim();//!!!!!去掉首尾空格，免得匹配出来首尾都有个逗号;尾巴需要的时候在代码添一个
		 System.out.println("原字符串--->"+input);
		newStr= input.replaceAll("\\s+", ",");//    \s匹配任意空格，+表示一个或多于一个。这种情况都要多添一个  \     ;比如匹配.号时就要\\.
		System.out.println("原来的---->"+input);//!!!!!!在原来的replace后原来的并没有变，而是生成了一个新的以input.replaceAll（）为结果的字符串，注意与arraylist的remove这些相区分！
		System.out.println("原来的replace后的，即新的---->"+newStr);
		if( newStr.charAt(newStr.length()-1)!=',')//单个字符的比较就用==or!=，不是用equals()
			newStr+=',';//!!!!
		return  newStr;
		 
	 }
	 
	 }

第13题：输入一个字符串，删除重复前面的字符，其余字符按原样顺序输出.
* 例如：
* 输入：input: "acbdfdffZZet";
* 输出：output:"acbdfZet";
* 实现函数：String(String input)

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* 输入一个字符串，删除重复前面的字符，其余字符按原样顺序输出.
* 例如：
* 输入：input: "acbdfdffZZet";
* 输出：output:"acbdfZet";
* 实现函数：String(String input)
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
Scanner input=new Scanner(System.in);
String str0=input.nextLine();
String result=text.delString( str0 );
System.out.println(result);
}
public String delString(String input ){
char[] sc=input.toCharArray();
List<String> list=new ArrayList<String>();
for(int i=0;i<sc.length;i++)
list.add(sc[i]+"");
System.out.println("list原来---->"+list);
for(int i=0;i<list.size();i++)
for(int j=i+1;j<list.size();j++)
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
System.out.println("list删除重复后----->"+list);
StringBuffer sb=new StringBuffer();//千万不能直接list.toString(),list.toString()的结果还是数组形式。
for(int i=0;i<list.size();i++)
sb.append(list.get(i));
return sb.toString();
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * 输入一个字符串，删除重复前面的字符，其余字符按原样顺序输出.
 * 例如：
 * 输入：input: "acbdfdffZZet";
 * 输出：output:"acbdfZet";
 * 实现函数：String(String input)
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  Scanner input=new Scanner(System.in);
		  String str0=input.nextLine();  
		  String result=text.delString( str0 );
		  System.out.println(result);
	 }	 
	 public String delString(String input ){  
 		 char[] sc=input.toCharArray();
 		 List<String> list=new ArrayList<String>();
 		 for(int i=0;i<sc.length;i++)
 			 list.add(sc[i]+"");
 		 System.out.println("list原来---->"+list);
 		 for(int i=0;i<list.size();i++) 
 			 for(int j=i+1;j<list.size();j++) 
 				 if(list.get(i).equals(list.get(j))){
 					 list.remove(j);
 					 j--;		 
 				 }	 
 		 System.out.println("list删除重复后----->"+list);
 		 StringBuffer sb=new StringBuffer();//千万不能直接list.toString(),list.toString()的结果还是数组形式。
 		 for(int i=0;i<list.size();i++)
 			 sb.append(list.get(i));
		return  sb.toString();		 
	 }
	 
	 }

第14题：尾号限行：输入一串车牌号码，以逗号分割开，车牌号码有以下要求，只要取后五位,如：AD123，12101，中国的车牌号不可能全是字母。
* 现在对尾号进行限制：尾号为1,6则周一限行，尾号为2,7则周二限行，尾号为3,8则周三限行尾号为4,9则周四限行,尾号为5,0的周五限行.
* 周六周日不限行。尾号不为数字，则看第4位是否是数字，如果第4位还不是数字，继续看第3位，以此下去，直到找到有数字的时候止.
* 由于用户不熟悉系统，有可能输入错误车牌，如车牌不满5位或大于5位、车牌全是字母、没用逗号分割等，如有输入错误情况一律返回error
* 如输入没有问题则返回限行的车牌号,如没有，刚返回空.
* 例如：输入：String theCarCard = "A1023,NB123,D12ZG",int limitDate = 3;
* 输出：A1023,NB123
* String limitedCarCard(String input)

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* 尾号限行：输入一串车牌号码，以逗号分割开，车牌号码有以下要求，只要取后五位,如：AD123，12101，中国的车牌号不可能全是字母。
* 现在对尾号进行限制：尾号为1,6则周一限行，尾号为2,7则周二限行，尾号为3,8则周三限行尾号为4,9则周四限行,尾号为5,0的周五限行.
* 周六周日不限行。尾号不为数字，则看第4位是否是数字，如果第4位还不是数字，继续看第3位，以此下去，直到找到有数字的时候止.
* 由于用户不熟悉系统，有可能输入错误车牌，如车牌不满5位或大于5位、车牌全是字母、没用逗号分割等，如有输入错误情况一律返回error
* 如输入没有问题则返回限行的车牌号,如没有，刚返回空.
* 例如：输入：String theCarCard = "A1023,NB123,D12ZG",int limitDate = 3;
* 输出：A1023,NB123
* String limitedCarCard(String input)
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
Scanner input=new Scanner(System.in);
String str0=input.nextLine(); //输入两个！！！时怎么办！！！！！！难道这种题只需要外面写实现函数？？？？
int limitDay=input.nextInt();//limitDay表示周几的意思。1-7
System.out.println("原字符串"+str0);
System.out.println("限行日周 "+limitDay);
String result=text. limitedCarCard( str0,limitDay );
System.out.println(result);
}
public String limitedCarCard(String input,int limitDay ){
String result="";
int[] limitNum=new int[2];//除了周末每天有2种尾号的车被限行。
switch( limitDay ){
case 1:
limitNum[0]=1;
limitNum[1]=6;
break;
case 2:
limitNum[0]=2;
limitNum[1]=7;
break;
case 3:
limitNum[0]=3;
limitNum[1]=8;
break;
case 4:
limitNum[0]=4;
limitNum[1]=9;
break;
case 5:
limitNum[0]=5;
limitNum[1]=0;
break;
case 6:
case 7:
limitNum[0]=10;//周六周天没有限行的，所以设成不可能车牌数字等到的数字；
limitNum[1]=10;
break;
default:
break;
}
String[] strs=input.split(",");
if(strs.length==1){//API：如果表达式不匹配输入的任何部分，则结果数组只具有一个元素，即此字符串。 input 里面没有逗号
System.out.println("input 里面没有逗号");
result="error";
}
for( int i=0;i<strs.length;i++){
if(strs[i].length()>5||strs[i].length()<5){//长度错误
System.out.println("input 长度错误");
result="error";}
else if (strs[i].matches("[A-Z]{5}")){//全是字母
System.out.println("input 全是字母");
result="error";}
else if(!strs[i].matches("[A-Z0-9]+")){//出现了一个或一个以上非大写字母和数字的情况 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
System.out.println("input 出现了一个或一个以上非大写字母和数字的情况");
result="error";}
else{
for(int j=4;j>=0;j--){//在输入没错的情况下处理限行情况：
if(!(strs[i].charAt(j)+"").matches("[A-Z]")){
String n=strs[i].charAt(j)+"";
for(int k=0;k<limitNum.length;k++){
if( limitNum[k]==Integer.parseInt(n))
result+=strs[i]+",";
}
break;//一旦找出最尾巴的数字，跳出循环。!!!!
}
}
}
}
return result;
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * 尾号限行：输入一串车牌号码，以逗号分割开，车牌号码有以下要求，只要取后五位,如：AD123，12101，中国 的车牌号不可能全是字母。
 * 现在对尾号进行限制：尾号为1,6则周一限行，尾号为2,7则周二限行，尾号为3,8则周三限行 尾号为4,9则周四限行,尾号为5,0的周五限行.
 * 周六周日不限行。尾号不为数字，则看第4位是否是数字，如果第4位还不是 数字，继续看第3位，以此下去，直到找到有数字的时候止.
 * 由于用户不熟悉系统，有可能输入错误车牌，如车牌不满5位或大于5位、车牌全是字母、没用逗号分割等，如有输入错误情况 一律返回error
 * 如输入没有问题则返回限行的车牌号,如没有，刚返回空.
 * 例如： 输入：String theCarCard = "A1023,NB123,D12ZG",int limitDate = 3;
 *       输出：A1023,NB123
 *       String limitedCarCard(String input)
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  Scanner input=new Scanner(System.in);
		  String str0=input.nextLine();  //输入两个！！！时怎么办！！！！！！难道这种题只需要外面写实现函数？？？？
		  
		  int limitDay=input.nextInt();//limitDay表示周几的意思。1-7
		  System.out.println("原字符串"+str0);
		  System.out.println("限行日周 "+limitDay);
		  String result=text. limitedCarCard( str0,limitDay );
		  System.out.println(result);
	 }	 
	 public String  limitedCarCard(String input,int limitDay ){  
		 String result="";
		 int[] limitNum=new int[2];//除了周末每天有2种尾号的车被限行。
		 switch( limitDay ){	 
		 case 1:
			 limitNum[0]=1;
			 limitNum[1]=6;
			 break;
		 case 2:
			 limitNum[0]=2;
			 limitNum[1]=7;
			 break;
		 case 3:
			 limitNum[0]=3;
			 limitNum[1]=8;
			 break;
		 case 4:
			 limitNum[0]=4;
			 limitNum[1]=9;
			 break;
		 case 5:
			 limitNum[0]=5;
			 limitNum[1]=0;
			 break;
		 case 6:
		 case 7:
			 limitNum[0]=10;//周六周天没有限行的，所以设成不可能车牌数字等到的数字；
			 limitNum[1]=10;
			 break;
		 default:
			 break;	 
		 }
		 
 		 String[] strs=input.split(","); 
 		 if(strs.length==1){//API：如果表达式不匹配输入的任何部分，则结果数组只具有一个元素，即此字符串。  input 里面没有逗号
 			 System.out.println("input 里面没有逗号");
 			   result="error";
 			   }
 		 
 		 for( int i=0;i<strs.length;i++){
 			 if(strs[i].length()>5||strs[i].length()<5){//长度错误
 				 System.out.println("input 长度错误");
 				result="error";}
 			 else if (strs[i].matches("[A-Z]{5}")){//全是字母
 				System.out.println("input 全是字母");
 				result="error";}
 			 else if(!strs[i].matches("[A-Z0-9]+")){//出现了一个或一个以上非大写字母和数字的情况    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 				System.out.println("input 出现了一个或一个以上非大写字母和数字的情况");
 				result="error";}
 			 
 			 else{
 				 for(int j=4;j>=0;j--){//在输入没错的情况下处理限行情况：
 					 if(!(strs[i].charAt(j)+"").matches("[A-Z]")){
 						 String n=strs[i].charAt(j)+"";
 						 for(int k=0;k<limitNum.length;k++){
 							if( limitNum[k]==Integer.parseInt(n))
 	 							 result+=strs[i]+",";
 						 }
 						 
 						 break;//一旦找出最尾巴的数字，跳出循环。!!!!
 					 }
 						 
 				 }
 			 }
 		 }
 		 
		return  result;		 
	 }
	 
	 }

第15题：输入一段字符串，字符串中包含空格、数字、符号和字母（包含大小写），要求完成函数使得输出给定字符串中最长字符串，输出的字符串可以包含数字和字符，不可以有空格和符号。若有相同长度的字符串，则输出第一个。
例如：输入:hello huawei!，输出为:huawei

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
* .输入一段字符串，字符串中包含空格、数字、符号和字母（包含大小写），要求完成函数使得输出给定字符串中最长字符串，输出的字符串可以包含数字和字符，不可以有空格和符号。若有相同长度的字符串，则输出第一个。
例如：输入:hello huawei!，输出为:huawei
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
Scanner input=new Scanner(System.in);
String str0=input.nextLine(); //输入两个！！！时怎么办！！！！！！难道这种题只需要外面写实现函数？？？？
System.out.println("原字符串"+str0);
String result=text. limitedCarCard( str0 );
System.out.println(result);
}
public String limitedCarCard(String input ){
String[] strs=input.split("\\s+");
System.out.println("被空格隔开的子字符串数组---->"+Arrays.toString(strs));
String result="";
int maxLen=strs[0].length();
for(int i=0;i<strs.length;i++){
if(maxLen<strs[i].length()){
maxLen=strs[i].length();
}
}
System.out.println("最长字符串长度---->"+maxLen);
for(int i=0;i<strs.length;i++){
if(strs[i].length()==maxLen){
result=strs[i];
break;
}
}
System.out.println("最长字符串---->"+result);//下面进一步改写，只能有数字和字符：
char[] cresult=result.toCharArray();
StringBuffer sb=new StringBuffer();
for(int i=0;i<cresult.length ;i++)
if(Character.isLetterOrDigit(cresult[i]))//!!!!!!!!!!!!!!!!!!
sb.append(cresult[i]);
return sb.toString();
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 /**
  * .输入一段字符串，字符串中包含空格、数字、符号和字母（包含大小写），要求完成函数使得输出给定字符串中最长字符串，输出的字符串可以包含数字和字符，不可以有空格和符号。若有相同长度的字符串，则输出第一个。
例如：输入:hello huawei!，输出为:huawei
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
		  HWText text=new HWText();
		  Scanner input=new Scanner(System.in);
		  String str0=input.nextLine();  //输入两个！！！时怎么办！！！！！！难道这种题只需要外面写实现函数？？？？
		  System.out.println("原字符串"+str0);
		  String result=text. limitedCarCard( str0 );
		  System.out.println(result);
	 }	 
	 public String  limitedCarCard(String input  ){  
		 String[] strs=input.split("\\s+");
		 System.out.println("被空格隔开的子字符串数组---->"+Arrays.toString(strs));
		 String result="";
		 int maxLen=strs[0].length();
		 for(int i=0;i<strs.length;i++){
			 if(maxLen<strs[i].length()){
				 maxLen=strs[i].length();
			 }
		 }
		 System.out.println("最长字符串长度---->"+maxLen);
		 
		 for(int i=0;i<strs.length;i++){
			 if(strs[i].length()==maxLen){
				 result=strs[i];
				 break;
			 }
		 }
		 System.out.println("最长字符串---->"+result);//下面进一步改写，只能有数字和字符：
		 char[] cresult=result.toCharArray();
		 StringBuffer sb=new StringBuffer();
		 for(int i=0;i<cresult.length ;i++)
			 if(Character.isLetterOrDigit(cresult[i]))//!!!!!!!!!!!!!!!!!!
				 sb.append(cresult[i]);
		 
	        return sb.toString();  
	 }
	 
	 }

第16题：第一题是一串字符，拼音的1~9，输出相应数字，比如输入yiersansiwuliuqibajiu，输出123456789
方法： outputNum(String inputString)

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 第一题是一串字符，拼音的1~9，输出相应数字，比如输入yiersansiwuliuqibajiu，输出123456789
方法： outputNum(String inputString)
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
HWText text=new HWText();
String output=text. outputNum("yiersansiwuliuqibajiu" );
System.out.println(output);
}
public String outputNum(String input ){
String result=input.replace("yi", "1").replace("er", "2").replace("san", "3").replace("si", "4").replace("wu", "5")
.replace("liu", "6") .replace("qi", "7").replace("ba", "8").replace("jiu", "9") ;
System.out.println("input----->"+input);//input----->yiersansiwuliuqibajiu !!注意原来的input并没有变；与arraylist的区别
return result;//123456789
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 /**
  * 第一题是一串字符，拼音的1~9，输出相应数字，比如输入yiersansiwuliuqibajiu，输出123456789 
方法： outputNum(String inputString)
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		  HWText text=new HWText();
 		  String output=text. outputNum("yiersansiwuliuqibajiu" );
 		  System.out.println(output);			 
	 }	 
	 public String outputNum(String input ){  
		 String result=input.replace("yi", "1").replace("er", "2").replace("san", "3").replace("si", "4").replace("wu", "5")
				 .replace("liu", "6") .replace("qi", "7").replace("ba", "8").replace("jiu", "9") ;
		 System.out.println("input----->"+input);//input----->yiersansiwuliuqibajiu  !!注意原来的input并没有变；与arraylist的区别
		 return result;//123456789
	 }
	 
}

第17题：假设1900年1月1日是星期一，然后让你输出之后的****年*月*日是星期几。（代码还有些问题！！~~）
*方法：getWeek(Stirng date); //其中date的格式为 yyyy-MM-dd

[java] view plain copy print ?

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 /**
  *假设1900年1月1日是星期一，然后让你输出之后的****年*月*日是星期几。
  *方法：getWeek(Stirng date);  //其中date的格式为 yyyy-MM-dd
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		   Scanner input=new Scanner(System.in);
 		   String str0=input.nextLine();
 		   HWText text=new HWText();
 		   String output=text.getWeek(str0);
 		   System.out.println(output);
	 }	 
	 public String getWeek(String data ){ 
		 Calendar c0=Calendar.getInstance();
		 c0.set(1970, 0, 1);//日历的月份比实际少1
		 String[] dates=data.split("-");
		 int year=Integer.parseInt(dates[0]);
		 int month=Integer.parseInt(dates[1])-1;
		 int day=Integer.parseInt(dates[2]);
		
		 Calendar c1=Calendar.getInstance();
		 c1.set(year, month, day); 
		 int days_cj=0;//两个日期相距的时间
		 days_cj=(int)(c1.getTime().getTime()-c0.getTime().getTime())/24*60*60*1000; //c.getTime返回Date对象，Date.getTime()返回距1970.1.1的毫秒数 
		 int week=days_cj%7;
		 String week_s="";
		 switch(week){
		 case 0:
			 week_s="星期一";
			 break;
		 case 1:
			 week_s="星期二";
			 break;
		 case 2:
			 week_s="星期三";
			 break;
		 case 3:
			 week_s="星期四";
			 break;
		 case 4:
			 week_s="星期五";
			 break;
		 case 5:
			 week_s="星期六";
			 break;
		 case 6:
			 week_s="星期天";
			 break;
		 }
		 
		 return week_s; 
	 }
	 
}

第18题：问题描述：
我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：8613912345678。特点如下：
1、长度13位；
2、以86的国家码打头；
3、手机号码的每一位都是数字。
请实现手机号码合法性判断的函数（注：考生无需关注手机号码的真实性，也就是说诸如86123123456789这样的手机号码，我们也认为是合法的），要求：
1）如果手机号码合法，返回0；
2）如果手机号码长度不合法，返回1
3）如果手机号码中包含非数字的字符，返回2；
4）如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
要求实现函数：
int verifyMsisdn(char* inMsisdn)
【输入】 char* inMsisdn，表示输入的手机号码字符串。
【输出】无
【返回】判断的结果，类型为int。
示例
输入： inMsisdn = “869123456789“
返回： 1
输入： inMsisdn = “8813912345678“
返回： 3
输入： inMsisdn = “8613912345678“
返回： 0

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Scanner;
/**
*问题描述：
我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：8613912345678。特点如下：
1、长度13位；
2、以86的国家码打头；
3、手机号码的每一位都是数字。
请实现手机号码合法性判断的函数（注：考生无需关注手机号码的真实性，也就是说诸如86123123456789这样的手机号码，我们也认为是合法的），要求：
1）如果手机号码合法，返回0；
2）如果手机号码长度不合法，返回1
3）如果手机号码中包含非数字的字符，返回2；
4）如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
要求实现函数：
int verifyMsisdn(char* inMsisdn)
【输入】 char* inMsisdn，表示输入的手机号码字符串。
【输出】无
【返回】判断的结果，类型为int。
示例
输入： inMsisdn = “869123456789“
返回： 1
输入： inMsisdn = “8813912345678“
返回： 3
输入： inMsisdn = “8613912345678“
返回： 0
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
String str0=input.nextLine();
HWText text=new HWText();
int output=text.verifyMsisdn(str0);
System.out.println(output);
}
public int verifyMsisdn(String phoneNum ){
if(phoneNum.length()!=13)
return 1;//若此处return了不会再执行后面的代码！！！！！！！！！
for(int i=0;i<phoneNum.length();i++){
if(!Character.isDigit(phoneNum.charAt(i)))
return 2;//若此处return了不会再执行后面的代码！！！！！！！！！
}
if(phoneNum.charAt(0)!='8'||phoneNum.charAt(1)!='6')
return 3;//若此处return了不会再执行后面的代码！！！！！！！！！
return 0;//其他情况时
}
}

package com.sheepmu.text;

 
import java.util.Scanner;
 
 /**
  *问题描述：
我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：8613912345678。特点如下：
 1、  长度13位；
2、  以86的国家码打头；
3、  手机号码的每一位都是数字。
 请实现手机号码合法性判断的函数（注：考生无需关注手机号码的真实性，也就是说诸如86123123456789这样的手机号码，我们也认为是合法的），要求：
1）  如果手机号码合法，返回0；
2）  如果手机号码长度不合法，返回1
3）  如果手机号码中包含非数字的字符，返回2；
4）  如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
要求实现函数：
  int verifyMsisdn(char* inMsisdn)
【输入】 char* inMsisdn，表示输入的手机号码字符串。
【输出】  无
【返回】  判断的结果，类型为int。
示例
输入：  inMsisdn = “869123456789“
返回：  1
输入：  inMsisdn = “8813912345678“
返回：  3
输入：  inMsisdn = “8613912345678“
返回：  0
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		   Scanner input=new Scanner(System.in);
 		   String str0=input.nextLine();
 		   HWText text=new HWText();
 		   int output=text.verifyMsisdn(str0);
 		   System.out.println(output);
	 }	 
	 public int verifyMsisdn(String phoneNum ){ 
		 if(phoneNum.length()!=13)
			 return 1;//若此处return了不会再执行后面的代码！！！！！！！！！
		 for(int i=0;i<phoneNum.length();i++){ 
			 
			 if(!Character.isDigit(phoneNum.charAt(i)))
				 return 2;//若此处return了不会再执行后面的代码！！！！！！！！！
		 }
		 if(phoneNum.charAt(0)!='8'||phoneNum.charAt(1)!='6')
			 return 3;//若此处return了不会再执行后面的代码！！！！！！！！！
		 
		 
		  return 0;//其他情况时
	 }
	 
}

第19题：输入一下小于5000的整数，例如68，加上它反过来的数86,68+86=154，如果不是回文，则继续进行这种操作，154+451=605，605+506=1111是回文数。返回1111
如果在7次这种操作内仍不能得出一个回文数，则返回0

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Scanner;
/**
* 输入一下小于5000的整数，例如68，加上它反过来的数86,68+86=154，如果不是回文，则继续进行这种操作，154+451=605，605+506=1111是回文数。返回1111
如果在7次这种操作内仍不能得出一个回文数，则返回0
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int number=input.nextInt();
int result=getHuiWen(number);
System.out.println( result);
}
public static boolean isHuiWen(int number){
String str0=String.valueOf(number);
StringBuffer sb=new StringBuffer(str0);
String str1=sb.reverse().toString();//sb有非常好的reverse方法！！哈哈，String 和ArrayList都木有！！
if(str0.equals(str1))
return true;
return false;//这里就是若上面没有return就return false,就相当与这儿else ..
}
public static int toReverse(int number){
String str0=String.valueOf(number);
StringBuffer sb=new StringBuffer(str0);
String str1=sb.reverse().toString();
return Integer.parseInt(str1);
}
public static int getHuiWen(int number){
int sum=number+toReverse(number);//题目意思好像是至少都要加一次的吧
int count=1;
while(!isHuiWen(sum)&&count<8){
sum+=toReverse(sum);
count++;
}
if(isHuiWen(sum))
return sum;
return 0;
}
}

package com.sheepmu.text;

import java.util.Scanner;
 
 /**
  * 输入一下小于5000的整数，例如68，加上它反过来的数86,68+86=154，如果不是回文，则继续进行这种操作，154+451=605，605+506=1111是回文数。返回1111
如果在7次这种操作内仍不能得出一个回文数，则返回0
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		   Scanner input=new Scanner(System.in);
 		   int number=input.nextInt();
 		   int result=getHuiWen(number);
 		   System.out.println( result);   
	 }	 
	  public static boolean isHuiWen(int number){
		  String str0=String.valueOf(number);
		  StringBuffer sb=new StringBuffer(str0);
		  String str1=sb.reverse().toString();//sb有非常好的reverse方法！！哈哈，String 和ArrayList都木有！！
		  if(str0.equals(str1))
			  return true;
		 return false;//这里就是若上面没有return就return false,就相当与这儿else ..
	  }
	 public static  int toReverse(int number){
		 String str0=String.valueOf(number);
		  StringBuffer sb=new StringBuffer(str0);
		  String str1=sb.reverse().toString();
		 return Integer.parseInt(str1);
	 }
	 public static int getHuiWen(int number){
		 int sum=number+toReverse(number);//题目意思好像是至少都要加一次的吧
		 int count=1;
		 while(!isHuiWen(sum)&&count<8){
			 sum+=toReverse(sum);
			 count++;
		 }
		 if(isHuiWen(sum))
			 return sum;
		 return 0;
	 }
}

第20题：要从5个人中选取2个人作为礼仪，其中每个人的身高范围为160-190，要求2个人的身高差值最小（如果差值相同的话，选取其中最高的两人），以升序输出两个人的身高。
Smple input：161 189 167 172 188 Sample outPut: 188 189

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Arrays;
import java.util.Scanner;
/**
* 要从5个人中选取2个人作为礼仪，其中每个人的身高范围为160-190，要求2个人的身高差值最小（如果差值相同的话，选取其中最高的两人），以升序输出两个人的身高。
Smple input：161 189 167 172 188 Sample outPut: 188 189
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
String numbers=input.nextLine();
String result=getTwo(numbers);
System.out.println( result);
}
public static String getTwo(String input){
System.out.println("输入身高字符串---->"+ input);
// int[] high =new int[input.length()];//------错误情况0---------，因为有空格所以input.length()不是5！！！！
// for(int i=0;i<high.length;i++)
// high[i]=Integer.parseInt(input.charAt(i)+"");
// char[] high_c= input.toCharArray();//------错误情况1---------
// System.out.println("带空格的string变成数组----->"+Arrays.toString( high_c));//带空格的string变成数组----->[1, 6, 7, , 1, 7, 8, , 1, 7, 9]
String[] high_s=input.split("\\s+");
System.out.println("带空格的string变成数组后----->"+Arrays.toString( high_s));//带空格的string变成数组----->[178, 172, 167]
int[] high=new int[high_s.length];
for(int i=0;i<high_s.length;i++)
high[i]=Integer.parseInt(high_s[i]+"");
Arrays.sort(high );
System.out.println("int型数组排序后----->"+Arrays.toString( high));
int[] cha=new int[high.length-1];//定义个差值数组来装相邻两数的差，因为已经排序了，所以相邻的差值肯定是最小的
for(int i=0;i<high.length-1;i++){
cha[i]=high[i+1]-high[i];
}
System.out.println("差值数组----->"+Arrays.toString(cha));
int minCha=cha[0];
int minCha_index=0;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
for(int i=0;i<cha.length;i++){
if(minCha>=cha[i]){//相等也赋值，因为排序后后面的大些，所以两个差值相等时肯定输出后面一对
minCha=cha[i];
minCha_index=i;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!得到对应的下标
}
}
System.out.println("最小差----->"+minCha+" 最小差对应的首下标--->"+minCha_index);
String output= high[minCha_index]+" "+high[minCha_index+1];
return output;
}
}

package com.sheepmu.text;

import java.util.Arrays;
import java.util.Scanner;
 
 /**
  * 要从5个人中选取2个人作为礼仪，其中每个人的身高范围为160-190，要求2个人的身高差值最小（如果差值相同的话，选取其中最高的两人），以升序输出两个人的身高。
Smple input：161 189 167 172 188 Sample outPut: 188 189
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		   Scanner input=new Scanner(System.in);
 		   String  numbers=input.nextLine();
 		   String result=getTwo(numbers);
  		   System.out.println( result);   
	 }	 
	   public static String getTwo(String input){
		   System.out.println("输入身高字符串---->"+ input); 
		   
//		   int[] high =new int[input.length()];//------错误情况0---------，因为有空格所以input.length()不是5！！！！
//		   for(int i=0;i<high.length;i++)
//			   high[i]=Integer.parseInt(input.charAt(i)+"");
		   
//		 char[] high_c=  input.toCharArray();//------错误情况1---------
//		 System.out.println("带空格的string变成数组----->"+Arrays.toString( high_c));//带空格的string变成数组----->[1, 6, 7,  , 1, 7, 8,  , 1, 7, 9]
		  
		   
		   
		   String[] high_s=input.split("\\s+");
		   System.out.println("带空格的string变成数组后----->"+Arrays.toString( high_s));//带空格的string变成数组----->[178, 172, 167]
		   int[] high=new int[high_s.length];
		   for(int i=0;i<high_s.length;i++)
 		  		high[i]=Integer.parseInt(high_s[i]+"");
		   Arrays.sort(high );
		   System.out.println("int型数组排序后----->"+Arrays.toString( high));
		   int[] cha=new int[high.length-1];//定义个差值数组来装相邻两数的差，因为已经排序了，所以相邻的差值肯定是最小的
		   for(int i=0;i<high.length-1;i++){
			   cha[i]=high[i+1]-high[i];
		   }
		   System.out.println("差值数组----->"+Arrays.toString(cha));
		   int minCha=cha[0];
		   int minCha_index=0;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		   for(int i=0;i<cha.length;i++){
			   if(minCha>=cha[i]){//相等也赋值，因为排序后后面的大些，所以两个差值相等时肯定输出后面一对
				   minCha=cha[i];
				   minCha_index=i;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!得到对应的下标
				   }
		   }
		   System.out.println("最小差----->"+minCha+"        最小差对应的首下标--->"+minCha_index);
		   String output= high[minCha_index]+" "+high[minCha_index+1];
 		   return output;
	   }
}

第21题：在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。
要求实现函数：
int delete_sub_str(const char *str, const char *sub_str, char *result_str)
【输入】 str：输入的被操作字符串
sub_str：需要查找并删除的特定子字符串
【输出】 result_str：在str字符串中删除所有sub_str子字符串后的结果
【返回】删除的子字符串的个数
注：
I、子串匹配只考虑最左匹配情况，即只需要从左到右进行字串匹配的情况。比如：
在字符串"abababab"中，采用最左匹配子串"aba",可以匹配2个"aba"字串。如果
匹配出从左到右位置2开始的"aba"，则不是最左匹配，且只能匹配出1个"aba"字串。
II、输入字符串不会超过100 Bytes，请不用考虑超长字符串的情况。
示例
输入：str = "abcde123abcd123"
sub_str = "123"
输出：result_str = "abcdeabcd"
返回：2
输入：str = "abcde123abcd123*****fdaklfa11123*123jfdlafl"
sub_str = "1234"
输出：result_str = "abcde123abcd123"

返回：0

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Arrays;
import java.util.Scanner;
/**
* 在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。
要求实现函数：
int delete_sub_str(const char *str, const char *sub_str, char *result_str)
【输入】 str：输入的被操作字符串
sub_str：需要查找并删除的特定子字符串
【输出】 result_str：在str字符串中删除所有sub_str子字符串后的结果
【返回】删除的子字符串的个数
注：
I、子串匹配只考虑最左匹配情况，即只需要从左到右进行字串匹配的情况。比如：
在字符串"abababab"中，采用最左匹配子串"aba",可以匹配2个"aba"字串。如果
匹配出从左到右位置2开始的"aba"，则不是最左匹配，且只能匹配出1个"aba"字串。
II、输入字符串不会超过100 Bytes，请不用考虑超长字符串的情况。
示例
输入：str = "abcde123abcd123"
sub_str = "123"
输出：result_str = "abcdeabcd"
返回：2
输入：str = "abcde123abcd123*****fdaklfa11123*123jfdlafl"
sub_str = "1234"
输出：result_str = "abcde123abcd123"
返回：0
* @author sheepmu
*/
public class HWText {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
String s0=input.next();
String s1=input.next();
int result=getTwo(s0,s1);
System.out.println( result);
}
public static int getTwo(String fstr,String sub){
System.out.println("输入原符串---->"+ fstr+" 子串---->"+sub);
int count=0;
// public int indexOf(String str)如果字符串参数作为一个子字符串在此对象中出现，
//则返回第一个这样的子字符串的第一个字符的索引；如果它不作为一个子字符串出现，则返回 -1。
while(fstr.indexOf(sub)!=-1){
fstr=fstr.substring(0, fstr.indexOf(sub)).concat(fstr.substring(fstr.indexOf(sub)+sub.length(),fstr.length()));
// fstr=fstr.replace(sub, "");//一定要记得把操作后的字符串赋值给fstr,因为字符串操作后会变成新的对象，不像arraylist,!!不然会无限循环
//因为需要计数，所以不能用replace();用replace()把里面的全部都替换掉了，相当于只在while里进行了一次
count++;
System.out.println("进入while,count--->"+count);
}
System.out.println(fstr);
return count;
}
}

package com.sheepmu.text;

import java.util.Arrays;
import java.util.Scanner;
 
 /**
  * 在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。
要求实现函数：
int delete_sub_str(const char *str, const char *sub_str, char *result_str)
【输入】 str：输入的被操作字符串
sub_str：需要查找并删除的特定子字符串
【输出】 result_str：在str字符串中删除所有sub_str子字符串后的结果
【返回】 删除的子字符串的个数
注：
I、 子串匹配只考虑最左匹配情况，即只需要从左到右进行字串匹配的情况。比如：
在字符串"abababab"中，采用最左匹配子串"aba",可以匹配2个"aba"字串。如果
匹配出从左到右位置2开始的"aba"，则不是最左匹配，且只能匹配出1个"aba"字串。
II、 输入字符串不会超过100 Bytes，请不用考虑超长字符串的情况。
示例
输入：str = "abcde123abcd123"
sub_str = "123"
输出：result_str = "abcdeabcd"
返回：2
输入：str = "abcde123abcd123*****fdaklfa11123*123jfdlafl"
sub_str = "1234"
输出：result_str = "abcde123abcd123"
返回：0
  * @author sheepmu
  */
public class HWText {
	 public static void main(String[] args){
 		   Scanner input=new Scanner(System.in);
 		   String  s0=input.next();
 		  String  s1=input.next();
 		   int result=getTwo(s0,s1);
  		   System.out.println( result);   
	 }	 
	   public static int getTwo(String fstr,String sub){
		   System.out.println("输入原符串---->"+ fstr+"      子串---->"+sub); 
		   int count=0;
		//  public int indexOf(String str)如果字符串参数作为一个子字符串在此对象中出现，
	       //则返回第一个这样的子字符串的第一个字符的索引；如果它不作为一个子字符串出现，则返回 -1。
	        while(fstr.indexOf(sub)!=-1){  	
         	fstr=fstr.substring(0, fstr.indexOf(sub)).concat(fstr.substring(fstr.indexOf(sub)+sub.length(),fstr.length()));
	   //  fstr=fstr.replace(sub, "");//一定要记得把操作后的字符串赋值给fstr,因为字符串操作后会变成新的对象，不像arraylist,!!不然会无限循环
	      //因为需要计数，所以不能用replace();用replace()把里面的全部都替换掉了，相当于只在while里进行了一次  
         	count++;    
        	System.out.println("进入while,count--->"+count);
	        }
	        System.out.println(fstr);
	        return count;  
	   }
}

第22题：输入字符串长度，字符串，计数m。从前往后计数，当数到m个元素时，m个元素出列，同时将该元素赋值给m，然后从下一个数计数循环，直到所有数字都出列，给定的数全部为大于0的数字。输出出队队列。
例如: 输入：len=4 str="3,1,2,4" m=7
输出：2,3,1,4

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Arrays;
/* 输入字符串长度，字符串，计数m。从前往后计数，当数到m个元素时，m个元素出列，同时将该元素赋值给m，
* 然后从下一个数计数循环，直到所有数字都出列，给定的数全部为大于0的数字。输出出队队列。
例如: 输入：len=4 str="3,1,2,4" m=7
输出：2,3,1,4
思路：最简单的约瑟夫环，数组实现！
* 出局的数放在新数组，把该数置为新的m;并把该出局的数置为-1，i++并把j又从1开始；每次都整个遍历原数组，遇到-1时i加而j不加。
* @author sheepmu
*/
public class RingText {
public static void main(String[] args){
String str0="3,1,2,4";
int len=4;
int m=7;
int[] result=chuQuan(str0,len,m); //[2, 3, 1, 4]
System.out.println(Arrays.toString(result));
}
public static int[] chuQuan(String str0,int len,int m){
String[] str1=str0.split(",");
int[] arr_yuan=new int[len];
for(int i=0;i<str1.length;i++)
arr_yuan[i]=Integer.parseInt(str1[i]);
int[] arr_new=new int[len];//新数组，存放依次出来的人
int left=len;//用来标识结束循环。
int i=0;//原数组。。
int j=1;//要删除的。。。
int k=0;//新数组初始下标。
while(left>0){
if(arr_yuan[i%len]>0){// !!!!!!!!!!!!!i%m的作用在于当i=m-1，即读到最后一个数时，继续读下一个，即第0个！！
if(j==m){
arr_new[k++]=arr_yuan[i%len];
m=arr_yuan[i%len];//把这个值置为新的m. !!!!!!!!!!!
arr_yuan[i%len]=-1;
left--;
i++;
j=1;
}
else{
i++;
j++;
}
}
else{//为-1时只是i加而j不加。
i++;
}
}
return arr_new;
}
}

package com.sheepmu.text;

import java.util.Arrays;
  /*   输入字符串长度，字符串，计数m。从前往后计数，当数到m个元素时，m个元素出列，同时将该元素赋值给m，
   * 然后从下一个数计数循环，直到所有数字都出列，给定的数全部为大于0的数字。输出出队队列。
    例如:  输入：len=4    str="3,1,2,4"   m=7   
             输出：2,3,1,4  
             思路：最简单的约瑟夫环，数组实现！ 
   *            出局的数放在新数组，把该数置为新的m;并把该出局的数置为-1，i++并把j又从1开始；每次都整个遍历原数组，遇到-1时i加而j不加。 
  * @author sheepmu
  */ 
public class RingText {
	 public static void main(String[] args){
		  String str0="3,1,2,4";
		  int len=4;
		  int m=7;
		  int[] result=chuQuan(str0,len,m);	 //[2, 3, 1, 4]
		  System.out.println(Arrays.toString(result)); 
		 
	 }	 	 
	 public static int[] chuQuan(String str0,int len,int m){
		
		 String[] str1=str0.split(",");
		 int[] arr_yuan=new int[len];
		 for(int i=0;i<str1.length;i++)
			 arr_yuan[i]=Integer.parseInt(str1[i]);
		  int[] arr_new=new int[len];//新数组，存放依次出来的人
		  int left=len;//用来标识结束循环。
		  int i=0;//原数组。。
		  int j=1;//要删除的。。。
		  int k=0;//新数组初始下标。
		  while(left>0){
			  if(arr_yuan[i%len]>0){// !!!!!!!!!!!!!i%m的作用在于当i=m-1，即读到最后一个数时，继续读下一个，即第0个！！	  
				  if(j==m){
					  arr_new[k++]=arr_yuan[i%len];
					  m=arr_yuan[i%len];//把这个值置为新的m.  !!!!!!!!!!!
					  arr_yuan[i%len]=-1;
					  left--;
					  i++;
					  j=1;
				  }
				  else{
					  i++;
					  j++;
				  }
			  }
			  else{//为-1时只是i加而j不加。
				  i++;
			  }
		  }
		 return arr_new;
	 }
}

第23题：题目: 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。

题前知识点补充：

[java] view plain copy print ?

package com.sheepmu.text;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/*
* @author sheepmu
*/
public class HWCompetition {
public static void main(String[] args){
String s="我AB";
byte[] bs0;
byte[] bs1;
byte[] bs2;
byte[] bs3;
byte[] bs4;
byte[] bs5;
try {
bs0= s.getBytes("GBK");
System.out.println("GBK---我AB--->"+Arrays.toString(bs0) );
bs1= s.getBytes("UTF-8");
System.out.println("UTF-8----我AB------>"+Arrays.toString(bs1) );
bs2= s.getBytes("UNICODE");
System.out.println("UNICODE---我AB----->"+Arrays.toString(bs2) );
bs3= "我".getBytes("UNICODE");
System.out.println("UNICODE---我----->"+Arrays.toString(bs3) );
bs4= "A".getBytes("UNICODE");
System.out.println("UNICODE---A----->"+Arrays.toString(bs4) );
bs5= "AB".getBytes("UNICODE");
System.out.println("UNICODE---AB----->"+Arrays.toString(bs5) );
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}

package com.sheepmu.text;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
  /*    
  * @author sheepmu
  */ 
public class HWCompetition {
	  public static void main(String[] args){
		  String s="我AB"; 
		  byte[] bs0;
		  byte[] bs1;
		  byte[] bs2;
		  byte[] bs3;
		  byte[] bs4;
		  byte[] bs5;
		try {
			bs0= s.getBytes("GBK");
			 System.out.println("GBK---我AB--->"+Arrays.toString(bs0) );
			 bs1= s.getBytes("UTF-8");
			 System.out.println("UTF-8----我AB------>"+Arrays.toString(bs1) );
			 bs2= s.getBytes("UNICODE");
			 System.out.println("UNICODE---我AB----->"+Arrays.toString(bs2) );
			 bs3= "我".getBytes("UNICODE");
			 System.out.println("UNICODE---我----->"+Arrays.toString(bs3) );
			 bs4= "A".getBytes("UNICODE");
			 System.out.println("UNICODE---A----->"+Arrays.toString(bs4) );
			 bs5= "AB".getBytes("UNICODE");
			 System.out.println("UNICODE---AB----->"+Arrays.toString(bs5) );
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} 
 		 
	  }
	  
}

[java] view plain copy print ?

package com.sheepmu.text;
import java.io.UnsupportedEncodingException;
  /*    
  * @author sheepmu
  */ 
public class HWCompetition {
	  public static void main(String[] args){
		  String s="我ABC汉DEF"; 
		  int len=6;
		  System.out.println("原字符串---->"+s);
		  HWCompetition hw=new HWCompetition();
		  String result=hw.getString(s,len);
 		  System.out.println("题目结果---->"+result);
	  }
	  public String getString(String s,int len)  { 	
		  if(len<=0){//!!!!!!!!!!!!!!!!!!防各种测试用例!!!!!!!!!!!!!!!!!!!!
			  return "";
		  }
		  if(s.getBytes().length<=len){
			  return s;
		  }
		  if(s==null||s.equals("")){
			  return "";
		  }
		  else{
			  String news=s.substring(0, len);//只需在len前查询汉字个数
			  System.out.println("news---->"+news);
			  int n=0;
			try {
				n = news.getBytes("GBK").length-len;//汉字个数
				System.out.println("news.getBytes().length---->"+news.getBytes("GBK").length);
				System.out.println("n---->"+n);
				
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			return news.substring(0, len-n);
		  }
		 
	  }
}

第24题：功能描述：数组的循环移位，
输入：{a,b,c},2
输出：{b,c,a}
要求实现方法：
/**
*data :待循环数组
*index:移动位数
*/
public String[] getChildren(String[] data,int index)
{
return null;

}

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.Arrays;
  /*     
  * @author sheepmu
  */ 
public class HWCompetition {
	public static void main(String[] args) {    
        char buf[]={'a','b','c','d','e'};    
        int n=8;       
        perm(buf,n);
    }    
    public static char[] perm(char[] buf,int n ){   
    	if(buf==null||buf.length==0){
    		return null;
    	}
    	if(n==0){
    		return buf;
    	}
    	int len=buf.length;
    	char[] c=new char[len];
    	int rel=n%len;
    	if(n>0){		
        	 for(int i=0;i<len;i++){
        		 c[(i+rel)%len]=buf[i];
        	 }       	  
    	}
    	else{
    		for(int i=0;i<len;i++){	 
       		   if(i+rel<0){		 
       			c[i+len+rel ]=buf[i];
       		   }
       		   else{
       			   c[i+rel]=buf[i];
       		   }
       	 }      	 
    	}
    	System.out.println(Arrays.toString(c));
      	 return c;
    }
     
}

第25题：写出一个程序，接受一个浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整
-4.5 四舍五入的结果是-4
4.4 四舍五入的结果是4

[java] view plain copy print ?

package com.sheepmu.text;
/*
* @author sheepmu
*/
public class HWCompetition {
public static void main(String[] args) {
double d=-23.234;
System.out.println(getValue(d) );
}
public static int getValue(double d){
if(!String.valueOf(d).contains(".")){
return (int)d;
}
String[] ss=String.valueOf(d).split("\\.");
if(Integer.valueOf(ss[1].substring(0, 1)).intValue()<5){
return (int)Math.floor(d);// 取接近它的比它小的浮点数xx.0000
}
else{
return (int)Math.ceil(d);//取接近它的比它大的浮点数(int)xxxx.00000
}
}
}

package com.sheepmu.text;
  /*     
  * @author sheepmu
  */ 
public class HWCompetition {
	public static void main(String[] args) {    
      double d=-23.234;
      
      System.out.println(getValue(d) );
    }    
    public static int getValue(double d){   
    	 if(!String.valueOf(d).contains(".")){
    		 return (int)d;
    	 }  
    	 String[] ss=String.valueOf(d).split("\\.");
    	 if(Integer.valueOf(ss[1].substring(0, 1)).intValue()<5){
    		 return (int)Math.floor(d);// 取接近它的比它小的浮点数xx.0000
    	 }
    	 else{
    		 return (int)Math.ceil(d);//取接近它的比它大的浮点数(int)xxxx.00000
    	 }
      	  
    }
     
}

第26题：求两个字符串的最长公共子串，若有长度相等的公共子串，返回第一次出现的。子串指至少两个字符，单个字母不算子串。

[java] view plain copy print ?

package com.sheepmu.text;
import java.util.ArrayList;
import java.util.List;
/*若公共子串长度相等，返回第一次出现的。
* @author sheepmu
*/
public class HWCompetition {
public static void main(String[] args) {
String s1="kqabcdexyz";
String s2="ababckyabcdyyybcde";
System.out.println(getStr(s1,s2,true));
}
public static String getStr(String s1,String s2 ,boolean isSelf){//第三个参数表示是否允许短的字符串本身作为子串
String shortStr=s1.length()>s2.length()? s2:s1;
String longtStr=s1.length()>s2.length()? s1:s2;
int shortLen=shortStr.length();
List<String> list=new ArrayList<String>();
int maxStrLen=0;//公共子串的最长长度。这样可以保证是公共子串但是长度比已出现的公共子串短的时就不用再加入list里面了。
String temp="";
for(int i=0;i<shortLen;i++){
for(int j=i+2;j<shortLen;j++){
temp=shortStr.substring(i,j);
boolean b1=isSelf&&longtStr.indexOf(temp)!=-1;
boolean b2=!isSelf&&!temp.equals(shortStr)&&longtStr.indexOf(temp)!=-1;
if((b1||b2)&&temp.length()>=maxStrLen){
list.add(temp);
maxStrLen=temp.length();
}
}
}
System.out.println(list);
int maxLen=list.get(0).length();
int maxIndex=0;
for(int k=1;k<list.size();k++){
if(list.get(k).length()>maxLen){
maxLen=list.get(k).length();
maxIndex=k;
}
}
return list.get(maxIndex);
}
}

package com.sheepmu.text;

import java.util.ArrayList;
import java.util.List;
  /*若公共子串长度相等，返回第一次出现的。    
  * @author sheepmu
  */ 
public class HWCompetition {
	public static void main(String[] args) {    
       String s1="kqabcdexyz";
       String s2="ababckyabcdyyybcde";   
       System.out.println(getStr(s1,s2,true));
    }    
    public  static String getStr(String s1,String s2 ,boolean isSelf){//第三个参数表示是否允许短的字符串本身作为子串      	
    	String shortStr=s1.length()>s2.length()? s2:s1;
    	String longtStr=s1.length()>s2.length()? s1:s2;
    	int shortLen=shortStr.length();
    	List<String> list=new ArrayList<String>();
    	int maxStrLen=0;//公共子串的最长长度。这样可以保证是公共子串但是长度比已出现的公共子串短的时就不用再加入list里面了。
    	String temp="";
    	for(int i=0;i<shortLen;i++){ 
    		for(int j=i+2;j<shortLen;j++){
    			 temp=shortStr.substring(i,j);
    			 boolean b1=isSelf&&longtStr.indexOf(temp)!=-1;
    			 boolean b2=!isSelf&&!temp.equals(shortStr)&&longtStr.indexOf(temp)!=-1;
    			if((b1||b2)&&temp.length()>=maxStrLen){
    				list.add(temp);
    				maxStrLen=temp.length();
    			}
    		}
    	}
    	System.out.println(list);
    	int maxLen=list.get(0).length();
    	int maxIndex=0;
    	for(int k=1;k<list.size();k++){
    		if(list.get(k).length()>maxLen){
    			maxLen=list.get(k).length();
    			maxIndex=k;
    		}		
    	}
    	 return list.get(maxIndex);
    }
     
}

Full Stack Developme

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
华为上机题汇总

—————————————————————————————————————————————————————————————————转载自：http://blog.csdn.net/sheepmu/article/details/20941803——————————————————————————————————————————————————————————————————以下...
复制链接

扫一扫

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。