几个算法题。。

1. 就餐抽查（30分）

问题描述：

某公司由于人多，午餐分为多批次就餐，严格要求每批次就餐时间。并定期抽查就餐情况。请编写程序实现就餐抽查情况。

要求实现函数：

void check_lunch(int num, int time,int input[], int output[])

【输入】  int num，就餐总人数

         int time，就餐分批数

         char input[]，就餐情况

【输出】  char output[]， 违规就餐情况

【返回】  无

注：对就餐分3批的情况，12人就餐，正确的就餐情况应如下分布[1,2,3,1,2,3,1,2,3,1,2,3]，不符合该分布的即是违规，输出时对相应位置0。

示例

1） 输入：num = 12，time = 3，input =[1,2,3,3,1,3,1,1,1,1,2,3]

输出：output = [1,2,3,0,0,3,1,0,0,1,2,3]

2） 输入：num = 11，time = 4，intput = [1,2,3,4,2,3,3,4,1,2,3]

输出：output = [1,2,3,4,0,0,3,4,1,2,3]

1. package com.sheepmu.text;  
2.   
3. import java.util.Arrays;  
4.   
5.   /*    
6.   * @author sheepmu 
7.   */   
8. public class HWCompetition {  
9.      public static void main(String[] args){  
10.          int num=11,time=4;  
11.          int[] input={1,2,3,4,2,3,3,4,1,2,3};  
12. //       int[] output=new int[]{};  
13.          int[] output=new int[num];  
14.          HWCompetition hwc=new HWCompetition();  
15.          hwc.check_lunch( num,  time, input,  output);  
16.      }         
17.       void check_lunch(int num, int time,int input[], int output[]){  
18.           System.out.println(Arrays.toString(input));  
19.            int j=0;  
20.            for(int i=0;i<num;i++){  
21.                int yushu=(i+1)%time;  
22.                  
23.                if(yushu!=0){  
24.                  if(input[i]==yushu){  
25.                      output[j]=yushu;  
26.                  }  
27.                  else   
28.                      output[j]=0;  
29.                  j++;  
30.              }  
31.              else{//余数==0的情况  
32.                   if(input[i]==time){  
33.                       output[j]=time;  
34.                   }  
35.                   else  
36.                       output[j]=0;  
37.                  j++;  
38.              }  
39.           }  
40.            
41.          System.out.println(Arrays.toString(output));  
42.      }  
43. }      

2. 输入联想（30分）

问题描述：

输入联想功能是非常实用的一个功能，请编程实现类似功能。

要求实现函数：

void auto_complete(char *str, char *tmp,char *output)

【输入】  char *str，候选字符串

         char *tmp，输入字符串

【输出】  int *output，联想匹配的字符串

【返回】  无

注：候选字符串以空格隔开，输入字符串仅从字符串开始处匹配。将匹配的子字符串输出，同样以空格隔开。如无匹配成功的子字符串，则输出空字符串。

示例

1） 输入：str = chengdu chongqing，tmp = c

输出：output = chengdu Chongqing

2） 输入：str = chengdu chongqing，tmp = che

输出：end = Chengdu

3）输入：str = beijing nanjing，tmp = jing

输出：end =  

方法一：

1. package com.sheepmu.text;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6.   /*     
7.   * @author sheepmu 
8.   */   
9. public class HWCompetition {  
10.      public static void main(String[] args){  
11.          String str="chengdu chongqing";  
12.          String tmp="che";  
13.          String output="";  
14.          HWCompetition hwc=new HWCompetition();  
15.          hwc.auto_complete( str,tmp, output);  
16.      }         
17.       void auto_complete(String str,String tmp, String output){  
18.          String[] strs=str.split("\\s");  
19.          List<String> list=new ArrayList<String>();  
20.          for(int i=0;i<strs.length;i++)   
21.              list.add(strs[i]);  
22.          System.out.println("list--->"+list);  
23.          System.out.println("tmp--->"+tmp);  
24.          char[] tmps=tmp.toCharArray();  
25.          int len_list=list.size();   
26.          int len_t=tmps.length;   
27.          for(int j=0;j<len_list;j++){  
28.              int len_list_j=list.get(j).length();  
29.              char[] list_j=list.get(j).toCharArray();  
30.                 for(int k=0;k<len_t;k++){  
31.                      if(len_t>len_list_j){   
32.                          list.remove(j);  
33.                          len_list--;//!!!!!!!!!!!!!!!  
34.                          j--;//!!!!!!!!!!!!! 要是不这样28行会出问题，因为remove后size变成了1，但是j即index却变成了1  
35.                          break;  
36.                          }  
37.                      else {//temp的长度小于带收索的长度  
38.                          if(tmps[k]!=list_j[k]){  
39.                          list.remove(j);  
40.                          len_list--;//!!!!!!!!!!!!!!!  
41.                          j--;//!!!!!!!!!!!!!  
42.                          break;  
43.                      }  
44.                      }  
45.                  }  
46.              }  
47.                
48.         //  output= list.toString();//这样会 [chengdu] ，即会带有两边的[]  
49.              if(!list.isEmpty()){   
50.                  StringBuffer sb=new StringBuffer();  
51.                  sb.append("end=");  
52.                  for(String result:list){  
53.                  sb.append(result+" ");//加上空格！！最后再给去掉尾巴的“  ”；  
54.              }     
55.                  output=sb.toString().trim();//!!  
56.         }  
57.              else{  
58.                  output="end=";  
59.              }   
60.               
61.             System.out.println(output);  
62.          }  
63.      }  
64.        
65.    

方法二：

1. package com.sheepmu.text;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   /*     
6.   * @author sheepmu 
7.   */   
8. public class HWCompetition {  
9.      public static void main(String[] args){  
10.          String str="chengdu chongqing";  
11.          String tmp="che";  
12.          String output="";  
13.          HWCompetition hwc=new HWCompetition();  
14.          hwc.auto_complete( str,tmp, output);  
15.      }         
16.       void auto_complete(String str,String tmp, String output){  
17.          String[] strs=str.split("\\s");//和下面一样，应该是只有\s,\d啊之类的才加\  
18.          List<String> list=new ArrayList<String>();  
19.          for(int i=0;i<strs.length;i++)   
20.              list.add(strs[i]);  
21.          System.out.println("list--->"+list);  
22.          System.out.println("tmp--->"+tmp);   
23.          int len_list=list.size();   
24.            
25.          for(int j=0;j<len_list;j++){//还有一个好方法：!list.get(j).startsWith(tmp);!!!!!!!!!!!!!!!!!!!!  
26.   
27.              if(!list.get(j).matches(tmp+"[a-z]*")){//正则表达式就是爽啊!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  
28.                  list.remove(j);  
29.                 len_list--;  
30.                  j--;  
31.              }  
32.              }  
33.                
34.              if(!list.isEmpty()){   
35.                  StringBuffer sb=new StringBuffer();  
36.                  sb.append("end=");  
37.                  for(String result:list){  
38.                  sb.append(result+" ");//加上空格！！最后再给去掉尾巴的“  ”；  
39.              }     
40.                  output=sb.toString().trim();//!!  
41.         }  
42.              else{  
43.                  output="end=";  
44.              }   
45.               
46.             System.out.println(output);  
47.          }  
48.      }  
49.        
50.    

3. 农场计数问题（20分） 
问题描述：  
已知某农场中有一群鸡和兔子，总共有M个头和N只脚，计算总共有多少鸡和兔子 · 
要求实现函数：  
public String getFowlsNum(int iHeadNum, int iFootNum, ArrayList iChickenNum, ArrayList iRabbitNum) 
【输入】iHeadNum：  总共头的数量   
   iFootNum： 总共脚的数量 
【输出】iChickenNum： 鸡的数量   
     iRabbitNum： 兔子的数量 
【返回】"0"：           找到符合要求的鸡和兔子的数量 
               "-1"：          未找到符合要求的数量 
示例  
输入：iHeadNum =201, iFootNum=604 
输出：iChickenNum.add(100), iRabbitNum.add(101) 返回："0"  
输入：iHeadNum =201, iFootNum=123 
输出： iChickenNum.add(0), iRabbitNum.add(0) 返回："-1"  
 

1. package com.sheepmu.text;  
2. import java.util.ArrayList;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.      public static void main(String[] args){  
8.          int iHeadNum=201;  
9.          int iFootNum=604;  
10.          ArrayList iChickenNum=new ArrayList();  
11.          ArrayList iRabbitNum=new ArrayList();  
12.          HWCompetition hwc=new HWCompetition();  
13.          hwc.getFowlsNum( iHeadNum,iFootNum,iChickenNum,iRabbitNum);  
14.      }         
15.       public String getFowlsNum(int iHeadNum,int iFootNum,ArrayList iChickenNum,ArrayList iRabbitNum){  
16.           if(iFootNum%2!=0){//!!!!!  
17.               System.out.println("iChickenNum.add(0),iRabbitNum.add(0)");  
18.               return "-1";//如果脚的数量为奇数，则明显不对，  
19.           }        
20.           else{  
21.               int ji=2*iHeadNum-iFootNum/2;  
22.               int tui=iFootNum/2- iHeadNum;  
23.               if(ji>=0&&tui>=0)   
24.                   System.out.println("iChickenNum.add("+ji+"),iRabbitNum.add("+tui+")");         
25.               return "0";  
26.           }    
27.          }  
28.      }  
29.        
30.    

4.字符串压缩（30分） 
问题描述：  
将给定的字符串，按照规格压缩，输出压缩后的字符串。压缩规格为：相同字符连续，则压缩为“字符+数字个数”，如”aaaa”压缩为”a4” 
注：1、仅是单个字符连续才压缩，如babababa则不能压缩 
2、待压缩字符串中不包含数字和转义符 · 
要求实现方法：  
public String compressStr(String srcStr) 【输入】srcStr：  待压缩的字符串 
【输出】无 
【返回】            压缩后的字符串 
示例  

输入：srcStr = "aaacccddef" 返回："a3c3d2ef"

方法一：（用ArrayList）详情见华为上机汇总第 8 题

方法二：（用String,可读性不如上者，就当为熟悉API吧）

1. package com.sheepmu.text;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4.   /*     
5.   * @author sheepmu 
6.   */   
7. public class HWCompetition {  
8.      public static void main(String[] args){  
9.          String str="abcddef";  
10.          HWCompetition hwc=new HWCompetition();  
11.          String result=hwc.compressStr(str);  
12.          System.out.println(result);  
13.      }         
14.       public String compressStr(String str){  
15.           StringBuffer sb=new StringBuffer();  
16.            for(int i=0;i<str.length();i++){  
17.                if(str.length()==0)  
18.                    break;  
19.                if(str.length()==1)  
20.                    sb.append(str.charAt(i));//针对aaacccddef  
21.                for(int j=i+1;j<str.length();j++){  
22.                     if(str.charAt(i)==str.charAt(j)){  
23.                           if(j==str.length()-1){//针对当后面一直没有出现不同时：aaacccddeffff                               
24.                               sb.append(str.length()).append(str.charAt(i));  
25.                               str=str.substring(j);//长度只剩0了。一定要赋给新的str!!!!!!!!!!!!!!!!!!!!!!!!                         
26.                               break;  
27.                               }  
28.                     }   
29.                     else{//遇到不等时  
30.                         if(j==1)  
31.                             sb.append(str.charAt(i));  
32.                         else   
33.                             sb.append(j).append(str.charAt(i));  
34.                          System.out.println(sb.toString());  
35.                         str=str.substring(j);  
36.                         i--;  
37.                         break;  
38.                     }  
39.                        
40.                    }        
41.          }  
42.            return sb.toString();  
43.      }  
44. }   
45.    

5. 排序算法（20分）
问题描述
将给定的无序整数数组降序排列后输出，输入的无序数组长度为N，类型为unsigned int
要求实现函数
 void DscSort (const int InputArray[], unsigned int n, int OutputArray[])
 【输入】InputArray：  给定的无序数组
               n：     数组长度
 【输出】OutputArray： 排序后的数组
 【返回】无
 示例
 输入：InputArray={1,5,4,8,3,2,9,6,7,0}

 输出：OutputArray={9,8,7,6,5,4,3,2,1,0}

方法一：（直接调用api）思路：升序再倒过来输出

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.      public static void main(String[] args){  
8.          int[] inputArray={1,5,4,8,3,2,9,6,7,0};  
9.          int n=inputArray.length;  
10.          int[] outputArray=new int[n];  
11.          HWCompetition hwc=new HWCompetition();  
12.          hwc.dscSort (inputArray,n,outputArray);  
13.            
14.      }         
15.      void dscSort (int InputArray[],   int n, int OutputArray[]){  
16.          Arrays.sort(InputArray);//升序  
17.          int i=0;  
18.          while(--n>=0){  
19.              OutputArray[i++]=InputArray[n];  
20.          }  
21.          System.out.println(Arrays.toString(OutputArray));  
22.      }  
23. }   

方法二：（若题目规定不能调用api）

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.      public static void main(String[] args){  
8.          int[] inputArray={1,5,4,8,3,2,9,6,7,0};  
9.          int n=inputArray.length;  
10.          int[] outputArray=new int[n];  
11.          HWCompetition hwc=new HWCompetition();  
12.          hwc.dscSort (inputArray,n,outputArray);  
13.          System.out.println(Arrays.toString(inputArray));  
14.      }         
15.      void dscSort (int InputArray[],   int n, int OutputArray[]){//自己写：快排降序  
16.          int high=0;  
17.          int low=n-1;  
18.          sort(InputArray,high,low);   
19.      }  
20.      void sort(int InputArray[],int high,int low){  
21.          int i,j,temp;      
22.          i=high;//高端下标      
23.          j=low;//低端下标      
24.          temp=InputArray[i];//取第一个元素为标准元素。      
25.                
26.          while(i<j){//递归出口是 low>=high      
27.                while(i<j&&temp>InputArray[j])//后端比temp小，符合降序，不管它，low下标前移    
28.                    j--;//while完后指比temp大的那个    
29.                if(i<j){    
30.                    InputArray[i]=InputArray[j];    
31.                    i++;    
32.                }    
33.                while(i<j&&temp<InputArray[i])    
34.                    i++;    
35.                if(i<j){    
36.                    InputArray[j]=InputArray[i];    
37.                    j--;    
38.                }    
39.          }//while完，即第一盘排序      
40.          InputArray[i]=temp;//把temp值放到它该在的位置。      
41.           
42.          if(high<i) //注意，下标值      
43.               sort(InputArray,high,i-1);//对左端子数组递归      
44.          if(i<low)  //注意，下标值    
45.              sort(InputArray,i+1,low);//对右端子数组递归  ；对比上面例子，其实此时i和j是同一下标!!!!!!!!!!!!!   
46.      }  
47. }   
48.    

6.查找最大的不重复数（30分）

问题描述
如果一个数字十进制表达时，不存在连续两位相同，则称之为“不重复数”。例如，105、1234和12121都是“不重复数”，而11、100和1225不是。给定一个正整数A，返回大于A的最小“不重复数”。A小于100000
要求实现函数
int getNotRepeatNum(int iValue)
【输入】lValue：  给定的数字，返回大于该值的最小不重复数
【输出】无
【返回】大于iValue的最小不重复数
示例
输入：iValue =54
返回： 56
输入：iValue =10
返回： 12    
输入：iValue =98
返回： 101
输入：iValue =21099
返回： 21201

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3. import java.util.Scanner;  
4.   /*     
5.   * @author sheepmu 
6.   */   
7. public class HWCompetition {  
8.      public static void main(String[] args){  
9.          Scanner input=new Scanner(System.in);  
10.          int a=input.nextInt();  
11.          System.out.println("输入的数字为---->"+a) ;  
12.          HWCompetition hwc=new HWCompetition();  
13.          int result=hwc.getNotRepeatNum(a);  
14.          System.out.println("返回的大于"+a+"的最小不重复数---->"+result) ;  
15.      }         
16.      int getNotRepeatNum(  int iValue){   
17.          int i=0;  
18.          for(i=iValue+1 ;i<100000;i++){  
19.              if(!isRepeatNum(i)){     
20.                  break;//!!!不然要白白运行好多好多次  
21.              }  
22.          }   
23.             return i;          
24.      }  
25.       public boolean isRepeatNum(int a){  
26.           String str=a+"";  
27.           char[] cs=str.toCharArray();  
28.           int len=cs.length;  
29.           for(int i=0;i<len-1;i++){//因为后面要i+1,如果是i<len就要下标越界。  
30.                   if(cs[i]==cs[i+1])   
31.                       return true;       
32.           }  
33.           return false;  
34.       }  
35.        
36. }   
37.    

7. 扑克牌比较（30分）
问题描述：
在扑克中，牌的类型包括：A(1),2,3,4,5,6,7,8,9,T(10),J(11),Q(12),K(13),D（小鬼devilkin），B(大鬼Belial）。
请做一个简单的程序，输入两张牌的字符，比如"2"和"K"，判断牌的大小，规则如下：
B>D>2>A>K>Q>J>10....>3 最小的为3
判断规则：比较cFirstCard和cSecondCard，如果FirstCar大，那么返回1；如果相同，返回0；如果FirstCar小，返回-1。
要求实现函数：
int CompareOneCard(char cFirstCard, char cSecondCard)
【输入】 char cFirstCard：需要比较的第一张牌
char cSecondCard: 需要比较的第二张牌
注意：输入的为字符’A’，’2’，…，’9’，’T’，’J’，’Q’，’K’，’D’，’B’
【返回】  int类型：返回两张牌的比较结果
注意：不用考虑输入的合法性，这个由函数的使用者保证。输入的牌均为字符’1’,’2’…’9’,大写的’A’，’T’，’J’，’Q’，’K’，’D’，’B’。
举例：  
输入：’4’、’5’，返回：-1

输入：’6’、’6’，返回：0

1. package com.sheepmu.text;  
2.   /*     
3.   * @author sheepmu 
4.   */   
5. public class HWCompetition {  
6.      public static void main(String[] args){  
7.          char cFirstCard='5';  
8.          char  cSecondCard= '6';  
9.          HWCompetition hwc=new HWCompetition();  
10.          int result=hwc.CompareOneCard(cFirstCard,cSecondCard);  
11.           System.out.println("比较的结果"+result);  
12.      }         
13.      int CompareOneCard(char cFirstCard, char cSecondCard){   
14.             int iF=getReallN(cFirstCard);     
15.             System.out.println("iF--->"+ iF);  
16.             int iS=getReallN(cSecondCard);  
17.             System.out.println("iS--->"+ iS);  
18.             return iF>iS ?  1:  iF<iS? -1:0  ;//不需要添括号        
19.      }  
20.        
21.      int getReallN(char c){  
22.          int value=0;  
23.          switch(c){  
24.             case 'T':  
25.                 value=10;  
26.                 break;  
27.             case 'J':  
28.                 value=11;  
29.                 break;  
30.             case 'Q':  
31.                 value=12;  
32.                 break;  
33.             case 'K':  
34.                 value=13;  
35.                 break;  
36.             case 'A':  
37.                 value=14;  
38.                 break;  
39.             case '2':  
40.                 value=15;  
41.                 break;  
42.             case 'D':  
43.                 value=16;  
44.                 break;  
45.             case 'B':  
46.                 value=17;  
47.                 break;  
48.             case '3':               
49.             case '4':  
50.             case '5':  
51.             case '6':  
52.             case '7':  
53.             case '8':  
54.             case '9':  
55. //              value=c;             // 超级笨蛋错误!!!!! 若输入9，'9'=57!!!!字符9对于的值不是数字9而是该字符本身对于的值。  
56.                 value=Integer.parseInt(c+"") ;  
57.                 break;                
58.             }  
59.          return value;  
60.      }  
61.        
62. }   
63.    

8. 干瞪眼（30分）
问题描述：
在成都，流行一种扑克游戏叫“干瞪眼”。使用扑克牌，包括：A(1),2,3,4,5,6,7,8,9,T(10),J(11),Q(12),K(13)。
注意：10用T替换，这里暂时不考虑大鬼和小鬼。
两手牌的大小规则如下：
a)    单牌：4比3大，5比4大，只有两张牌刚好大一点时才能进行比较，比较顺序为：A>K>Q>J>T>9>8>7>6>5>4>3。
比如：6大于5，但是不能比4大，6和4不能比较。单牌2属于特殊牌，他可以和其他所有普通单牌比较，并且是最大的。
请注意3，他不能大于任何牌。
b)    对子：即两张牌的点数相同，规则和单牌相似，也需要进行类似处理。两个2是特殊对子，可以大于所有的其他对子。
注意：对子和单牌是不能进行比较的。
c)    炸弹：3个点数相同的牌。炸弹可以大于任何单张和对子，炸弹之间的比较不用像单牌和对子那样，只能大一点才能比较。
只要满足：222>AAA>KKK>QQQ>JJJ>TTT>…>333的规则的即可。即222是最大的，AAA可以大于KKK，也可以大于333。
d)    其他规则暂不考虑实现
现在请你实现一个程序，自动判断两手牌的大小，注意：输入的牌只会出现3种类型：单张，对子，炸弹。张数最多3张。
不会出现2个单牌。比如”25”，也不会出现一个对子加单牌，比如”334”等，类似输入异常你可以不用考虑。
但是pFirstCards为单牌，pSecondCards为对子，类似的组合输入是合法的。
要求实现函数：
int CompareCards(char *pFirstCards, char *pSecondCards)
【输入】  char *pFirstCards：需要比较的第一手牌
char *pSecondCards：需要比较的第二手牌
【返回】  int 类型，返回值说明：
如果pFirstCards和 pSecondCards无法比较，比如”3”和”6”；”55”和”6”等，返回0。
如果pFirstCards大于pSecondCards，返回1。
如果pFirstCards等于 pSecondCards，返回2。
如果pFirstCards小于 pSecondCards，返回3。
注意：不用考虑输入的合法性，这个由函数的使用者保证。输入的牌均为字符’1’,’2’..’9’,大写的’A’，’T’，’J’，’Q’，’K’。
示例
输入： “77”、 “33”，返回：0

输入： “77”、 “77”，返回：2

思路：1. 1vs2  or  2vs1          此情况只需判断长度即可得出结果，无需后续比较

             2. 1vs1  or  2 vs2        同一种比较方式

             3. 3vs3      和情况2不同的比较方式

             4. 3 vs 非3    or    非3vs3

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.      public static void main(String[] args){  
8.          String pFirstCards="QQ";  
9.          String pSecondCards="444";  
10.          HWCompetition hwc=new HWCompetition();  
11.          int result=hwc.CompareCards(pFirstCards,pSecondCards);  
12.           System.out.println("比较的结果"+result);  
13.      }         
14.      int CompareCards( String pFirstCards, String pSecondCards){   
15.          int len1=pFirstCards.length();  
16.          int len2=pSecondCards.length();  
17.          if((len1==1&&len2==2)||(len1==2&&len2==1))// 1vs2，无法比较。为提供效率，能先搞定的搞定，这种情况就不需要执行后面的了。  
18.              return 0;     
19.          int[] is1=getReallNs(pFirstCards);  
20.          int[] is2=getReallNs(pSecondCards);  
21. //       System.out.println(Arrays.toString(is1));//[12, 12]  
22. //       System.out.println(Arrays.toString(is2));//[4, 4, 4]  
23.          if((len1==1&&len2==1)||(len1==2&&len2==2)){//1vs1 或者2vs2,比较方式是一样的。其实不用天括号  
24.              if(Math.abs(is1[0]-is2[0])==1)  //有题目知，长度为2肯定是对子情况  
25.                  return is1[0]-is2[0]>0? 1:3;  
26.             else if(is1[0]==is2[0])    
27.                 return 2;  
28.             else  
29.                 return 0;  
30.          }  
31.          if(len1==3&&len2==3) //炸弹不可能相等，因为一副牌没有6个一样的。  
32.              return is1[0]>is1[0]? 1:3;         
33.          if(len1==3&&len2<3||len1<3&&len2==3)   
34.             return  len1==3? 1:3;      
35.          return 0;//其实测试用例应该永远都不会执行这一句。  
36.      }  
37.      int[] getReallNs(String s){  
38.          int len=s.length();  
39.          int[] cs =new int[len];  
40.          for(int i=0;i<len;i++){  
41.              cs[i]=getReallN(s.charAt(i));  
42.          }     
43.          return cs;  
44.      }  
45.        
46.      int getReallN(char c){  
47.          int value=0;  
48.          switch(c){  
49.             case 'T':  
50.                 value=10;  
51.                 break;  
52.             case 'J':  
53.                 value=11;  
54.                 break;  
55.             case 'Q':  
56.                 value=12;  
57.                 break;  
58.             case 'K':  
59.                 value=13;  
60.                 break;  
61.             case 'A':  
62.                 value=14;  
63.                 break;  
64.             case '2':  
65.                 value=15;  
66.                 break;  
67.             case '3':               
68.             case '4':  
69.             case '5':  
70.             case '6':  
71.             case '7':  
72.             case '8':  
73.             case '9':  
74. //              value=c;             // 超级笨蛋错误!!!!! 若输入9，'9'=57!!!!字符9对于的值不是数字9而是该字符本身对于的值。  
75.                 value=Integer.parseInt(c+"") ;  
76.                 break;                
77.             }  
78.          return value;  
79.      }  
80.        
81. }   
82.    

9. 矩阵转置（20分） 
问题描述： 
将一个N*N矩阵的行列互换。 · 
要求实现函数： 
public String matrixTranspose (String inArr, int n) 
【输入】inArr：       输入的字符矩阵 
    n：          N*N矩阵的行数 
【返回】转置后的字符矩阵 注： 
输入输出的矩阵都是以一维形式保存的二维数组，比如输入为"1,2,3,4,5,6,7,8,9"，实际上表示如下3*3的矩阵： 
1,2,3,4,5,6,7,8,9  
示例 

输入InArr ="1,2,3,4,5,6,7,8,9"，n=3 返回："1,4,7,2,5,8,3,6,9" 

注：笔者人为的把题目稍微添成了每项为字符串而不是字符。字符更简单，字符串时注意截取时，13不是1,3

方法一：被题目忽悠的用了矩阵。就当是熟悉下二维数组嘛

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.       public static void main(String[] args){  
8.           String inarr="1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16";  
9.           int n=4;  
10.           System.out.println("inarr---->"+inarr);  
11.           HWCompetition hw=new HWCompetition();  
12.           String result=hw.matrixTranspose(inarr,n);  
13.           System.out.println("result---->"+result);  
14.       }  
15.       public String matrixTranspose(String inarr,int n){//要把字符串中的逗号去掉,不然逗号也是string的一个下标值了,输出时再加上就是咯  
16.           String[] ss=inarr.split(",");  
17.           String[][] css=new String[n][n];  
18.           int k=0;  
19.           for(int i=0;i<n;i++){//字符串转换为二维数组  
20.               for(int j=0;j<n;j++){  
21.                   css[i][j]=ss[k];  
22.                   k++;  
23.               }  
24.           }  
25.           StringBuffer sb=new StringBuffer();  
26.           for(int i=0;i<n;i++){// 二维数组逆置  
27.               for(int j=0;j<n;j++){  
28.                  sb.append(css[j][i]+",");//尾巴多了一个，  
29.               }  
30.           }  
31.           return sb.substring(0, sb.length()-1);  
32.       }  
33. }      
34.        
35.    
36.    

方法二：更简单，完全不需矩阵。

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.       public static void main(String[] args){  
8.           String inarr="1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16";  
9.           int n=4;  
10.           System.out.println("inarr---->"+inarr);  
11.           HWCompetition hw=new HWCompetition();  
12.           String result=hw.matrixTranspose(inarr,n);  
13.           System.out.println("result---->"+result);  
14.       }  
15.       public String matrixTranspose(String inarr,int n){//要把字符串中的逗号去掉,不然逗号也是string的一个下标值了,输出时再加上就是咯         
16.           String[] ss=inarr.split(",");  
17.           StringBuffer sb=new StringBuffer();  
18.           for(int i=0;i<n;i++){ //对于题目例子： 需要的下标顺序是 036147258  
19.               for(int j=i;j<ss.length;j+=n){  
20.                   sb.append(ss[j]+",");//尾巴多了逗号  
21.               }  
22.           }  
23.           return sb.substring(0, sb.length()-1);//去掉尾巴逗号  
24.       }  
25. }      
26.        
27.    
28.    

10.路灯（20分）

某省会城市街道纵横交错，为了监控路灯的运行状况，每条街道使用一个数字字符串标识该街道上所有路灯的运行状况。
假设路灯只有如下3种状态（分别用数字0, 1, 2标识，一盏路灯只对应其中一种状态）：
0 标识路灯熄灭；
1 标识路灯开启；
2 标识路灯故障；
请根据输入的字符串，找出该街道上连续的处于相同状态的路灯的最大个数。若两种状态的路灯数量相同，则返回最先出现的路灯状态。
输入
街道上连续的路灯组成的状态字符串。字符串中只包含数字，每个路灯的状态为0，1，2中的一种状态。如“1101”代表4盏路灯，第3盏路灯为熄灭状态，其它3盏为开启状态。
输出
连续为相同状态的路灯的最大数量；
上述路灯的状态； 
要求：先输出数量，再输出状态，两个整数间采用一个空格间隔。如输出：
53 2
样例输入
112200111
样例输出
3 1

1. package com.sheepmu.text;  
2. import java.util.Arrays;  
3.   /*     
4.   * @author sheepmu 
5.   */   
6. public class HWCompetition {  
7.       public static void main(String[] args){  
8.           String s="112001110";//这类题一定要注意最后全部相同的情况，即没有再出现与之不同的，不然很容易死循环。  
9.           System.out.println("inarr---->"+s);  
10.           HWCompetition hw=new HWCompetition();  
11.           String result=hw.ludeng(s);  
12.           System.out.println("题目结果---->"+result);  
13.       }  
14.       public String ludeng(String s){//要把字符串中的逗号去掉,不然逗号也是string的一个下标值了,输出时再加上就是咯          
15.           char[] as=s.toCharArray();  
16.           int len=as.length;  
17.           int maxc=1;  
18. //        int mubiaobindex=0;//不要制造多余变量  
19. //        int mubiaovalue=as[0];  
20.           int bindex=0;//如果需要返回最大连续的第一个下标，如此时的6；若题目有此需求：则设置两个变量：“每部分”的次数+首次出现的下标。  
21.           char value=as[0];//若题目需要返回最大长度部分的值即本题状态的1  
22.           for(int i=0;i<len-1;  ){  
23.               int count=1;//每次外层循环是把count令为1,开始新的计数  
24.               bindex=i;  
25.               value=as[i];  
26.               for(int j=i+1;j<len;j++){  
27.                   if(as[i]!=as[j]){  
28.                       i=j;  
29.                       break;  
30.                   }  
31.                   else{  
32.                       i++;//!!!!!!!!!!!如果后面没有出现不同的；如果不加这一句，外层循环会一直执行。  
33.                       count++;  
34.                   }                     
35.               }  
36.                 
37.               if(count>maxc){  
38.                   maxc=count;  
39. //                mubiaobindex=bindex;  
40. //                mubiaovalue=value;  
41.                   System.out.println("maxc--->"+maxc+"     起始下标---->"+bindex+"    状态---->"+value);  
42.               }  
43.           }  
44.          StringBuffer sb=new StringBuffer();  
45.          return sb.append(maxc+" ").append(value).toString();  
46.            
47.       }  
48. }      
49.        
50.    
51.