stacyprowell.com » Scala

Scala Sudoku

stacy — Tue, 28 Dec 2010 06:48:07 +0000

A while back I needed to get back up to speed on Python, so I wrote a Sudoku solver using a simple algorithm. This required me to think just a bit about the language and how to implement this… plus it was fun.

Now I’m tinkering with Scala, and it occurred to me to write a Sudoku solver tonight. So just over an hour later I have one, and I’m posting it here. I make no claims about this being the right way to do things, or even a good way to do things. In particular, it uses a dumb algorithm to solve Sudoku, and probably isn’t done The Scala Way. In fact, I’m actually posting this so you can tell me where I’ve gone wrong, should have done things differently, etc.

Plus, if you want a Scala Sudoku solver, well, here’s one. Enjoy!

Use this in one of three ways.

Compile it and run it from the prompt. Enter the board one line per row.
Load it into a running Scala REPL and use Board.init to interactively enter the board, one line per row. Use the search method to find a solution.
Put the board in a file and use Board.read from the Scala REPL to load the board. Use the search method to find a solution.

/**
 * Simple Sudoku solver.
 * 2010 by Stacy Prowell.
 * http://stacyprowell.com/
 */
package sjp.sudoku
 
/**
 * An exception indicating that the board has no solution.
 * @param msg  A message.
 * @author sprowell
 */
class BadBoardException(msg:String) extends Exception(msg)
 
/**
 * Helper class for search data.
 * @param fails  Number of failures detected so far during the search.
 * @author sprowell
 */
protected class SearchData(var fails:Int = 0)
 
/**
 * A ''board'' holds two items.
 * - The currently known cell values
 * - The set of possible values for each unknown cell
 * 
 * @author sprowell
 */
class Board {
 
  /** Size of board. */
  val N = 9
 
  /** Representation of an unknown cell. */
  val U = ' '
 
  /** Known values in the grid. */
  val known = Array.ofDim[Char](N,N)
  for (i <- 0 until N; j <- 0 until N) known(i)(j) = U
 
  /** Allowed possibilities for each cell. */
  val possible = Array.ofDim[Set[Char]](N,N)
  for (i <- 0 until N; j <- 0 until N) possible(i)(j) = '1' to '9' toSet
 
  /**
   * Generate a string representing the current state of a cell.
   * There are two possiblities.
   * - `(5,4)=9` if the cell value is known
   * - `(5,4) allows {3,9}` if the cell value is now known
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @return  The cell representation.
   */
  def cellToString(row:Int, col:Int) = {
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    (row,col) +
      (known(row)(col) match {
        case U => " allows {" + possible(row)(col).mkString(",") + "}"
        case c => "=" + c
      })
  }
 
  /**
   * Set a cell to the given value.  This also updates the set of possible
   * values for each cell.
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @param ch  The character, 0-9.
   * @return  The updated board.
   */
  def set(row:Int, col:Int, ch:Char):Board = {
    /**
     * Tiny local function to exclude a value from the possibilities for
     * a cell.
     * @param rr  The zero-based row.
     * @param cc  The zero-based column.
     * @return  True if the cell is solved, false if it is not.
     * @throws  BadBoardException  There is no longer any viable solution.
     */
    def exclude(rr:Int, cc:Int, ex:Char) = {
      if (possible(rr)(cc) contains ex) {
        possible(rr)(cc) -= ex
        possible(rr)(cc).size match {
          case 0 => throw new BadBoardException(cellToString(rr,cc) +
            " has no possibilities")
          case 1 => true
          case _ => false
        }
      }
      false
    }
 
    // Check the arguments.
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    require('1' <= ch && ch <= '9')
 
    // The proposed value must be allowed for the cell.
    if (known(row)(col) != U && known(row)(col) != ch)
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
    if (!possible(row)(col).contains(ch))
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
 
    // Record any cells that get solved along the way.
    var also = List[(Int,Int)]()
 
    // Cannot have same value in row or column.
    for (i <- 0 until N) {
      if (i != col && exclude(row,i,ch)) also = (row,i)::also
      if (i != row && exclude(i,col,ch)) also = (i,col)::also
    } // Exclude in row and column.
 
    // Cannot have same value in block.
    val (brow,bcol) = (row/3*3,col/3*3)
    for (i <- 0 to 2; j <- 0 to 2) {
      val (rr,cc) = (brow+i,bcol+j)
      if (rr != row && cc != col && exclude(rr,cc,ch)) also = (rr,cc)::also
    } // Exclude in block.
 
    // Fix up the cell.  Set known and the set of possibilities.
    known(row)(col) = ch ; possible(row)(col) = Set(ch)
 
    // Done.  Now check to see if we discovered any other values.
    // If so, then set those now, recursively.
    also foreach {
      case (rr,cc) => set(rr,cc,possible(rr)(cc).head)
    } // Set each discovered solved cell.
    this
  }
 
  /**
   * Create a duplicate of this board.
   * @return  An independent clone of this board.
   */
  override def clone = {
    val cl = new Board()
    for (i <- 0 until N; j <- 0 until N) {
      cl.known(i)(j) = known(i)(j)
      cl.possible(i)(j) = possible(i)(j) 
    } // Duplicate known and possible.
    cl
  }
 
  /**
   * Initialize a row.  This is only intended to be used from the
   * companion object's init.  The provided string can be any length;
   * only the first N or fewer characters are used.
   * @param row  The zero-based row.
   * @param vals  A string of the values in that row.
   * @return  The updated board.
   */
  private def init(row:Int, vals:String) = {
    require(row >= 0 && row < N)
    require(vals.length <= N)
    var col = 0
    vals.foreach{ch => if (ch != U) set(row,col,ch) ; col += 1}
    this
  }
 
  // Import used below.
  import java.io.{Writer,FileWriter}
 
  /**
   * Write the board to the given writer.
   * @param writer  The writer to get the output.
   */
  def write(writer:Writer) {
    writer.write(known.map(row => row.mkString("")).mkString("\n"))
    writer.flush()
  }
 
  /**
   * Write the board to the given file.
   * @param file  The file name.
   */
  def write(file:String) {
    write(new FileWriter(file))
  }
 
  /**
   * Pretty-print the board.
   * @return  String representing the current known state of the board.
   */
  override def toString() = {
    def rts(row:Int) =
      known(row).slice(0, 3).mkString("") + " | " +
      known(row).slice(3, 6).mkString("") + " | " +
      known(row).slice(6, 9).mkString("") + "\n"
 
    var str = ""
    for (rblock <- 0 until N by 3) {
      if (rblock != 0) str += "----+-----+----\n"
      for (roff <- 0 to 2) {
        str += rts(rblock+roff)
      }
    } // Format all blocks.
    str
  }
 
  /**
   * Search for a solution.
   * @return  Solution, if one is found.
   */
  def search():Option[Board] = search(new SearchData(0))
 
  /**
   * Search for a solution.
   * @param sd  Search data block.
   * @return  Solution, if one is found.
   */
  private def search(sd:SearchData):Option[Board] = {
    // Get the cells that are currently unknown, and get the possibilities
    // for each.
    def unknowns = {
      for (i <- 0 until N; j <- 0 until N if known(i)(j) == U)
        yield (i,j,possible(i)(j))
    }
 
    // If all cells are known... We are done!
    if (unknowns.length == 0) {
      printf("Solution found:  fails=%d\n", sd.fails)
      return Option(this)
    }
 
    // Randomly choose an unknown
    val (row, col, choices) = unknowns(scala.util.Random.nextInt(unknowns.length))
 
    // Try each choice for the unknown cell.
    choices foreach {
      ch =>
      // Copy the board and set the value.  Then recursively seek a
      // solution.  If we find one, we are done.
      val newboard = clone
      try {
        newboard.set(row, col, ch)
        val soln = newboard.search(sd)
        if (soln.isDefined) return soln
      } catch {
        case e:BadBoardException => sd.fails += 1
      }
    } // Trying each choice.
    None
  }
}
 
/**
 * Companion object to the board class.  Provides methods to make and
 * initialize a board.
 *
 * @author sprowell
 */
object Board {
 
  /**
   * Convenience method to make a new board.
   * @return  A new board.
   */
  def apply() = new Board()
 
  import scala.io.Source
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param file  The file path.
   * @return  The new board.
   */
  def read(file:String):Board = read(Source.fromFile(file))
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param source  The source providing the data.
   * @return  The new board.
   */
  def read(source:Source):Board = {
    val board = new Board()
    var row = 0
    for (line <- source.getLines) {
      if (line.length > 0) board.init(row, line)
      row += 1
    } // Read all rows.
    board
  }
 
  /**
   * Interactively initialize a board by requesting nine lines of text
   * from the user.  Each line should consist of digits and unknown markers
   * (typically a space).  This is the initial board.
   * @return  The new board.
   */
  def init:Board = {
    val board = new Board
    for (row <- 0 until board.N) {
      val line = Console.readLine("Row %d: ", row)
      board.init(row, line)
    } // Read all rows.
    board
  }
}
 
/**
 * Application entry point when run from the prompt.  Initialize a board
 * using user input, solve it, and print the solution.
 *
 * @author sprowell
 */
object Sudoku {
  /**
   * Entry point when run from the prompt.
   * @param args  Command line arguments (ignored).
   */
  def main(args:Array[String]) {
    Board.init.search() match {
      case None => println("No solution.")
      case Some(b) => println(b)
    }
  }
}

Watched Properties in Scala

stacy — Tue, 27 Apr 2010 20:08:39 +0000

Scala is pretty damn neat. I’ve only just started learning the language (an earlier attempt had to be sidelined because “real” work interfered), but I’m back to it now.

Properties

Here’s a funny little class I’ve been playing with in some development work.

class Property[T](var value:T) {
  def get:T = value
  def set(newval:T) = {
    value = newval
    this
  }
  def :=(newval:T) = set(newval)
  override def toString = "Property(" + value + ")"
}
implicit def Property2value[T](prop:Property[T]) = prop.get

I think that’s just too neat. The property can be set with the (admittedly PL/1-ish) := operator, and the value can be extracted with a cast or assignment.

If I could override the assignment then I could make this very, very C++-ish-ish. Note that I could have written something like the following.

def `=`(newval:T) = set(newval)

But then I’d have to use this as follows.

scala> val p = new Property(12)
scala> p `=` 13

That’s just not the same thing. Scala does not allow overriding assignment; no copy constructor for you.

If you are willing to declare p to be a var, then you can do the following. But this is really not what you want since it creates a new property, and does not modify the value of the existing property.

scala> def ValueToProperty[T](value:T) = new Property(value)
 
scala> var p = new Property(12)
p: Property[Int] = Property(12)
 
scala> p = 171
p: Property[Int] = Property(171)

Watched Property

So what’s the point of having this mutable property class? Well, now that I have the above I can add code to watch the property.

trait Watcher[T,U] {
  def notify(value:T, data:U)
}
trait Watchable[T,U] {
  var watchers:Map[Watcher[T,U],U] = Map()
  def register(watch:Watcher[T,U], data:U) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T,U](value:T) extends Property(value) with Watchable[T,U] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Now I have a watcher and a watchable. I mix in the watchable trait with the property, and presto! I have a watched property. It’s somewhat of a big deal for some work I’m doing now; this would have made my life much easier.

class See[T,U]() extends Watcher[T,U] {
  def notify(value:T, data:U) = {
    println("Value is now " + value + " and data is " + data + ".")
  }
}

Finally, we do some “work.”

scala> val see = new See[Int,String]
see: See[Int,String] = See@fab91
 
scala> val watch = new WatchedProperty[Int,String](1)
watch: WatchedProperty[Int,String] = Property(1)
 
scala> watch register (see,"watch")
 
scala> watch := 12
Value is now 12 and data is watch.
res22: Property[Int] = Property(12)
 
scala> watch := 31
Value is now 31 and data is watch.
res23: Property[Int] = Property(31)

Of course, I can also avoid new by declaring the companion object for WatchedProperty and adding a factory method. Life in Scala is pretty good (so far).

object WatchedProperty {
  def apply[T,U](value:T) = new WatchedProperty[T,U](value)
}

Cleaner Watched Property

There is a problem with the implementation of watched property, and it is the type annotation U. Why should the property have to know the type for the data? The data only exists for the benefit of the watcher. Worse, the watched property isn’t a drop-in replacement for property; it has two parameters instead of just one. Finally, everyone who wants to register must use the same data type U (or a subclass). Here are some alternatives.

The watcher can maintain a map from watched property to the associated data. The watched property can then send itself with the property change notification. This is bad. The watcher has to maintain the map. If it is watching a lot of properties then it may have to maintain a big map, and there is lookup overhead. We avoid that by having the property return the data with the notification.
We could treat the data as an Any. Then it is the responsibility of the watcher to correctly cast the value during notification. This is a nuisance because the compiler cannot catch type problems for us, but Java programmers should be used to that by now.

Let’s try the second approach.

trait Watcher[T] {
  def notify(value:T, data:Any)
}
trait Watchable[T] {
  var watchers:Map[Watcher[T],Any] = Map()
  def register(watch:Watcher[T], data:Any) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval:T)
    notify(newval)
    this
  }
}

That’s better, actually. Watched property is again a referentially-transparent replacement for property, and watchers can use any data type they want. What could be better than this?

Better Watched Property

Actually that whole “Any” value is the problem now. This implementation cleans up the design a bit with better information hiding and referential transparency, but it also musses up type safety a bit. The watcher knows the type of the data; why can’t it get back properly-typed data during notification?

Maybe we’ve been asking the wrong question. The issue is, I think, the Java-esque nature of the solution. Why does notify really have to be passed the data? Why not do something very different? In fact, why not get rid of the watcher trait altogether? Why do we need it? We really just want to invoke a function (or method) when the property is changed. Let’s just directly register the callback, and forget the middleman.

trait Watchable[T] {
  var watchers:List[(T) => Unit] = List()
  def register(notify:(T) => Unit) {
    watchers += notify
  }
  def notify(value:T) = {
    watchers foreach (notify => notify(value))
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Watcher is gone. The data item is gone. The funny type problem is gone. The code is simpler, and even more flexible, since anything can be a watcher, including lambdas.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> def see(x:Int) = println("Value changed to: " + x + ".")
see: (Int)Unit
 
scala> prop.register(see)
 
scala> prop.register((x:Int) => println("Lambda sees value: " + x + "."))
 
scala> prop := 413
Value changed to: 413.
Lambda sees value: 413.
res10: Property[Int] = Property(413)

Data Again

Well, what about data? The value for data can be captured in a closure. Here’s an example, where the data is a name for the property being monitored.

class ChangeWatcher {
  def watch[T](prop:WatchedProperty[T], name:String) {
    prop register {
      (value:T) => println(name + ": " + value)
    }
  }
}

Did you get all that? The above is a fully-generic watcher. You pass it a property and a name for the property. Whenever the property is changed, it notifies you. This works for any kind of property.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> val status = new WatchedProperty("okay")
status: WatchedProperty[java.lang.String] = Property(okay)
 
scala> val temp = new WatchedProperty(21.8)
temp: WatchedProperty[Double] = Property(21.8)
 
scala> val cw = new ChangeWatcher
cw: ChangeWatcher = ChangeWatcher@3da8bc
 
scala> cw.watch(prop, "prop")
 
scala> cw.watch(status, "status")
 
scala> cw.watch(temp, "temperature")
 
scala> status := "Danger!"
status: Danger!
res18: Property[java.lang.String] = Property(Danger!)
 
scala> temp := 73.2
temperature: 73.2
res19: Property[Double] = Property(73.2)

The important thing to note is that you don’t have to have data. Or you can have lots of data. Or whatever you want. The responsibility for data is all back to the watcher, and off the shoulders of the watchable. This seems (to me) to be the correct division of responsibility.

To sum up: Functional Programming + Objects = Good.

Silly Scala Tricks

stacy — Thu, 12 Nov 2009 04:53:10 +0000

One of the things I have in my Scala startup file is the following.

def show[T](implicit thetype:scala.reflect.Manifest[T]) {
  thetype.erasure.getMethods() foreach println
}
def help(x:AnyRef) {
  x.getClass().getMethods() foreach println
}

These silly little functions are useful – at least, to me. Now when I can’t remember the name of a method I can type something like the following at the Scala prompt.

scala> help(Map())
public scala.Option scala.collection.immutable.EmptyMap.get(java.lang.Object)
public int scala.collection.immutable.EmptyMap.hashCode()
public boolean scala.collection.immutable.EmptyMap.equals(java.lang.Object)
...

The output isn’t very Scala-ish, but I could format it if I weren’t so lazy.

scala> help(scala.runtime.RichString)
public int scala.runtime.RichString$.$tag() throws java.rmi.RemoteException
public final boolean scala.runtime.RichString$.scala$runtime$RichString$$parseBoolean(java.lang.String)
public final char scala.runtime.RichString$.scala$runtime$RichString$$LF()
public final char scala.runtime.RichString$.scala$runtime$RichString$$CR()
public final char scala.runtime.RichString$.scala$runtime$RichString$$FF()
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

These functions aren’t in any way brilliant, or even clever, but they are short and ridiculously trivial to write.

Scala

stacy — Thu, 01 Jan 2009 07:32:33 +0000

As usual, I’m learning Yet Another Programming Language. Every time I do I see some new ideas and experience new frustrations. This time the language is Scala http://www.scala-lang.org/. There is a lot to like about it.

First, it’s a functional langauge, and I really like functional languages. Second, it is statically typed with type inference, and I like that. Third, it is object-oriented in a nice way (everything really is an object). Fourth it runs on the Java VM. So far, so good.

The down side to it is that the learning curve seems quite steep. I am occasionally surprised by the solutions given in the text I’m reading (the Scala book), and I think that’s bad. After reading half the book I should be able to predict the form of a solution. I’ve been doing quite a bit of functional programming recently, and so I’m not shocked by that aspect. I think it is actually the exposition, which is otherwise excellent. Too many ideas are being introduced for the first time in code snippets.

I am also frustrated that Scala uses type erasure. It’s not as much of a problem as with Java, but it is still a bit frustrating.

On the plus side I really want to write some code in Scala. I’m currently developing a class library for sequence enumeration. It’s relatively compact, but mixins would really help the library, and the Scala prompt would make testing much nicer. Right now I’m testing using Jython. The temptation is strong to re-write the library in Scala.

If anyone else has experience with Scala, I’d love to hear about it.