fun toRangeList([]) = []
  | toRangeList([x]) = [(x,x)]
  | toRangeList(x::xs) = let
	val y::ys = toRangeList(xs)
	val (f,t) = y
    in
	if x = (f-1) then
	    (x,t)::ys
	else
	    (x,x)::y::ys
    end;
 
fun toIntList(st) = let
    val stlist = String.tokens (fn c => (c = #" ")) st
    fun f([]) = []
      | f(x::xs) = let
	    val SOME x = Int.fromString(x)
	in 
	    x::f(xs) 
	end
in
    f(stlist)
end;
 
fun tupleToPrettyString(x,y) = 
    if x=y then 
	Int.toString(x)
    else 
	Int.toString(x) ^ "-" ^ Int.toString(y);
 
fun toPrettyString([]) = ""
  | toPrettyString([(x,y)]) = tupleToPrettyString(x,y)
  | toPrettyString((x,y)::xs) = let
	val st = toPrettyString(xs)
    in
	tupleToPrettyString(x,y) ^ " " ^ st
    end;
 
fun home(st) = let 
    val ilist = toIntList(st)
    val rlist = toRangeList(ilist)
in
    toPrettyString(rlist)
end;

def range_list(l):
    x,xs = l[0],l[1:]
    if not x:
        return []
    elif not xs:
        return [(x,x)]
    else:
        l2 = range_list(xs)
        y,ys = l2[0],l2[1:]
        f,t = y
        if x == f-1:
            return [(x,t)]+ys
        else:
            return [(x,x),y]+ys
 
def home1(s):
    ilist = map(int,s.split(' '))
    rlist = range_list(ilist)
    def string_range(x):
        a,b = x
        if a == b:
            return '%d' % a
        return '%d-%d' % (a,b)
    slist = map(string_range,rlist)
    return ' '.join(slist)
 
p1 = "1 2 4 5 6 8 10"
p2 = "3 5 7 101 102 103"
 
print home1(p1)
print home1(p2)

solve:: [Int] -> [(Int,Int)]
solve  (x:xs)        = solve' xs (x,x) []
 
solve':: [Int] -> (Int,Int) -> [(Int,Int)]
      -> [(Int,Int)]
 
solve' [] (x,y) z    = reverse  ((x,y) : z)
solve' (x:xs) (x',y') z
       | x == (y' + 1) = solve' xs (x', x) z
       | otherwise     = solve' xs (x , x) ((x', y'):z)

*Main> solve [1,2,3,4,7,9,11,12,14,15]
[(1,4),(7,7),(9,9),(11,12),(14,15)]

type r = {s: int; e: int};;
 
let find_range seq = 
  let merge_range a n = match a with      
      x::xs when x.e + 1 == n -> {s = x.s; e = n}::xs
    | [] | _ -> {s = n; e = n}::a
  in
    List.rev (List.fold_left merge_range [] seq)
;;
 
let pretty seq = 
  let pretty_r r_ = 
    if r_.s == r_.e then
      string_of_int r_.s
    else
      (string_of_int r_.s) ^ "-" ^ (string_of_int r_.e)
  in
  let rec join seq = match seq with 
      x::xs -> 
	if List.length xs == 0 then 
	  x 
	else 
	  x ^ " " ^ (join xs)
    | _ -> ""
  in
    join (List.map pretty_r seq)
;;
 
let _ = print_endline (pretty (find_range [1;2;3;5;6;10;14;15;16]));;

>
class GroupRange {
	static int[] splitToInt(String str)
	{
		String [] strArray;
		strArray = str.split(" ");
		int [] intArray = new int[strArray.length];
		int i = 0;
		for(String s:strArray)
		{
			intArray[i] = Integer.parseInt(s);
			i++;
		}
		return intArray;
	}
	static String solve(String str)
	{
		StringBuffer output = new StringBuffer();
		int[] intArray = splitToInt(str);
		int start,end,a,b;
		start = 0;
		end   = 0;
		a = 0;
		b = 1;
		output.append(intArray[a]);
 
		while(b < intArray.length)
		{
			if ((intArray[b]-intArray[a]) > 1)
			{
				if ((end - start)>0)
				{
					output.append("-");
					output.append(intArray[end]);
				}
				output.append(" ");
				output.append(intArray[b]);
				a = b;
				b++;
				start = end = a;
			}else
			if ((intArray[b]-intArray[a]) == 1)
			{
				b++;
				a++;
				end++;
			}
			else b++;
		}
		if((end-start)>0)
		{
			output.append("-");
			output.append(intArray[end]);
		}
		return output.toString();
	}
	public static void main(String[] args)
	{
				System.out.println(solve("1 2 4 5 6 8 10"));
				System.out.println(solve("3 5 7 101 102 103"));
	}
 
}
</blockcode>

def solve(str) {
  def a = str.split(/\s+/).collect { Integer.valueOf(it) }
 
  def result = []
  def idx = (0..<(a.size()-1)).grep{ a[it].next() != a[it+1] }
  [*idx, a.size()-1].inject(0) { from, to ->
    result << (a[from]..a[to])
    to.next()
  }
 
  result.collect{ (it.from - it.to)? "$it.from-$it.to" : it.from }.join(' ')
}
 
assert "1-2 4-6 8 10" == solve("1 2 4 5 6 8 10") 
assert "3 5 7 101-103" == solve("3 5 7 101 102 103")

>
<?
$b = explode(" ", $input); // ระเบิด string เป็น array
$out=$b[0];
$flag=TRUE; //flag ตัวนี้เอาไว้บอกว่ามี serie ต่อหรือไม่ ผมสลับ TRUE กับ FALSE เพื่อความง่ายในการใช้ IF
for($i=0;$i<=count($b);$i++)
{
	if (($b[$i+1]-$b[$i])==1 && ($flag))
	{
		$out=$out."-";
		$flag=!$flag;
	}
	elseif ($b[$i+1]-$b[$i]>1)
	{
		if($flag)
			$out=$out." ".$b[$i+1];
		else
		{
			$flag=!$flag;
			$out=$out.$b[$i]." ".$b[$i+1];
		}
	}
}
if (!$flag)
	$out=$out.$b[count($b)-1];
echo $out;
?></blockcode>
โดย $out เป็น output ครับ กระทู้ตั้งกันต้นปี ตอบเอาปลายปี แหะๆ

def home(input):
	output=''
	for i in map(int,input.split()):
		output=(output+'%d, '%i).replace('%d, '%(i-1),'%d-'%(i-1)).replace('-%d-'%(i-1),'-')
	return output[:-2]+'.'
print home("1 2 4 5 6 8 10")
print home("3 5 7 101 102 103")

str = "1 2 4 5 6 8 10"
def home str
     a = str.split
    (0...a.length).each do |n|
      previous_result = a[n].to_i - a[n-1].to_i == 1 ? true:false if n != 0
      result = a[n+1].to_i - a[n].to_i == 1 ? true:false
      next_result = a[n+2].to_i - a[n+1].to_i == 1 ? true:false if n+2 != a.length
      first_true = previous_result == false ? true:false if result and n != 0
      last_true = next_result == false ? true:false if result and n != a.length
      print "#{a[0]}-" if result and n == 0
      print "#{a[n]}-" if first_true
      if last_true then
         print "#{a[n+1]} "  
         @dup = a[n+1] 
      end
      print " #{a[n]} " if result == false and a[n] != @dup 
    end
end
home str

from itertools import *
 
prob = "1 2 4 5 6 8 10"
 
prob_int_ary = map(int,  prob.split(' '))
groups = groupby(enumerate(prob_int_ary), lambda (i,x): i-x)
 
def pretty_result(iter):
  for tmp in iter:
    if (tmp[0] == tmp[1]):
      yield str(tmp[0])
    else:
      yield "%s-%s" % (tmp[0], tmp[1])
 
print ' '.join(pretty_result(map(lambda l: (l[0][1], l[-1][1]), map(lambda(k,g): list(g), groups))))