What is the smallest positive integer that leaves a remainder of 1 when divided by 2, a remainder of 2 when divided by 3, a remainder of 3 when divided by 4, and following the same pattern up to leaving a remainder of 9 when divided by 10?

Courtesy of Funnymonkey9696 on Reddit

Simple Python Solution finder:

found = False
num = -1
while not found:
    num += 1
    found = True
    for i in range(2, 10):
        if not num % i == i - 1:
            found = False
print "Blah: " + str(num)

Went outside: red-hot; staying inside now.

I was just relaxing all cool inside my ground floor room, having just taken a shower, when my mom asked me to mow the lawn. Now I am trenched in sweat. This is ridiculous. But as I said, at least my room is extremely cool.

Watch this video on YouTube.

My maps don’t look amazing, but I think for the kind of effort involved they do look quite reasonable (The map in the video is created in < 20 minutes and I think if you invested another 20 it would be a perfectly fine map).

Here’s one of my first completed ones, where I tried out things:

And here is one I am currently using:

• 3 bags of Green Tea with Lemon Taste
• 3 bags of Earl Grey
• 1 bag of “Sweet Chili” tea
• 1 bag of Fruit tea

Let it brew for about 20 minutes, then add sugar while the stuff is still hot. Quite a lot of it actually, maybe 170-200g or so. Refrigerate forever until it is finally cold.

In this post I am looking at the book ‘Game of Thrones’ by George R. R. Martin. First I divided the ebook into seperate files by using csplit and then I counted the total words of each chapter using wc. In Numbers I then sumed it all up and this is the result:

(Note that Prologue is a character to make it easier to deal with it)

The average length of a chapter in ‘Game of Thrones’ is 4,007 words and the total amount of words is 292,492 words.

Sweet. Now let’s visualize it a bit:

In this pie chart we can see what percentage of the total word count each character has in the book.

In this chart we can see the average amount of words a chapter of a character has.

Mom found my old gameboy (+ my sister’s GBC) and some of our games in the attic. “I can throw that away, right?”

“I will kill you if you do. I’m not even kidding.”

(Also: the save on the Blue was from my sister; she was surprisingly a decent trainer as it seems, three legendaries in her roaster.)

Almost every Steam User knows it: Suspended Downloads which just won’t finish. Here are my 2 cents on how to fix them in almost any situation:

• Downloads will be suspended when you launch a game. If that’s what you did, then just pause them and unpause them. The download should then continue.
• The Steam folder or some subdirectories are set to “Read Only”. Uncheck that option for the Steam folder. (This should be the number one thing on Windows at least)
• (The Mac equivalent of sort is to Repair Permissions on your root drive. Just to be save you can check the read-only thing as well using “Get Info” on the steam folder in ~/Library/Application Support and checking if it says “Read & Write” next to your username in the permission section. I’ve never seen permission change by themselves on the Mac thought, seems to be only with the Windows version of Steam.)
• If you are using a non-english Operating System you can try to set your Unicode Language Setting to “English” (suggestion by a guy named Elvis in the comments of the previous post).
• Exit Steam, go to the Steam-Folder and delete the “ClientRegistry.blob” file. Now restart Steam (you will have to enter your password again even if you checked to save it).
• Verify the game cache (this option is found in the Properties of the game in the Steam Interface).
• Delete a bunch of already downloaded files and reverify the cache.
• If nothing helps: Delete everything and redownload

Those are pretty much the options in the order in which they should be applied.

If everything else fails and you find out how to fix it, please leave me a comment so I can add it to the list.

• S -> TS | XS | a
• T -> TT | YY | YS
• X -> a
• Y -> b

The word we are going to look for is “abbbaa”. This is an example given to me in a homework assignment in the FGdI 1 class during the summer of 2012 (taught by Ulrich Kohlenbach).

;; Grammar must be in Chomsky normal form.
;; symbols are written in uppercase, terminals in lowercase
;; A -> BC becomes a list with the string "A" as the first element,
;; followed by another list (containing "BC") as the second element. If a 
;; symbol maps to more than one thing, then they can be added to the list
;; along with "BC".
;; 
;; The table here specifies the grammar:
;;    S -> TS | XS | a
;;    T -> TT | YY | YS
;;    X -> a
;;    Y -> b
(define grammar (list
  '("S" ("TS" "XS" "a"))
  '("T" ("TT" "YY" "YS"))
  '("X" ("a"))
  '("Y" ("b"))))
 
(define startsymbol "S")
 
;; the word as a string, note that every letter used here should also be a 
;; terminal somewhere in the grammar.
(define word "abbbaa")

So much for the easy part. Now we need a function to look up thing in this table for us, as will need to do just that for obvious reasons:

;; string grammar ~> (listof string)
;; Takes a constructed string which is the construct we are looking for
;; (e.g. "a" for a terminal or "TS" for a symbol construct) and a grammar
;; definition and returns a list of which variables can build this construct
(define (find-accepting-productions construct grammar)
  (util:fold
        (fn (x v)
          (if (find construct (x 1))
              (cons (x 0) v)
              v))
        '()
        grammar))

Hopefully, this should also be pretty straightforward. The fold function used here is part of my untility collection provided here on GitHub. It works exactly like the scheme version of fold, so look for documentation for that if you require it. The result of our function here is going to be a list of all the symbols that contain a construct. For example if we use the example grammar I provided and we look at the terminal "a", the result will be '("S", "X").

Now let’s get to the heart of the problem: The CYK algorithm is calculated using a table of sort. I am not going to explain the principle here in detail as there are lots of resources on the internet and in books about it and I am certainly not qualified to teach it, having only just learned it myself. The principle, however is easy and I hope that the comments together with a general understanding should proof sufficient to see what the function is doing.

;; number number string grammar ~> (listof string)
;; Calculates which symbols from the grammar are able to produce a cell in
;; the cyk-table.
(define (calculate-cell row col word grammar)
  (if (= row 0)
      ;; if we are looking at the first row, this is trivial
      ;; just look for a terminal:
      (find-accepting-productions (word col) grammar)
      ;; for subsequent rows it is less trivial, we need recursion
      ;;
      ;; First, we need to compare 0 to row-1 fields to eachother
      ;; the fields in question are calculated as:
      ;; k|col and (row - k - 1)|(row + k + 1) where the coordinates are
      ;; y|x in the table.
      ;;
      ;; Now basically, we always need to get the posibilies for these fields
      ;; recursively and then try all permuations of the possibilies for these
      ;; fields to each other and look if they can be produced by our grammar.
      (unique (apply append (map
          (fn (k)
             (apply append (map
                (fn (x) (find-accepting-productions x grammar))
                (permutations
                  (calculate-cell k col word grammar)
                  (calculate-cell (- row k 1) (+ col k 1) word grammar)))))
          (sequence 0 (- row 1)))))))

As you can see, I’ve used a permutations function to combine each of the elements of the first cell with all those of the second cell. This function is pretty straightforward and is provided here:

;; (listof string) (listof string) ~> (listof string)
;; Creates a list of all possible string permuations from two lists
;; the resulting strings are concatinated together to a single string
(define (permutations lst1 lst2)
  (if (or (empty? lst1) (empty? lst2))
      ;; if either one is empty, then there are no permuations
      '()
      ;; otherwise:
      (apply append
             ;; map over all elements in lst1, then for each of them
             ;; map again over those in lst2 and concatinate them
             (map (fn (x) (map (fn (y) (append x y)) lst2)) lst1))))

Last, but not least we can add a couple of more functions to actually print out the result. The easiest one is certainly this one:

;; string grammar string ~> boolean
;; Returns whether the grammar detects a word based on the startsymbol.
(define (grammar-detects-word? word grammar startsymbol)
  (find startsymbol (calculate-cell (- (length word) 1) 0 word grammar)))

This function basically returns a boolean whether the word is actually an element of the language created using the provided grammar, but if you actually want to see the table (as I did, since I wanted to check if I did my homework assignment correctly), you can do so as well:

;; string grammar ~> nul
;; Generates the cyk table and prints it for you
(define (gen-and-print-table word grammar)
  ;; header
  (print "V_i/j\t")
  (dotimes (x (length word))
      (print (+ 1 x) "\t"))
  (println)
  ;; print vertical dimension
  (dotimes (y (length word))
      ;; print horizontal dimension
      (print (+ y 1) "\t")
      (dotimes (x (- (length word) y))
          (let ((result (calculate-cell x y word grammar)))
              (if (= result '())
                  (print "{}")
                  (print "{"
                         (util:join-strings ", " (sort result))
                         "}")))
                 (print "\t"))
          ;; new line
          (println)))

So that is basically it and if you want, you can also get the complete source code at GitHub instead of copying all the individual parts. In case there are any more questions, feel free to contact me.

Although I have been programming since I was maybe 12 or 13 (maybe even earlier if you count messing around with selfhtml to create text-adventures with links as programming), Racket was different to me. My experience prior to the course were around 4 or 5 years of Delphi, 1.5 years of Java (only used it in my High School CS class and disliked it immediately), some C#, C++ and C knowledge and a bunch of years (5+) in php. A bunch of smaller script in Python and Ruby as well if I think about it, but that’s pretty much it.

Functional programming itself was not that much of an issue for me – most of the smaller php scripts I write are functional after all – and the parentheses quickly stopped bothering me, so I thought it was pretty neat. Although I was not really used to it and now – in retrospect (if I’m allowed to say so after just half a year) – my programs were not very well done. Maybe that’s because with ‘How to Design Programs’ you are limited to subsets of Racket and you are not allowed to use all the functionality as a result (initially not even the debugger!!).

If I had to sum up my experiences, I would say Racket is somewhat mediocre. The language is neat, the functionality – again in retrospect when comparing it to newLISP – not as well done, but good enough in general and the included IDE is somewhat buggy in Mac OS X.

newLISP

Maybe it’s just the fact that we are using too much java for my taste, but I recently started to miss messing around with the simple syntax of Racket and I also was looking into trying some new languages to use for general purpose scripting on my system. My usual candidates for that so far have been PHP and Ruby.

PHP is a horrible language from a design standpoint, and prone to produce bad code by people who don’t know what they are doing, but somehow it can be made to work. Plus using it for scripting does not work even half as well as using it as a web development language in my experience.

Ruby is pretty cool, lots of really neat stuff, but I detest the function commenting style used in RDoc (yard fixes this) and I absolutely hate how 2-spaces indention and – even worse – all-lowercase underscore-joining instead of camel case is the de facto default in the Ruby community for naming variables, classes, methods and so on (e.g. some_instance.do_stuff instead of the imho much nicer someInstance.doStuff(); even .NET’s fuggly Pascal-style camel case is better than that).

So I was shopping around: Clojure looked interesting, but was disqualified for having a ridiculous startup time of 1.5s (!!!) and also the JVM/Java integration looks really unappealing to me. Somehow dirty, but I guess that might stem from me disliking java in general.

That’s when I almost gave up hope and experimented with writing my own Lisp/Scheme like runtime for smallish scripts, first in Ruby and then (against all better senses) in Java (I wanted something faster than Ruby and it was between Java and C++, so I bit the bullet, although I actually regretted it and I have a unfinished C++ version which only misses lambda compared to the java version on my hard drive as well now).

That’s when I stumbled upon newLISP and I saw that it was everything I wanted to have and tried to do myself; amazing!

It has a simple lisp-like syntax, without any old crufty legacy stuff like Common Lisp has it, not too minimalistic, but not too bloated either. It is well documented, throughly tested and runs on all major platforms. Plus it’s open source (even if it is the GPL, which I personally think is rather meh, but whatever).