题目一：通过键盘输入一串小写字母(a~z)组成的字符串。
          请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
  比如字符串“abacacde”过滤结果为“abcde”。

  要求实现函数：void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);

  【输入】 pInputStr：  输入字符串
              lInputLen：  输入字符串长度        
  【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；

  【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出

  示例
  输入：“deefd”        输出：“def”
  输入：“afafafaf”     输出：“af”
  输入：“pppppppp”     输出：“p”

  main函数已经隐藏，这里保留给用户的测试入口，在这里测试你的实现函数，可以调用printf打印输出
  当前你可以使用其他方法测试，只要保证最终程序能正确执行即可，该函数实现可以任意修改，
  但是不要改变函数原型。一定要保证编译运行不受影响。
  -------------------------------------------------------------------------------------------*/
  /*题二：题目描述（40分）：
  通过键盘输入一串小写字母(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”
     -------------------------------------------------------------------public class Test {
        static void stringFilter( char InputStr[], long len, char OutputStr[]){
                int[] a= new int[26];
                int num=0;
                int j=0;//OutputStr[]计数
                for(int i=0;i<len;i++){
                        num = InputStr-'a';
                        if(a[num]==0){//没出现过
                                OutputStr[j]=InputStr;
                                j++;
                                a[num]=1;
                        }
                }
        }
        static void stringZip( char InputStr[], long len, char OutputStr[]){
                char temp=' ';
                int num=1;
                int point=0;
                for(int i=0;i<len;i++){
                        if(InputStr==temp){
                                num++;
                        }else{
                                if(num!=1){
                                        OutputStr[point++]=(char)(num+'0');
                                        num=1;
                                }                               
                                OutputStr[point++]=temp;
                                temp=InputStr;
                        }
                }               
        }
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                char [] test={'a','a','a','c','b','b','b','a','a','c','a','d','d','d','c','d','e'};
                long len=test.length;
                char [] res = new char[(int) len];
                stringFilter(test,len,res);
                int j=res.length;
                for(int i=0;i<j;i++){
                        if(res!='\0'){
                                System.out.print(res);
                        }else
                                break;                       
                }
               
                char[] res2=new char[(int) (2*len)];
                stringZip(test,len,res2);
                for(int i=0;i<2*len;i++){
                        if(res2!='\0'){
                                System.out.print(res2);
                        }else
                                break;
                }
        }


}

1. 题目一的解答：
   
2. public class test
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 String str  = "abacacde";
   
7.                 showFilterString(str);
   
8.                
   
9.         }
   
10.        
    
11.         public static void showFilterString(String str)
    
12.         {
    
13.                 StringBuilder builder = new StringBuilder();
    
14.                 List<Character> list = new ArrayList<Character>();
    
15.                 char[] chs = str.toCharArray();
    
16.                
    
17.                 for(int i=0; i<chs.length; i++)
    
18.                 {
    
19.                         if(!list.contains(chs[i]))
    
20.                         {
    
21.                                 builder.append(chs[i]);
    
22.                                 list.add(chs[i]);
    
23.                         }
    
24.                 }
    
25.                 System.out.println(builder.toString());
    
26.         }
    
27. }

复制代码

1. 第二题解答：
   
2. public class test
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                
   
7.                 System.out.println(stringZip("aabddd"));
   
8. 
   
9.         }
   
10. 
    
11.         public static String stringZip(String pInputStr)
    
12.         {
    
13.        
    
14.                 List<Character> list = new ArrayList<Character>();
    
15.                 List<Integer> numList = new ArrayList<Integer>();
    
16.                 char[] chs = pInputStr.toCharArray();
    
17.                 int count = 1;
    
18.                 int i;
    
19.                 for(i=0; i<(chs.length-1); i++)
    
20.                 {
    
21.                         if(chs[i] == chs[i+1])
    
22.                         {
    
23.                                 count++;     //若前一个字符与后一个字符相等，曾递增一次
    
24.                         }
    
25.                         else if(chs[i] != chs[i+1])
    
26.                         {
    
27.                                 list.add(chs[i]);
    
28.                                 numList.add(count);
    
29.                                 count = 1;
    
30.                         }
    
31.                 }
    
32.                 //最后还要比较最后一个字符是否与前一个字符相等的两种情况
    
33.                 if(chs[chs.length-2] != chs[chs.length - 1])
    
34.                 {
    
35.                         list.add(chs[chs.length-1]);
    
36.                         numList.add(1);
    
37.                 }
    
38.                 else
    
39.                 {
    
40.                         list.add(chs[i]);
    
41.                         numList.add(count);
    
42.                 }
    
43.                 char[] chss = new char[list.size()*2];  //
    
44.                 System.out.println(numList);
    
45.                 System.out.println(list);
    
46.                 for(i=0; i<list.size(); i++)
    
47.                 {
    
48.                         if(numList.get(i) == 1)  //如果不连续，则为一个计数为一个空格
    
49.                                 chss[2*i] = ' ';
    
50.                         else
    
51.                         {
    
52.                                 chss[2*i] = (char)(numList.get(i)+'0');  //否则字符的连续的计数值
    
53.                         }
    
54.                         chss[2*i+1] = list.get(i);  //字符
    
55.                 }
    
56.                 return deleteSpace(String.valueOf(chss));
    
57.         }
    
58.        
    
59.         public static String deleteSpace(String str) //去除字符串中的空格
    
60.         {
    
61.                 char[] chs = str.toCharArray();
    
62.                 int len = 0;
    
63.                 for(int i=0; i<chs.length; i++)
    
64.                 {
    
65.                         if(chs[i] != ' ')
    
66.                         {
    
67.                                 len++;
    
68.                         }
    
69.                 }
    
70.                 char[] dest = new char[len];
    
71.                 int j=0;
    
72.                 for(int i=0; i<chs.length; i++)
    
73.                 {
    
74.                         if(chs[i] != ' ')
    
75.                         {
    
76.                                 dest[j++] = chs[i];
    
77.                         }
    
78.                 }
    
79.                
    
80.                 return String.valueOf(dest);
    
81.         }
    
82. }

复制代码