Condense the List of Numbers

1. A number in this problem is an integer. We assume it is representable as an int in the PL.
2. A range is written as m-n. This is three tokens: a number, a hyphen, and another number. The first number m is expected to be less than n. We will ignore it otherwise.
3. A single item appears as one number token, x. This is equivalent to x-x.
4. We allow the numbers to be negative.

1. We are not permitting an empty list. We do not expect the ranges or single items to appear in any particular order.

1. Same as input format.

1. The output produced should represent the same set of numbers represented by the input. The output is required to be the shortest possible. We take this to mean the length of the output viewed as a sequence of tokens is to be minimized, and not, e.g., that all blanks are to be eliminated.
2. The real need is clearly for a condensation of the list given in some internal data structure format, rather than a textually presented list of numbers.

1. A range m-n denotes the set range(m, n) which is defined as {z st m <= z <= n}. A single-item x denotes the singleton set { x }.
   1. setofoneitem(ars) ::= range(m, n), if ars is of the form <number m>, hyphen, <number n>. The angular brackets are meta characters.
   2. setofoneitem(ars) ::= { x } , if ars is of the form <number x>.
2. The list is a comma-separated sequence of ranges and single items:
   1. single-item ::= number
   2. range ::= number hyphen number
   3. rs ::= range | single-item
   4. list ::= rs | list comma rs
   5. external-list ::= list period
   6. This is the grammar describing our input (and also output). Written in "extended" BNF. It assumes "standard" tokens for numbers, hyphen, and period.
   7. Read an introduction to Grammars
3. A list denotes the union of the sets denoted by the rs items it contains.
   1. setoflist( [ars period] ) ::= setofoneitem(ars).
   2. setoflist(q + [comma, ars, period]) ::= setoflist(q) + setofoneitem(ars). Here q is a list as defined above. The plus denotes catenation in the lhs, and set union in the rhs.
4. The input "file" is expected to contain well-formed sequences that conform to the above external-list.

1. The list ol that the program generates should be equal, as a set, to the input list il.
   1. setoflist(ol) == setoflist(il).
2. The list ol is the shortest of all such lists:
   1. if a list ls != ol exists such that setoflist(ls) == setoflist(ol) then length(ls) > length(ol).
3. The items in the list ol are in the increasing order. That is, if r_i and r_j, i < j, are two ranges appearing in ol, then
   1. the second number of r_i is less than the first number of r_j, that is r_i.2 < r_j.1
   2. For the purpose of this rule, a single item x is to be taken as a range x-x.

1. The lists are sequences of parse-able entities: rs, comma, rs, comma, …, period. The rs itself is a sequence; it is a 3-long sequence if it is a range, a 1-long sequence if it is a single item.
   1. rslen(rs) ::= 3, if rs is a range
   2. rslen(rs) ::= 1, if rs is a single item
2. Unless we define length function carefully, we will permit a single item x to appear as a range x-x in the output list.
   1. length([rs, period]) ::= rslen(rs)
   2. length(q + [comma, rs, period]) ::= length(q) + 1 + rslen(rs) The plus denotes catenation in the lhs, and arithmetic plus in the rhs.

The pseudo code is shown in VHLL (very high level language).

var nums: set of numbers := {};

input-bgn(input-fnm);
repeat
  nums := nums + set-of(input-one-rs());
until input-next-token() == period;
input-end();

ol-initialize();
while nums != {} do
  var m: number := min-of(nums);
  var n: number := m;
  repeat
    nums := nums - {n};
    n := n + 1;
  until n not-in nums;
  ol-append(m, n-1);
od;
ol-period();

The nums is stored as a set data type provided by the VHLL design language. The first loop construct the set of numbers represented by the input. The second loop constructs the shortest list of ranges.

The design imagines the file content to be a stream of tokens: rsf is an imaginary stream variable conceptually denoting the tokens read so far; ytr is a similar var denoting the file content yet to be read.

A `filter' that accomplishes the above is, strictly speaking, a part of this and the next design. To save space, and to avoid discussing the well-known, we skip the design of such a lexical analyzer.

proc input-bgn(fnm: string)  // open/initialize input stream
  pre : file-exists(fnm)
  post: rsf ==  <>, ytr == file-content(fnm)

proc input-end()            // close/finalize input stream
  pre : is-defined(ytr)
  post: rsf ==  file-content(fnm), ytr ==  < >

func input-next-token(): token  // gives the next token from the input.
  pre : ytr !=  < >
  post: result ==  ytr0[1], rsf == rsf0 | result, ytr == ytr0[2 ..]

func input-one-rs(): rs
  // gives a representation of the next rs from the input.
  // The rs may be a range or a single item.
  pre : well-formed(ytr)
  post: exists i: {0, 1, 3} (
    result  ytr0[1 .. i], rsf == rsf0 | result, ytr == ytr0[i+1 ..],
    i == 0 - > ytr[1] ==  period,
    i == 1 - > ytr[1]  == comma,
    i == 3 - > result[2] == hyphen
    )

In the above, rsf0 used in the post stands for the value rsf had at the entry point. Similarly for ytr0.

func set-of(r): set of numbers
  // yields a set of numbers represented by the r.
  pre : is-rs(r)
  post: result == setofoneitem(r)

func min-of(A: set of number): number
  pre : A != {}
  post: result in A, for-all e: A (result <= e)

infix + (A: set of T, B: set of T)  == A union B.
infix - (A: set of T, B: set of T)  == A difference B.
infix not-in (e: T, A: set of T)  not (e member-of A)

proc ol-initialize() ... // for you to finish!
proc ol-append() ...
proc ol-period() ...

//* This concentrates on how to represent ranges. You will agree that it is a lower-level (i.e., closer to the machine) design than the first design. *//

The set is stored as an array of ranges. Each range is stored as a pair of, its lowest and highest, numbers. The array may or may not be kept sorted.

This code is not as obvious as that of the previous design. Also, even to understand it vaguely requires the detailed meaning of the primitive operations.

var numa: grow-shrink array of pairs of numbers : create-empty();

input-bgn(input-fnm);
repeat
  numa-append(numa, input-one-rs());
until input-next-token() == period;
input-end();

out-bgn()
while not numa-empty() do
  var x: number : numa-index-of-min();
  var m: number : numa[x].1;  // .1 means first of the pair
  var n: number : numa[x].2;  // .2 means second
  repeat
    n := n + 1;
  until numa-ix-delete(n-1) ==  0;
  out-append(m, n-1);
od;
out-end();

A filter that accomplishes the lexical analysis is a part of this and the previous design.

proc out-bgn()
  pre : true
  post: out == ""

proc out-append(x, y: number)
  pre : x  <= y
  post: exists s, t: string (
    out  out0 | s | t,
    x == y - > t  itoa(x),
    x  < y - > t  itoa(x) | "-" | itoa(y),
    s == if out0 ==  "" then "" else "," fi
  )

proc numa-append(m, n: number)
  pre : true
  post: numa == if m  <= n then  numa0 |  <m, n > else numa0 fi

proc numa-ix-delete(b: number): number
  // function with side-effect on numa[]
  // if numa has a range that includes b delete that range, and
  // return the index of the deletion; otherwise return 0
  pre : true
  post: (result == 0) && not-in-numa(b) && (numa == numa0)
    or (
      (numa0[result].1  < b) && (b  < numa0[result])
      && (numa == numa0[1..result-1] | numa0[result+1..]))

aux func not-in-numa(b: number): boolean is
  not exists i: 1..len(numa) st
    (numa[i].1  <= b) && (b  <= numa[i].2)

func numa-index-of-min(): number
  // deliver the index of the range with the least first number
  pre : numa non empty
  post: numa == numa0 &&
    numa[result].1 == min { numa[i].1 st i in 1..len(numa)}