一道编程题：

任意输入一组数据，不超过九个数据，如：
"9999999223","9999999125","9999999123","9999999124","9999999321","9999999322","9999999121"
用程序实现后的成一个字符串如下：

"9999999121,9999999123-125,9999999223,9999999321-322"

将其连续的数据用“9999999123-125”显示，没有连续的单个显示“9999999121,9999999223”

[ 本帖最后由 ωǒ伈怺恆 于 2007-7-30 15:03 编辑 ]

没人顶.不出答案了...

顶````````````

什么编程，是C语言，还是机械编程？

用什么语言实现都行.

不懂编程滴.把算法写出来也行..

谁能把答案写出来.

我送1000东安币.....

真的假的 你等到

引用:

原帖由 七月飞雪 于 2007-7-30 14:06 发表
真的假的 你等到

当然真滴..

以后我会搞更多的题出来..更多的东安币来发奖..


大家加油..

这1000东安币看来只有给我自己了.
下面是用JAVA实现的代码
private String ticketNoDispose(Vector ticketNoValue) {
  List list = new ArrayList();

  for (int i = 0; i < ticketNoValue.size(); i++) {
   String sValue = (String)ticketNoValue.get(i);
   sValue = sValue.replaceAll("-","");
   list.add(new Long(sValue));
  }

  Collections.sort(list);//用向量的特性将LIST类型变量排序

  int icount = 0;
  Vector v = new Vector();
  String ss = "";
  for (int i = 0; i < list.size(); i++) {
   Long value = (Long)list.get(i);
   long lvalue = value.longValue();
   if (list.contains(new Long(lvalue + 1))) {//从数组里面第一个数据开始,与下一个数据进行比较,如果下一个数等于当前的数加1,则这个数与下一个数是连续的
    if (icount == 0) {
     v.add(new Long(lvalue));
     if(i == 0)
      ss += String.valueOf(lvalue);
     else
      ss += ","+String.valueOf(lvalue);
    }
    v.add(new Long(lvalue + 1));
    icount++;
   } else {
    if(icount == 0) {
     v.add(new Long(lvalue));
     if(i == 0)
      ss += String.valueOf(lvalue);
     else
      ss += ","+String.valueOf(lvalue);
    } else {
     String sss = String.valueOf(lvalue);
     ss += "-"+ sss.substring(sss.length()-3);
    }
    icount = 0;
   }
  }
  return ss;
}

我还没来啊`
` ` 哎``

引用:

原帖由 °.吢冇所薆. 于 2007-8-6 17:06 发表
我还没来啊`
` ` 哎``

哈哈..

太迟了...太迟了..

哈哈 偶来晚拉！这个题用C实现也不难哦！

我也来凑凑热闹，同样用java实现，不但可以处理数字字符串还可以处理字符字符串 代码如下：package mypack;
import java.util.List;
import java.util.ArrayList;
public class test {

public static String[] compareTO(String[] str) {
  String tmp = null;
  int result = 0;
  for(int i=0;i<str.length-1;i++) {
   for(int j=i+1;j<str.length;j++) {
    result = compare(str,str[j]);
    if(result>0&&result!=3) {
     tmp = str;
     str = str[j];
     str[j] = tmp;
    }
   }
  }
  return str;
}

public static String[] substring(String[] str,int index) {
  String[] tmp = new String[str.length-index];
  for(int i=0;i<str.length-index;i++) {
   tmp = str[i+index];
  }
  return tmp;
}

public static String[] parse(String[] str) {
  List l = new ArrayList();
  int a = 0;
  while(a<str.length) {
   String strtmp;
   int tmp = recursion(substring(str,a));
   if(tmp!=0) {
    if(tmp==1)
     strtmp = str[a] + "~" + str[a+1].substring(str[a+1].length()-1);
    else
     strtmp = str[a] + "~" + str[a+tmp].substring(str[a+tmp].length()-1);
    a += tmp;
   }else
    strtmp = str[a];
   ++a;
   l.add(strtmp);
  }
  String[] result = new String[l.size()];
  for(int i=0;i<l.size();i++) {
   result = (String)l.get(i);
  }
  return result;
}

public static int compare(char a,char b) {
  return b - a;
}

public static int compare(String a,String b) {
  int cont = a.length();
  int cont1 = b.length();
  char[] charvalueA = a.toCharArray();
  char[] charvalueB = b.toCharArray();
  if(cont>cont1)
   return 1;
  if(cont<cont1)
   return -1;
  if(cont==cont1) {
   for(int i=0;i<cont;i++) {
    int result = compare(charvalueA,charvalueB);
    if(i!=cont-1) {
     if(result>0)
      return 2;
     else if(result<0)
      return -2;
    } else {
     if(result==1)
      return 3;
     else if(result==0)
      return 0;
     else if(result>0)
      return -1;
     else if(result<0)
      return 1;
    }
   }
  }
  return -1;
}

public static int recursion(String[] str) {
  int n = 0;
  int k = 1;
  if(str.length>1) {
   while(compare(str[n],str[k])==3) {
    n++;
    k++;
       if(k==str.length)
        return n;
   }
   
  } else {
   return n;
  }
  return n;
}
public static void main(String[] args) {
  String[] str = args;
  str = test.compareTO(str);
  str = test.parse(str);
  for(int i=0;i<str.length;i++) {
   System.out.println(str);
  }
}
}



输入字符串参数：777771 777772 777773 77774 77755 77775 77756 77776 777777 77778 777779 55555555555555555555 a b c d e f g h
输出结果为：
a-h
77774-6
77778
77755-6
777771-3
777777
777779
55555555555555555555

[ 本帖最后由 jjaps 于 2007-9-5 14:11 编辑 ]

哈哈哈哈..楼上滴.以后早点现身哈..

C++的容器也能实现吧