public   class  Ranges {
     private  ArrayList<Range> ranges =  new  ArrayList<Range>();

     public   void  AddValue( int  i) {
         int  index = Collections.binarySearch(ranges, i);
         if  (index <  0 ) {
             int  insertPosition = -index -  1 ;

            Range prevRange = getRange(insertPosition -  1 );
             boolean  isExpandPrev = prevRange !=  null  && i - prevRange.to ==  1 ;
             if  (isExpandPrev) {
                prevRange.to = i;
            }

            Range nextRange = getRange(insertPosition);
             boolean  isExpandNext = nextRange !=  null  && nextRange.from - i ==  1 ;
             if  (isExpandNext) {
                nextRange.from = i;
            }

             if  (!isExpandNext && !isExpandPrev) {
                ranges.add(insertPosition,  new  Range(i, i));
            }  else   if  (isExpandNext && isExpandPrev) {
                prevRange.to = nextRange.to;
                ranges.remove(insertPosition);
            }
        }
    }

     public  String toString() {
        StringBuilder sb =  new  StringBuilder();
         for  (Range r : ranges) {
            sb.append(r.toString()).append(", ");
        }
         if  (sb.length() >  0 ) {
             return  sb.substring( 0 , sb.length() - ", ".length());
        }
         return  "";
    }

     private  Range getRange( int  index) {
         return  index >=  0  && index < ranges.size() ? ranges.get(index) :  null ;
    }

     private   static   class  Range  implements  Comparable<Integer> {
         private   int  from;
         private   int  to;

         public  Range( int  from,  int  to) {
             this .to = to;
             this .from = from;
        }

         public   boolean  contains( int  i) {
             return  from <= i && to >= i;
        }

         public   int  compareTo(Integer integer) {
             if  (from > integer) {
                 return   1 ;
            }
             if  (to < integer) {
                 return  - 1 ;
            }
             return   0 ;
        }

         public  String toString() {
             return  from + (from == to ? "" : "-" + to);
        }
    }
}

 public  String toFormattedString( int [] integers) {
     if  (integers.length ==  0 ) {
         return  "";
    }
    Arrays.sort(integers);
     int  last = integers[ 0 ];
    StringBuilder sb =  new  StringBuilder(Integer.toString(last));
     for  ( int  current : integers) {
         if  (current != last) {
            sb.append("-").append(last -  1 ).append(", ").append(current);
        }
        last = current +  1 ;
    }
     return  sb.toString();
}

(define (get-pairs numbers)
  (define (get-pair start current numbers)
    (cond ((null? numbers) (list (list start current)))
          (else (let ((next (+ current 1)))  
                  (cond ((= next (car numbers)) (get-pair start next (cdr numbers)))
                        (else (cons (list start current) (get-pairs numbers))))))))
  (cond ((null? numbers) ())
        (else (let ((start (car numbers)))
                (get-pair start start (cdr numbers)))))) 

(get-pairs '(1 2 3 5 7 10 11 12 16 17 18 19))
 
;output: ((1 3) (5 5) (7 7) (10 12) (16 19))