// 1000
// 1001
// 0111

The above has two contiguous blocks of sizes 2 and 4 (I’m not counting diagonals as contiguous).

The auxiliary constructor for the class Grid takes a height and width argument and creates a random matrix. You can then invoke the numBlocks method and access the blockSizes field on your instance of Grid.

class Grid(s: Array[Array[Boolean]]) {
  require(s.length > 0 && s(0).length > 0 && s.forall(_.length == s(0).length))
  val height = s.length
  val width = s(0).length
  final val state = s
 
  def this(h: Int, w: Int) = this(Array.fill[Boolean](h, w)(scala.util.Random.nextBoolean))
 
  private def valid(r: Int, c: Int): Boolean =
    0 <= r && r < height && 0 <= c && c < width
 
  private def contiguous(r: Int, c: Int) = 
    for {
      i <- -1 to 1
      j <- -1 to 1
      if (i * j == 0)
    } yield (r + i, c + j)
 
  val blockSizes = {
    val visited = Array.ofDim[Boolean](height, width)
    def visit(r: Int, c: Int): Int = {
      if (valid(r, c) && !visited(r)(c) && state(r)(c)) {
        visited(r)(c) = true
        1 + contiguous(r, c).map{ case (i, j) => visit(i, j) }.sum
      }
      else
        0
    }
    val sizes = 
      for {
        r <- 0 until height
        c <- 0 until width
        val v = visit(r, c)
        if v > 0
      } yield v
    sizes.toList
  }
 
  def numBlocks = blockSizes.length
 
  override def toString = state.map(_.map(if (_) "x" else ".").mkString(" ")).mkString("\n")
}

The computation in the blockSizes method works using a val visited: Array[Boolean] which is mutated by the visit method. The visit method recursively visits all active cells contiguous to the current one, adding one to a running sum of the number of active cells visited in this block and so finally returning the size of the block.

The Question

The question is: given a sorted array of integers and a target integer, find a pair of integers in the array that sum to the target in linear time.

The Solution

A solution is to initialise two pointers to the ends of the array and compute the sum of the two elements pointed to. If the sum equals the target, we’re done.

If not, it either exceeds the target (in which case we can decrease our candidate solution by the smallest amount possible in a unique way: decrementing the upper pointer) or is too small (in which case we perform the dual operation and increment the lower pointer).

We repeat this process (via a while loop or recursion) until we find a solution or the pointers cross (if they cross, there was no pair of distinct elements of the array that summed to the target).

It’s linear time because on each pass of the loop/recursion, the algorithm either terminates (by success or pointers crossing) or the distance between the pointers decreases by one. Therefore in the worst case (i.e. termination as late as possible), the pointers meet and force termination – they must have jointly travelled n places, where n is the length of the array. Therefore it’s O(n) – linear time.

The Scala code

object PairSum {
 
  def main(args: Array[String]) {
 
    // parse input
    val xs = args.tail.map(_.toInt)
    val target = args(0).toInt
 
    // ensure list is sorted
    require(sorted(xs))
    def sorted(xs: Array[Int]) = xs.sliding(2).forall { case Array(a,b) => a <= b }
 
    // find a solution, if one exists
    def findPair(l: Int, h: Int): Option[(Int, Int)] = {
      if (l >= h) None
      else if (xs(l) + xs(h) == target) Some((xs(l), xs(h)))
      else if (xs(l) + xs(h) <  target) findPair(l + 1, h)
      else                              findPair(l, h - 1)
    }
 
    // pretty printout
    println(
      findPair(0, xs.length - 1) match {
        case Some((a,b)) => a + " + " + b + " = " + (a + b)
        case None => "No solution"
      }
    )
 
  }
}

Comments on coding the solution

Before learning Scala, I did this in Java (going a bit mental and creating a new datatype – a “double pointer array”…) and then tried doing it in a “functional-programming-y” way in ML. That ended badly – I was trying to use lists (nullifying the whole point of efficiency as there’s no O(1) random access). I could have used ML’s arrays and whatnot, but it’s nightmarishly ugly stuff.

Xiang managed to do an O(n) time, O(1) space list implementation in ML!

This ended up being surprisingly idiomatic in Scala. The require and sorted predicate, the combination of tail recursion (which the JVM can just about handle in this case), immutability, OOP field syntax, seamlessly using what are traditionally list functionals on arrays… seems quite Scala-ish.

Having said that, I’m a Scala beginner – tell me if there are any obvious improvements.

Ted Nelson gave a talk at school today.

He handed out some copies of ZigZag and Xanadu and demoed XanaduSpace. Having heard about it for ages and seeing demonstrations in other videos scattered across the web, it was great to see it right there. I think a combination of seeing it materialise despite the rather long-lived smear campaign against it (the print equivalent of Googlebombing “Xanadu” for “vaporware”) and hearing Ted talk about concrete implementation details (C++, OpenGl and Python back-end, next platform will be iPhone, Flash version soon) really brought it to life.

The basic thread of the talk was an indignant reminder that technology was really just “packaging and conventions” and that we had learned to use kludgy solutions rather than engineering great solutions (this was blamed on techies). Nelson believes that the web’s infrastructure (one-way links, unsourced quotations etc.) is a shadow of what it should be, and that 1984, when Xerox PARC gave us the desktop metaphor, was when “it all went wrong”. Seems fair.

At age 70, having been ridiculously ahead of the curve for so long but never really achieving the recognition he deserves, Nelson continues to pursue his original projects with zeal and keen perceptiveness. Listening to his anecdotes and analogies reminded me strongly of interviews with Richard Feynman.

Mr Smith covered the talk.

Update: since writing this post, I have read Geeks Bearing Gifts, which I thoroughly recommend to anyone with any interest in computers. Nelson’s autobiography, Possiplex, is imminent: find it and read it. Coincidentally, I visited Greenwich Village in NY (where Nelson grew up) – nice place!