华为机试题及参考答案
转载自：http://blog.csdn.net/dsfas3432/article/details/17100967
/*
* 程序实现目标：输入一个字符串，将其各个字符对应的ASCII值加5后，输出结果。
程序要求：该字符串只包含小写字母，若其值加5后的字符值大于'z',将其转换成从a开始的字符。
*/
public class Main001 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String str="afdsfdsxz";
char[] indata=str.toCharArray();
addAccii(indata);
}
public static void addAccii(char[] indata){
for(int i=0;i<indata.length;i++){
if((indata[i]+5)>122){
indata[i]= 'a';
}else{
indata[i]= (char)(indata[i]+5);
}
System.out.print(indata[i]);
}
}
}
/*
* 功能描述：判断一个字符串中是否只含有相同的子字符串（子串长度>=2）
输入：abab
返回：true
输入：abcd
返回：false
*/
public class Main002 {
static void main(String[] args) {
String str = "ertyertyabcdabcdsdf464132132146464165479lhkjhnkjgibkjbjljdslfsajdlasdf4asdf5a7e";
int count = 2;
List<String> maxLengthList = newArrayList<String>();
maxLengthList = checkString(str,count, maxLengthList);
System.out.println(maxLengthList);
StringBuilder sbBuilder = new StringBuilder();
if (maxLengthList.isEmpty()) {
System.out.println("无重复并且长度大于2的子串！");
} else {
int maxLength = maxLengthList.get(0).length();
sbBuilder.append(maxLengthList.get(0)).append(",");
for (int i = 1; i < maxLengthList.size(); i++) {
if (maxLengthList.get(i).length() == maxLength){
sbBuilder.append(maxLengthList.get(i)).append(",");
}
}
System.out.println("重复最长子串为："
+sbBuilder.toString().substring(0,
sbBuilder.toString().length() - 1));
}
String str1 = "abab";
int startindex = 0;
int count2 = 2;
System.out.println(isHave(str.substring(0,count2), str1, startindex,
count));
}
public static List<String>checkString(String str, int count,
List<String> maxLengthList) {
if (count >str.length() / 2 + 1) {
return maxLengthList;
}
for (int i = 0; i <str.length() - count; i++) {
List<String> strList = new ArrayList<String>();
String regex = str.substring(i,i + count) + "+?";
Pattern pattern= Pattern.compile(regex);
Matcher matcher= pattern.matcher(str);
while (matcher.find()) {
strList.add(matcher.group());
}
if (strList.size()> 1
&& !maxLengthList.contains(str.substring(i, i + count))) {
maxLengthList.add(str.substring(i, i + count));
}
}
count++;
if (count >str.length()) {
return maxLengthList;
}
checkString(str,count, maxLengthList);
Collections.sort(maxLengthList,new Comparator<Object>() {
@Override
publicint compare(Object o1,Object o2) {
int length1 =o1.toString().length();
int length2 =o2.toString().length();
return length1 - length2< 0 ? 1 : (length1 - length2 == 0 ? o1
.toString().compareTo(o2.toString()) : -1);
}
}
);
return maxLengthList;
}
public static boolean isHave(Stringstr1, String str,int startindex,
int count) {
boolean isHave =false;
++startindex;
if (count >str.length() / 2 + 1) {
return isHave;
}
List<String>strList = new ArrayList<String>();
String regex = str1+ "+?";
Pattern pattern =Pattern.compile(regex);
Matcher matcher =pattern.matcher(str);
while (matcher.find()) {
strList.add(matcher.group(0));
}
if (strList.size()> 1) {
isHave = true;
} else if(!str.endsWith(str1)) {
int endIndex =startindex + count;
if (endIndex >str.length()) {
return isHave;
}
isHave = isHave(str.substring(startindex,endIndex), str,
startindex, count);
} else {
++count;
isHave = isHave(str.substring(0,count), str, startindex, count);
}
return isHave;
}
}
/*
* 3、手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
实例：
输入：1,2,5,9,84,3,2
输出：84,9
* */
public class Main003 {
public static void main(String[] args) {
Main003 test = new Main003();
int[] arr = {1,45,98,6,4};
test.getMaxValue(arr);
}
public void getMaxValue(int[] arr){
int temp=0;
if(arr.length<1){
System.out.println("数组元素个数至少为2");
}
else{
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[i]>arr[i+1]){
temp = arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}
System.out.print(arr[arr.length-1]+"、"+arr[arr.length-2]);
}
}
}
/*
* 题目描述：
有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，
这样的数字就称为：回文数字。编写一个函数，判断某数字是否是回文数字。
要求实现方法：
public String isPalindrome(String strIn);
【输入】strIn:整数，以字符串表示；
【返回】true:是回文数字；
false: 不是回文数字；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例：
输入：strIn = “121”
返回：”true
*/
public class Main004 {
public static void main(String[] args) {
String inputValue = JOptionPane.showInputDialog("请输入一个整数");
long inputValueLong =Long.parseLong(inputValue);
long temp =inputValueLong;
long reverseLong = 0L;
while(inputValueLong !=0)
{
reverseLong =reverseLong*10+inputValueLong%10;
inputValueLong =inputValueLong/10;
}
if(reverseLong ==temp)
System.out.println("你输入的是回文数");
else
System.out.println("你输入的不是回文数");
}
}
/*
* 6.手动输入一个字符串，仅限小写字母，统计并输出每个字符在字符串中出现的次数,并输出。
* 提示(可以用Map)
实例：
输入：aaabbbccc
输出： a 3
b 3
c 3
*/
public class Main006 {
public static void main(String[] args) {
statTimes("dfsdfgerfgtewthgat");
}
static void statTimes(Stringparam)
{
if(param ==null) return;
//hashset保存不重复的值因此
HashSet<Character>hSet = new HashSet<Character>();
char[] cs =param.toCharArray();
for (char c : cs)
hSet.add(c);
ArrayList<Character>list = new ArrayList<Character>(hSet);
int n =hSet.size(); //有多少种字符
int[] times =new int[n]; //保存每种字符的出现次数
for (char c : cs) //进行统计
times[list.indexOf(c)]++;
for (int i = 0; i < n;i++)
System.out.println("字符 " + list.get(i) +"出现了：" + times[i] +"次。");
//打印结果
}
}
/*
* 要求实现方法public String addTwoBigNumber(String s1,string s2)
大数相加，注意处理异常
*/
public class Main007 {
String result,s1,s2;
int s1Len, s2Len;
public Main007(Stringstr1,String str2)
{
s1=str1;
s2=str2;
}
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("input thefirst number:");
String s1=sc.nextLine();
System.out.println("input thesecond number:");
String s2=sc.nextLine();
sc.close();
Main007 a=new Main007(s1,s2);
String res=a.add();
System.out.println("my addresult is: "+res);
}
public boolean check()//输入异常检查
{
for(int i=0;i<s1Len;i++)
{
if(s1.charAt(i)>'9'||s1.charAt(i)<'0')
{
System.out.println("first inputis not a number");
return false;
}
}
for(int i=0;i<s2Len;i++)
{
if(s2.charAt(i)>'9'||s2.charAt(i)<'0')
{
System.out.println("secondinput is not a number");
return false;
}
}
return true;
}
public String add()
{
result="";
s1Len=s1.length();
s2Len=s2.length();
if(check())
{
if(s1Len<s2Len)//make s1 longerthan s2
{
String tempStr=s2;
s2=this.s1;
s1=tempStr;
int tempNum=s2Len;
s2Len=s1Len;
s1Len=tempNum;
}
int flag=0;//if there is acarry-over from the behind number
int deltaLen=s1Len-s2Len;
int sum;
for(int i=s1Len-1; i>=0; i--)
{
if(i-deltaLen>=0)
sum=(s1.charAt(i)-'0')+(s2.charAt(i-deltaLen)-'0')+flag;
else
sum=(s1.charAt(i)-'0')+flag;
flag=0;
if(sum>9)//if there is acarry-over
{
sum-=10;
flag=1;
}
result=sum+result;
}
if(flag==1)//if the highestbit has a carry-over
{
result="1"+result;
flag=0;
}
}
returnresult;
}
}
/*
* 8、比较二维数组列最小值，组成一个新数组返回。(实现核心算法，不需要使用IO)
输入：{{5,6,1,16},{7,3,9}}
输出：intArrs ={1,3}
*/
public class Main008 {
public static void main(String args[]) {
// 写测试方法
int[][] a = { { 5, 6, 1, 16 }, { 7, 3, 9 }, { 2, 4, 56 } };
int[] ss =getColMin(a);
for (int i = 0; i < ss.length; i++) {
System.out.print(ss[i] +"");
}
}
public static int[] getColMin(int a[][]) {
int[] res =new int[a.length];
for (int i = 0; i < a.length; i++) {
int[] s = a[i];
Arrays.sort(s);
res[i] = s[0];
}
return res;
}
}
/*
* 输入：aaa,cat tiger.123dd
输出： tiger
功能描述：键盘输入一句话
输出一句话中最长的单词，如果最长的出现多次，返回第一个。
这句话只包含数字字母和标点。
*/
public class Main009 {
private static String langWord(String inString) {
int sum=0;
String[] strings=inString.split("[ ,.1-9]");
ArrayList<String> strings2=new ArrayList<String>();
for (int i = 0; i < strings.length; i++) {
if (sum<strings[i].length()) {
sum=strings[i].length();
strings2.add(strings[i]);
}
}
return strings2.get(strings2.size()-1);
}
public static void main(String[] args) {
System.out.println("请输入字符串：");
Scanner scanner=new Scanner(System.in);
String data=scanner.nextLine();
System.out.println(langWord(data));
}
}
/**
* 10、功能描述：将字符串中的字母全部替换成字母的下一个字母，要是最后一位是z或Z则替换为a或A。
* 输入：aBxyZ
* 输出：bCyzA
*/
public class Main010 {
public static void main(String[] args) {
String data = "aBxyZ";
System.out.println(new Main010().nextString(data));
}
public String nextString(String data) {
char[] arr = data.toCharArray();
for (int i = 0; i < arr.length; i++) {
if (arr[i] >='a' && arr[i] <= 'z' || arr[i] >='A'
&& arr[i] <= 'Z') {
if (arr[i] =='z' || arr[i] == 'Z') {
arr[i] = (char) (arr[i] - 25);
} else if ((arr[i] >= 'a' && arr[i] <'z')
|| (arr[i] >= 'A' && arr[i] <'Z')) {
arr[i] = (char) (arr[i] + 1);
}
}
}
String res = String.valueOf(arr);
return res;
}
}
/**
*2、求一个整形数组中元素的平均值，并统计其中大于和小于此平均值的元素的个数
要求：输入：整形数组中的元素个数及各个元素
输出：整型数组中元素的平均值，大于和小于此平均值的元素个数
*/
public class Main011 {
public static void main(String[] args) {
int[] arr ={1,100};
new Main011().getavage(arr, 2);
}
public void getavage(int[] arr,int num){
if(num==0){
System.out.println("数组为空");
}else{
double avage = 0.0;
int sum = 0;
int count1=0;
int count2=0;
for(int i=0;i<arr.length;i++){
sum += arr[i];
}
avage = (double)sum/num;
for(int j =0;j<num;j++){
if(arr[j]>avage){
count1++;
}else{
count2++;
}
}
System.out.println("平均值:"+avage);
System.out.println("大于平均值的元素个数:"+count1);
System.out.println("小于平均值的元素个数:"+count2);
}
}
}
/*
* 功能描述：已知：yier sansi wu liu qi ba jiu 分别对应123456789，
对一段只含有这几种字符串的字符串进行转换，如：
输入：yiersansan
输出：1233
*/
public class Main012 {
public static void main(String[] args) {
Replace("yiersansan","yi","1");
System.out.println(Replace("yiersansan","yi","1"));
}
public static String Replace(String source,String oldString,StringnewString){
if (source ==null) {
return null;
}
StringBuffer output = new StringBuffer();
int lengOfsource = source.length();
int lengOfold = oldString.length();
int posStart;
int pos;
for (posStart = 0;(pos =source.indexOf(oldString, posStart))>=0;posStart=pos+lengOfold){
output.append(source.substring(posStart,pos));
output.append(newString);
}
if (posStart < lengOfsource) {
output.append(source.substring(posStart));
}
return output.toString();
}
}
/*
* 功能描述：删除字符串中字符个数最少的字符，最少字符串有多个，最少的要全部删除
然后返回该子字符串。
输入：asdasdas
输出：asasas
*/
public class Main013 {
/**
* 一、创建HashMap，然后统计字符串每个字母的次数，将字母作为HashMap的键，
* 字母出现的次数作为值
二、得到最小的值，然后得到对应的字母
三、String.split("字母")，得到不包含该字符的字符串数据
四、用StringBuffer将这些字符串连接起来，最终得到需要的字符串
* @param args
*/
public static void main(String args[]){
String str;
int flg[] =new int[200];//只考虑小写或者大写的字母
int min=5;
char c='c';
Scanner s = new Scanner(System.in);
List<Object> v = new ArrayList<Object>();
str=s.next();
for(int i=0;i<str.length();i++){
char ch =str.charAt(i);
min=((++flg[ch]<min) ? flg[ch]:min);
if(min<=flg[ch]){
c=ch;
}
}
for(int i=0;i<str.length();i++){
char ch=str.charAt(i);
if(ch==c){
}else{
v.add(ch);
}
}
String ss=v.toString();
System.out.println(ss);
}
}
/*
* 功能描述：找出一个int[]中满足 2^n的数字，然后组成的新的数组
输入：{4,3，8}
输出：{4,8}
*/
public class Main014 {
/**
* @param args
*/
public static void main(String[] args) {
int[] data1={256,2,4,3,1,15,16,28,44,32,64};
int[] data2=nestString(data1);
System.out.println(Arrays.toString(data2));
}
private static int[] nestString(int[] data) {
List<Integer> list=new ArrayList<Integer>();
for (int i = 0; i < data.length; i++) {
int temp = data[i];
while (temp != 2) {
if (temp %2== 0) {
temp /=2;
}else {
break;
}
}
if (temp==2) {
list.add(data[i]);
}
}
int [] data2=newint[list.size()];
for (int i = 0; i < list.size(); i++) {
data2[i]=list.get(i);
}
return data2;
}
}
/*
*
功能描述：共data1个人，围成一圈，然后标号，从1-data1。
然后从data2号开始从1报数，报3的出列，求出列序列。
返回一个数组
如：
输入：3，2
输出：1,2,3
要求实现方法：
/*
* data1：人数
* data2 : 起始位置
*
public int[] circleOut(int data1,int data2)
{
int outNum = 3;
//TODO
return null;
}
*/
public class Main015 {
/**
* 约瑟夫环问题
*/
private static int count=0;//定义数到的人的编号count
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入人数：");
int n=scanner.nextInt();
System.out.println("请输入出局号码：");
int m=scanner.nextInt();
long s1 = System.currentTimeMillis();
sortP(n,m);
long s2 = System.currentTimeMillis();
System.out.println("所用总时间："+(s2-s1));
}
private static void sortP(int n,int m) {
if(n==1){//特殊情况
System.out.println(n);;
}else {
f1(n, m);
}
}
//当人数大于1时执行此函数
private static void f1(int n,int m) {
int[] arr =new int[n];
for(int j=0;j<n;j++){//循环执行n（总人数）次，排出出局次序
for(int i = 0;i<m;i++){
count++;//每数一人count加1
measure(j, arr);//判断count是否已在数组中
if(count>n){
count=1;//若count大于总人数将其置1
measure(j, arr);//继续进行判断
}
}
arr[j]=count;//将出局人序号保存至数组
}
System.out.println("出局顺序为："+Arrays.toString(arr));
System.out.println("最后出局人为："+arr[n-1]);
}
/*用于判断count是否已存在，若存在count加1继续判断
* 此函数用双重循环，若为单重不能保证count在数组唯一
* */
private static void measure(int j,int[] arr) {
for(int s = 0;s<j;s++){
for(int w=0;w<j;w++){
if(count==arr[w])count++;
}
}
}
}
/*
* 功能描述：统计一个数字转为二进制后，0和1的个数，组成数组返回
输入：6
输出：{1,2}
*/
public class Main016 {
public static void main(String[] args) {
test();
test2();
}
/**
* 统计二进制数中0的个数[除法操作]
*/
public static void test() {
int d = 6;
int count = 0;
while (d != 0) {
if (d % 2 == 0) {
count++;
}
d /= 2;
}
System.out.println(count);
}
/**
* 统计二进制数中0的个数[与操作]
*/
public static void test1() {
int d = 6;
int count = 0;
while (d != 0) {
if ((d & 0x01) != 1) {
count++;
}
d >>= 1;
}
System.out.println(count);
}
/**
* 统计二进制数中1的个数的方法。时间复杂度只与1的个数有关。
*/
public static void test2() {
int n = 6;
int count = 0;
while (n != 0) {
count++;
n = n & (n - 1);
}
System.out.println(count);
}
}
/*
* 功能描述：对一个二进制数的每位进行0和1反转，求翻转后的二进制所对应的十进制
输入：110
输出：5
*/
public class Main017 {
public static void main(String[] args) {
test();
}
/**
* 反转二进制数并输出结果的十进制值是多少
*/
public static void test() {
int d = 110;
int len = Integer.toBinaryString(d).length();
int b[] =new int[len];
int index = 0;
while (d != 0) {
b[index++] = d & 0x01;
d >>= 1;
}
int c = 0;
d = 0;
while (c < len) {
d = d * 2 + b[c];
c++;
}
System.out.println(d);
}
}
/*
* 功能描述：判断一个字符串中的"( )"是否配对
输入：if(a.equals(a))
输出：true
*/
public class Main018 {
public static void main(String[] args) {
System.out.println(isStack("{}{}{{{}sss}}"));
// System.out.println(isStack("{"));
// System.out.println(isStack(""));
// System.out.println(isStack("{{fdsfs}}{}"));
System.out.println(isStack("{}}"));
}
private static boolean isStack(Stringstring) {
Stack<Character>stackz = new Stack<Character>();
for (int i = 0; i <string.length(); i++) {
if (string.charAt(i)=='{') {
stackz.push(string.charAt(i));
} else if (string.charAt(i)== '}') {
if (stackz.isEmpty()){
return false;
} else {
stackz.pop();
}
}
}
if (stackz.isEmpty()){
return true;
} else {
return false;
}
}
}
/*
* 功能描述：查找一个字符串的子字符串集
输入：abab
输出：a bab ba aba bab
*/
public class Main019 {
/**
* @param args
*/
public static void main(String[] args) {
perenum("abcdef",3);
}
public static ArrayList<String> perenum(String str,int m)
{
ArrayList<String> strArr = new ArrayList<String>();
Find(strArr,"",str);
return null;
}
public static String Find(ArrayList<String> strArr,StringstrBef,String str)
{
for(int i=0 ;i<str.length();++i)
{
String allstr = strBef+str.charAt(i);
String str1=str.substring(i+1);
Find(strArr,allstr,str1);
strArr.add(allstr);
System.out.print(allstr+"\n");
}
return str;
}
}
/*
* 功能描述：数组的循环移位，
输入：{a,b,c,},2
输出：{b,c,a}
*/
public class Main020 {
/**
* @param args
*/
public static void main(String[] args) {
int[] n ={7,4,8,9,1,5};
char[]n2={'a','b','c'};
for(int i=0;i<n.length;i++){
outNum(n);
System.out.println();
moveNum(n);
}
}
private static void moveNum(int[] n) {//数组元素移位
int temp = n[n.length-1];
for(int i=n.length-1;i>0;i--){
n[i] = n[i-1];
}
n[0] = temp;
}
private static void outNum(int[] n) {//输出数组
for(int i=0;i<n.length;i++){
System.out.print(n[i]);
}
}
}
/*
* 程序实现目标：输入一个字符，将字符转换为小写，将其对应的ASCII值加5后，输出结果。
程序要求：若其值加5后的字符值大于'z',将其转换成从a开始的字符。
输入：‘A’
输出：‘f’
*/
public class Main021 {
public static void main(String[] args) {
Main021 test = new Main021();
String data = "q";
String regex = "^[a-z]*$";
if (data.matches(regex)) {
System.out.println(test.getString(data));
} else {
System.out.println("输入的字符串不合法");
}
}
public char[] getString(String data) {
char[] arr = data.toCharArray();
for (int i = 0; i < arr.length; i++) {
if (arr[i] + 5 >'z') {
arr[i] = (char) (arr[i] - 21);
} else {
arr[i] = (char) (arr[i] + 5);
}
}
return arr;
}
}
/*
* 要求：将一个二维数组进行逆序，逆序后所有的元素行列不定，进行随机排列
*/
public class Main022 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generatedmethod stub
}
}
/*
* 根据输入m数据，找出str的m个字符的所有字符串
例如"abc"m=2
"ab" "ac""bc"
"abcd" m=3
"abc" "acd""bcd" "abd"
*/
public class Main023 {
public static void main(String[] args) {
perenum("abcdef",3);
}
public static ArrayList<String> perenum(String str,int m)
{
ArrayList<String> strArr = new ArrayList<String>();
Find(strArr,"",str,m);
return null;
}
public static String Find(ArrayList<String> strArr,StringstrBef,String str,int m)
{
for(int i=0 ;i<str.length();++i)
{
String allstr = strBef+str.charAt(i);
String str1=str.substring(i+1);
Find(strArr,allstr,str1,m);
strArr.add(allstr);
if (allstr.length()==m) {
System.out.print(allstr+"\n");
}
}
return str;
}
}
/*
* 分解质因数
eg：输入 28
输出 2*2*7
*/
public class Main024 {
static boolean is_odd(int n)
{
if(n==2||n==3)return true;
if(n%2==0)return false;
int i;
for(i=3;i<=n/2;i+=2)
if(n%i==0)return false;
return true;
}
public static void main(String[]args)
{
try { Scanner in=new Scanner(System.in);
System.out.println("输入数值");
int n=in.nextInt();
int i;
System.out.print(n+"=");
for(i=2;i<=n;i++)
{
if(!is_odd(i))continue;
if(n%i==0)
{
while(true)
{
System.out.print(i);
n/=i;
if(n!=1) System.out.print("*");
if(n%i!=0)break;
}
}
}
System.out.println();
} catch (Exception e) {
System.out.println("输入的不是整数！");
//e.printStackTrace();
System.exit(0);
}
}
}
/*
* n个长度的字符串中取m个长度的组合
*/
public class Main025 {
/**
* @param args
*/
public static void main(String[] args) {
perenum("abcdef",3);
}
public static ArrayList<String> perenum(String str,int m)
{
ArrayList<String> strArr = new ArrayList<String>();
Find(strArr,"",str,m);
return null;
}
public static String Find(ArrayList<String> strArr,StringstrBef,String str,int m)
{
for(int i=0 ;i<str.length();++i)
{
String allstr = strBef+str.charAt(i);
String str1=str.substring(i+1);
Find(strArr,allstr,str1,m);
strArr.add(allstr);
if (allstr.length()==m) {
System.out.print(allstr+"\n");
}
}
return str;
}
}
/*
* 二维数组转置
例：1 2 3
4 5 6
转置
1 4
2 5
3 6
*/
public class Main026 {
/**
* @param args
*/
public static void main(String[] args) {
int[][] aa={{1,2,3},{4,5,6}};
int[][] bb=turn(aa);
for(int[] ii:bb){
for(int i:ii){
System.out.print(i+" ");
}
System.out.println();
}
}
public static int[][] turn(int[][] aa) {
int lencol=aa[0].length;
int lenrow=aa.length;
int [][] rr=newint[lencol][lenrow];
for (int i = 0; i < lencol; i++) {
for (int j = 0; j < lenrow; j++) {
rr[i][j]=aa[j][i];
}
}
return rr;
}
}
}
/*
* 功能描述：输入字符串，将该字符串中数字放到非数字的后面，并保持原有顺序不变。
例如：h3a2p0p1y----------happy3201
*/
public class Main027 {
/**
* @param args
*/
public static void main(String[] args) {
sof("h3a2p0p1y");
}
public static String sof(StringinString) {
char[] t=inString.toCharArray();
ArrayList<String> list1=new ArrayList<String>();
ArrayList<String> list2=new ArrayList<String>();
for (int i = 0; i < t.length; i++) {
if (t[i]>=48 && t[i]<=57) {
list1.add(t[i]+"");
}else if((t[i]>=97&&t[i]<=122)||(t[i]>=65&&t[i]<=91)) {
list2.add(t[i]+"");
}
}
String string1="";
for (Iterator iterator = list2.iterator();iterator.hasNext();) {
string1=string1+(String)iterator.next();
}
String string2="";
for (Iterator iterator = list1.iterator();iterator.hasNext();) {
string2=string2+(String)iterator.next();
}
System.out.println(string1+string2);
return string1+string2;
}
}
/*
* 有一个字符串，请将其中的数字按大小排序
要求：用最简单的方式实现，考虑性能
输入: "32, 43, 76, 4, 54, 2, 93, 1"
*/
public class Main028 {
/**
* @param args
*/
public static void main(String[]args){
String str=new String("13a64bc52");
char[]strArray=str.toCharArray();
List<Character>a=new ArrayList<Character>();
List<Integer> b=newArrayList<Integer>();
for(int i=0;i<strArray.length;i++)
{
if(strArray[i]<='9'&&strArray[i]>='0')
a.add((Character)strArray[i]);
else
b.add((Integer)i);
}
int [] integerArray=newint[a.size()];
for(inti=0;i<a.size();i++)
integerArray[i]=Character.digit((char)a.get(i), 10);
integerArray=bubbingSort(integerArray);
int [] rs=newint[str.length()];
int count=0;
for(int i=0;i<rs.length;i++)
{
for(Iterator<Integer>it=b.iterator();it.hasNext();)
{
int x=it.next();
rs[x]=strArray[x];
}
if(rs[i]!=0)
continue;
else
{
rs[i]=integerArray[count];
count++;
}
}
for(int i=0;i<rs.length;i++)
{
if(rs[i]>9||rs[i]<0)
System.out.print((char)rs[i]);
else
System.out.print(rs[i]);
}
}
public static int[] bubbingSort(int[] a){
int swap=0;
for(int i=a.length-1;i>=0;i--)
for(int j=0;j<i;j++)
{
if(a[i]<a[j])
{
swap=a[i];
a[i]=a[j];
a[j]=swap;
}
}
return a;
}}
/*
* 从一个字符串中返回给定单词的位置，如果有多个，则返回第一次出现的位置,如果没有，则返回0
例子："hello world","hello"
结果：1
*/
public class Main029 {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(theLocation("ahello world","hello"));
}
public static int theLocation(String str1,String str2) {
int sum=0;
if (str1.contains(str2)) {
String [] arrray1=str1.split(" ");
for (int i = 0; i < arrray1.length; i++) {
if (arrray1[i].trim().equals("")) {
++sum;
}
if (str2.equals(arrray1[i])) {
return i-sum+1;
}
System.out.println(arrray1[i]);
}
}
return 0;
}
}
/*
* 输入是一个表达式，比如说是1*2-3+4*5，要求计算出这个表达式的值。
思路：不瞻前，只顾后。
在计算的时候，如果当前运算符是乘除法，则直接计算出来，再考虑后续的。
如果当前的操作符不是乘除，则“顾后”，查看后面的操作符是不是乘除法，
如果是乘除法，则计算乘除法，否则把当前的加减法计算出来，再计算后续的。
*/
public class Main030 {
public static void main(String ss[]) {
String s = "1+2*3*4+5";
System.out.println(calculate(s.toCharArray()));
}
private static double calculate(char[] expr) {
double c1 = Double.parseDouble(expr[0]+"");
double c2 = Double.parseDouble(expr[2]+"");
int index = 3;
char op = expr[1];
while (index < expr.length) {
if (expr[index] =='*' || expr[index] == '/') {
// 如果是乘除法，则先计算
c2 = cal(c2, Double.parseDouble(expr[index+ 1] +""),
expr[index]);
} else {
// 如果不是乘除法，则计算出来结果
c1 = cal(c1, c2,op);
op = expr[index];
c2 = Double.parseDouble(expr[index+ 1] +"");
}
index += 2;
}
returncal(c1, c2, op);
}
private static double cal(double a,double b, char op) {
switch (op) {
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
return a / b;
}
return -1;
}
}
/*
* 最长公共子串和最长公共子序列
*/
public class Main31 {
public static void main(String ss[]) {
get("abcdefg","hbcsefgk");
}
private static void get(String s1, String s2) {
int lcslen = 0;
int pos_x = -1, pos_y = -1;
// 初始化二维数组
int flag[][] =new int[s1.length() + 1][s2.length() + 1];
for (int i = 0; i < s1.length() + 1; i++) {
flag[i][0] = 0;
}
for (int i = 0; i < s2.length() + 1; i++) {
flag[0][i] = 0;
}
for (int i = 1; i <= s1.length(); i++) {
for (int j = 1; j <= s2.length(); j++) {
if (s1.charAt(i - 1) == s2.charAt(j - 1)){
flag[i][j] = flag[i - 1][j- 1] + 1;
if (flag[i][j] > lcslen) {
lcslen =flag[i][j];
pos_x = i;// 记录下最大长度在二维数组中的位置
pos_y = j;
}
} else {
flag[i][j] = 0;
}
}
}
// 方便观察，输出二维矩阵
for (int i = 0; i < s1.length() + 1; i++) {
for (int j = 0; j < s2.length() + 1; j++) {
System.out.print(flag[i][j]);
}
System.out.println();
}
// 输出最长子串
StringBuilder sb = newStringBuilder();
while (flag[pos_x][pos_y] != 0) {
sb.append(s1.charAt(pos_x -1));
pos_x--;
pos_y--;
}
System.out.println(sb.toString());
}
}