各种操作字符串的方法



 第一题，输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。从后向前比较，以最短字符串为标准，输出不同的元素的个数。

    例如:  输入：s1="1,3,5"   len1=3       s2="2,4,1,7,5"   len2=5  

             输出：2 

   函数原型

public int getDiffNum(int len1, String s1, int len2, String s2) 

[java] view plain copy

1. public class HuaWeiTest {  

2.   

3.     public static void main(String[] args) {  

4.         String s1 = "1,3,5";  

5.         String s2 = "2,4,1,7,5";  

6.         int len1 = 3;  

7.         int len2 = 5;  

8.         HuaWeiTest hwt = new HuaWeiTest();  

9.         System.out.println(hwt.getDiffNum(len1, s1, len2, s2));  

10.    }  

11.      

12.    public int getDiffNum(int len1, String s1, int len2, String s2)  {  

13.        int count = 0;  

14.        int len = 0;  

15.        String[] arr1 = s1.split(",");  

16.        String[] arr2 = s2.split(",");  

17.        if(len1 > len2) len = len2;  

18.        else len = len1;  

19.        for(int i=0;i<len;i++) {  

20.            if(!arr1[len1-i-1].equals(arr2[len2-i-1])) {  

21.                count ++;  

22.            }  

23.        }  

24.        return count;  

25.    }  

26.}  

 

 第二题，输入字符串长度，字符串，计数m。从前往后计数，当数到m个元素时，m个元素出列，同时将该元素赋值给m，然后从下一个数计数循环，直到所有数字都出列，给定的数全部为大于0的数字。输出出队队列。

    例如:  输入：len=4    str="3,1,2,4"  m=7   

             输出：2,3,1,4 

   函数原型

public String getOutString(int len, String str, int m) 

[java] view plain copy

1. import java.util.ArrayList;  

2. import java.util.List;  

3.   

4.   

5. public class HuaWeiTest {  

6.   

7.     public static void main(String[] args) {  

8.         int len=4;  

9.         String str="3,1,2,4";     

10.        int m=7;    

11.        HuaWeiTest hwt = new HuaWeiTest();  

12.        System.out.println(hwt.getOutString(len, str, m));  

13.    }  

14.    public String getOutString(int len, String str, int m) {  

15.        String ret ="";  

16.        String[] arr = str.split(",");  

17.        List<String> ls = new ArrayList<String>();  

18.        for(int i=0;i<len;i++) {  

19.            ls.add(arr[i]);  

20.        }  

21.        for(int i=0;i<len;i++) {  

22.            int temp = (m-1)%ls.size();  

23.            ret += ls.get(temp);  

24.            m = Integer.parseInt(ls.get(temp))+temp;  

25.            ls.remove(temp);  

26.        }  

27.        return ret;  

28.    }  

29.}  

第三题，输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。

    例如:  输入：3+8×2/9-2  

             输出：2 

   函数原型 

view plain

1. public int getMyRet(String str) 

1、选秀节目打分，分为专家评委和大众评委，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

1. public class SWTest {  

2.   

3.     public static void main(String[] args) {  

4.         int score[] = {  

5.                 34,53,65,75,64  

6.         };  

7.         int judge_type[] = {  

8.                 1,1,1,2,2  

9.         };  

10.        SWTest st = new SWTest();  

11.        System.out.print(st.cal_score(score, judge_type, 5));  

12.  

13.    }  

14.      

15.    int cal_score(int score[], int judge_type[], int n){  

16.        int totalExpert = 0;  

17.        int totalPublic = 0;  

18.        int numExpert = 0;  

19.        int numPublic = 0;  

20.        for(int i=0;i<n;i++) {  

21.            if(judge_type[i]==1) {  

22.                totalExpert += score[i];  

23.                numExpert ++;  

24.            }  

25.            if(judge_type[i] == 2){  

26.                totalPublic += score[i];  

27.                numPublic ++;  

28.            }  

29.        }  

30.        if(0==numPublic){  

31.            return (int)totalExpert/numExpert;  

32.        }else  

33.        {  

34.            return (int)((totalExpert/numExpert)*0.6) +   

35.            (int)((totalPublic/numPublic)*0.4);  

36.        }  

37.          

38.    }  

39.  

40.}  

 2、给定一个数组input[]，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到 output
[] 数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
      例如：input[] = {3, 6, 1, 9, 7}   output[] ={3, 7, 9, 6, 1};             input[] = {3, 6, 1,9, 7, 8}    output[] = {1, 6, 8, 9, 7, 3}

           函数接口  void sort(int input[[, int n, int output[])

[java] view plain copy

1. public class SWTest {  

2.   

3.     public static void main(String[] args) {  

4.         int input[] = {3,6,1,9,7,8};  

5.         int output[] = new int[6];  

6.         SWTest st = new SWTest();  

7.         st.sort(input, 6, output);  

8.         for(int i=0;i<output.length;i++){  

9.             System.out.print(output[i]);  

10.        }  

11.    }  

12.      

13.    void sort(int input[], int n, int output[]){  

14.        for(int i=0;i<n-1;i++){  

15.            for(int j=n-1;j>i;j--){  

16.                if(input[j]>input[j-1]) {  

17.                    int temp = input[j];  

18.                    input[j] = input[j-1];  

19.                    input[j-1] = temp;  

20.                }  

21.            }  

22.        }  

23.        int low = n/2-1;  

24.        int high = n/2+1;  

25.        output[n/2] = input[0];  

26.        for(int i=1;i<n;){  

27.            output[low] = input[i];  

28.            low --;  

29.            i++;  

30.            if(i == n) break;  

31.            output[high] = input[i];  

32.            high++;  

33.            i++;  

34.        }  

35.    }  

36.}  

      3、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任
务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[]中的任务按照系统任务、用户任务依次存放到 system_task[]数组和user_task[]数组中（数组中元素的值是任务在task[]数组中的下标），并且优先级高的任务排在前面，优先级相同的任务按照入
队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。
      例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40,99}    system_task[] = {0, 3, 1, 7, -1}    user_task[] ={4, 8, 2, 6, -1}

        函数接口   void scheduler(int task[], int n, int system_task[], intuser_task[])

[java] view plain copy

1. void scheduler(int task[], int n, int system_task[], int user_task[]){  

2.     int min = 0 ,s =0, u =0 ;  

3.     for(int i=0;i<n-1;i++) {  

4.         min = 0;  

5.         for(int j=0;j<n;j++) {  

6.             if(task[min]>task[j]) min = j;  

7.         }  

8.         if(task[min]<50) {  

9.             system_task[s++] = min;  

10.        }else if(task[min]<=255) {  

11.            user_task[u++] = min;  

12.        }  

13.        task[min] = 300;  

14.    }  

15.    system_task[s]= -1;  

16.    user_task[u] = -1;  

17.}  

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

[java] view plain copy

1. public class PhoneNumber {  

2.   

3.     public static void main(String[] args) {  

4.         String  inMsisdn = "8613912345678";  

5.         System.out.println(new PhoneNumber().verifyMsisdn(inMsisdn));  

6.     }  

7.     int verifyMsisdn(String inMsisdn){  

8.         char[] inchars = inMsisdn.toCharArray();  

9.         if(inchars.length!=13) return 1;  

10.        for(int i=0;i<13;i++) {  

11.            if(!Character.isDigit(inchars[i])){  

12.                return 2;  

13.            }  

14.        }  

15.        if((Character.digit(inchars[0], 10)!=8 )||(Character.digit(inchars[1], 10)!=6) ) return 3;  

16.        else return 0;  

17.    }  

18.}  

面试题不同公司有所不同，今天我整理了一些java上机面试题例子，希望这些例子对大家会有所帮助。

题目：
有n个人围城一圈每次从1数起数到3就把那个人提出圈子，最后只保留一个人。
输入： 输入人数字符串
输出：把最后一个人所保留位置返回出来。
比如你输入11的话即有11个人 [1,2,3,4,5,6,7,8,9,10,11]。返回的是7.
如果输入”123a” 的话，返回的是”0″。

package com.javaer.huawei;
 
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class TestJosephRing {
 
public static void main(String args[]){
String n = "11";
TestJosephRing tj = new TestJosephRing();
System.out.println(tj.getTheLeftPerson(n));
}
 
public int getTheLeftPerson(String num){
 
Pattern p =Pattern.compile("[a-zA-Z]|p{Punct}");//处理非法字符
Matcher m = p.matcher(num);
if(m.find()){
return 0;
}
 
int n = Integer.parseInt(num);
List<Integer> pL = newArrayList<Integer>();
for(int i=0; i<n; i++){
pL.add(i+1);
}
 
int count = 3;
for(int i=0; i<n-1; i++){
int temp = (count-1)%pL.size();//要移除的位置
pL.remove(temp);
count = temp+3; //保留被移除的位置，再加上计数
}
 
//最后肯定只剩下一个
return pL.get(0);
}
}

 

手动输入一个字符串，仅限小写字母，统计并输出每个字符在字符串中出现的次数，并输出。提示可以用map

例子：输入：aaabbbccc

输出：a 3

b3

c3

分析： 看到后面的提示，简直就是不用动脑，直接简单粗暴的顺势而上

直接上代码：

package com.javaer.huawei;
 
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
 
public class TestCharAcount {
 
public static void main(String args[]) {
String strIn = "aaabbbccc";
TestCharAcount tc = new TestCharAcount();
Map<Character, Integer> mTemp = tc.charAcount(strIn);
 
Set<Character> ks = mTemp.keySet();//生成索引set
for (Iterator<Character> it =ks.iterator(); it.hasNext();) {//遍历索引取值
char c = it.next();
System.out.println(c + " " +mTemp.get(c));
}
 
}
 
public Map<Character, Integer>charAcount(String strIn) {
String tempStr = strIn;
 
// The map is sorted according to the naturalordering of its keys
// treemap是以键的自然顺序来存储值的
Map<Character, Integer> m = newTreeMap<Character, Integer>();
char[] strC = tempStr.toCharArray();
for (int i = 0; i < strC.length; i++) {
Integer count = m.get(strC[i]);
if (null == count)
count = 0;
 
count++;
m.put(strC[i], count);
}
 
return m;
}
}