Puzzle 46 / Fillomino [LITS + Extra Region + Walls + Anti-Walls + Inequality + Tapa + Masyu]

5:27 PM phenomist: do you use gridderface to make pretty puzzles?

5:52 PM phenomist: actually nvm excel is probably easier lol

Okay I’m sorry this is a horrible puzzle where the rules don’t make sense and I didn’t even get it testsolved. I just wanted an image to concisely demonstrate the capabilities of gridderface, my puzzle marking and creation program, for the project homepage, after somebody expressed interest in using the program to write a puzzle. Then I got tremendously carried away.

fillomino-gf

Hints:

  • L, I, T, S are comparable, but not in that order.
  • The Tapa clue isn’t part of any polyomino.
  • The Masyu clue restricts the borders around three intersections, including itself.
  • (Is there a name for Fillominoes with the opposite of walls?)

Other than that, you’ll have to figure out the rules yourself (partly because I am lazy and partly because if I listed the rules it would probably take longer to read and understand them than to apply them to the puzzle…)

Anyway, this post is actually to say that it is now possible to use the Scala reboot of gridderface without spending forever to attempt to install Scala, because I figured out how to make .jar file releases. It’s probably still hard to use but who knows?

Because it’s a full rewrite, the version is back to 0.2 unlike the old 0.5. As I noted earlier, the code base was horrible.

By the way here is the Heyawake phenomist eventually made.

Okay back to homework (and agonizing over which college to go to).

Advertisements

Adventures in Scala Pseudo-Abuse

So, what have I been doing with programming recently?

Scala is an amazing multiparadigm programming language that runs on the Java Virtual Machine and interoperates with Java. I learned about it last time reading random articles on Twitter.

When I say “amazing” I mean “This is a language in which my code gives me nerdgasms every time I read it.” Wheeee.

Okay, it’s not perfect. People say it’s too academic. It has a notoriously complicated type system (which is Turing-Complete at compile time). Its documentation is a bit patchy too. For a serious introduction, the Scala website has plenty of links under documentation, and a tour of features. Somebody wrote another tour that explains things a bit more. So here, instead of introducing it seriously, I’m just going to screw with its features.

Example of freedom. Scala lets names consist of symbols, and treats one-parameter methods and infix operators exactly the same. The full tokenization rules are a bit detailed and I put them at the bottom of this post for the interested. This lets you create classes with arithmetic and domain-specific languages easily, but it also creates some silly opportunities:

scala> val * = 12
*: Int = 12

scala> * * * * *
res0: Int = 1728

Continue reading

Now on GitHub!

Yay?

Right now I feel about this a lot like I felt about getting Twitter. Nobody I know personally is there, but all the “famous” “technological” people are, and something like 90% of the open-source projects I bump into are too.

Just like Twitter, I barely know how to use Git either, but that’s okay. For version control I’m going all command-line now! Last time I tried to link stuff up with Eclipse everything exploded, but after I ran git init from the terminal this time, it’s highlighting things red and green everywhere like it’s suddenly begging me not to forsake it for the command line. Nice try, Eclipse. You can’t even get your “presentation compiler” to stop crashing.

Anyway, I’m recoding my grid-puzzle-drawing project from scratch (Step 3 of writing a complex program, according to Knuth) and having a lot of fun (ab)using Scala monads.

def tryToInt(str: String): Either[String, Int] = {
  try {
    Right(str.toInt)
  } catch {
    case e: NumberFormatException => Left("Error: cannot parse int: " + str)
  }
}
def tryToInts(strs: Seq[String]): Either[String, Seq[Int]] = {
  ((strs map tryToInt).foldLeft
    (Right(List.empty): Either[String, Seq[Int]])
    ((collected, next) =>
      for (c <- collected.right; n <- next.right)
        yield (c :+ n)))
}