stuff & things

Team composition

Sun, 25 Oct 2009 18:23:10 -0700

Team makeup

Pragmatist, Perfectionist, Crazy Smart

Interactions

A quote to start: This quote is the designers’ reflections on designing a programming language (SIMULA).

In the spring of 1967 a new employee at the NCC in a very shocked voice told the switchboard operator: “Two men are fighting violently in front of the blackboard in the upstairs corridor. What shall we do?” The operator came out of her office, listened for a few seconds and then said: “Relax, it’s only Dahl and Nygaard discussing SIMULA”.

The story is true. The SIMULA 67 language was the outcome of ten months of an almost continuous sequence of battles and cooperation in front of that blackboard - interrupted by intervals when we worked in our neighbouring offices (communicating by shouting through the wall if necessary) or at home. (The people arranging this conference asked us to provide material relating to the development of our respective languages. We felt that the best thing we could have done was to bring along that blackboard. But we did not know for certain whether we would be flying a wide-body aircraft.)

In some research teams a new idea is treated with loving care: “How interesting:”, “Beautiful:”. This was not the case in the SIMULA development. When one of us announced that he had a new idea, the other would brighten up and do his best to kill it off. Assuming that the person who got the idea is willing to fight, this is a far better mode of work than the mode of mutual admiration. We think it was useful for us, and we succeeded in discarding a very large number of proposals.

(from http://www.oberon2005.ru/paper/kn1978-01e.pdf via http://lambda-the-ultimate.org/node/3107)

Isn’t that fantastic? You know that the “idea-defender” here would need to quickly detach himself from any silly latent emotional attachment to an idea. Any idea in that situation is going have to live on its own merits.

If you’ve got someone who you know will rip into your shitty ideas with pointed criticism, then:

you’re not going to do dumb stuff; and
you’re going to know that you’ve got a winner when you get them on board.

That kind of relationship is a huge asset. It’s one thing that turns you into (the very cliched) “more than the sum of your parts”. If you can do this, you’re really combining your 2+ brains effectively.

Drop your ego, cultivate these relationships, and then hang on to them for dear life.

Really? REALLY? wtf.

Sat, 25 Jul 2009 12:10:13 -0700

js> x = [];

js> x[0] = "num0";
num0
js> x[1] = "num1";
num1
js> x[2] = "num2";
num2
js> x
num0,num1,num2
js> x["1"] = "str";
str
js> x
num0,str,num2
js>

Someone please tell me there’s a way to avoid this idiotic behaviour.

ImgBurn rocks the shizzle.

Mon, 09 Feb 2009 21:11:16 -0800

ImgBurn rocks the shizzle.

Huzzah!

Wed, 28 Jan 2009 17:13:14 -0800

Huzzah!

First Clojure program

Sat, 15 Nov 2008 16:47:00 -0800

So, I watched a few of Rich’s videos on Clojure a couple months back, but I finally got an afternoon to spend trying it out.

I skimmed through Ruby Quiz to find an interesting but simple problem, and I decide to write a Sokoban clone.

My initial thought was to do it as a gui app, but I haven’t written any Java code since JDK 1.0-alpha in late 1995, and honestly, I didn’t really feel like putting effort into learning the Java GUI API only to end up with a bizarrely emulated, slightly broken GUI.

So, I grabbed Compojure off of git, and made the UI a hack webapp. (Yes, it’s bizarrely emulated and slightly broken still, but at least it was easy to write).

First, have a look at the result: Clojban!

If you care, the (probably horrible and un-idiomatic) code follows.

(ns clojban
  (:use (compojure html
                   http
                   file-utils)
        (clojure.contrib str-utils
                         seq-utils)
        (clojure set))
  (:import (java.util.regex Pattern)))

(defstruct pos :x :y)
(defstruct level
           :player ; pos
           :boxes  ; set-of-pos
           :goals  ; set-of-pos
           :walls  ; set-of-pos
           )

(defn explode
  "return a pos/type seq for each char in the line"
  [y line]
  (map (fn [x y type] (vector (struct pos x y) type))
       (iterate inc 0) (repeat y) line))

(defn line-explode
  "call explode on each line with the appropriate y"
  [lines]
  (let [linesplit (. Pattern compile "\n" (. Pattern MULTILINE))] ; must be a better way?
    (reduce into
            (map explode
                 (iterate inc 0)
                 (. linesplit split lines)))))

(defn filter-level
  "extracts a set of the pos's that match types"
  [expl-level type1 type2 & type3]
  (set (map first
            (filter (fn [item]
                      (or (= (second item) type1)
                          (= (second item) type2)
                          (= (second item) type3)))
                    expl-level))))

(defn load-levels
  "load and return seq of level's"
  [filename]
  (let [contents (slurp filename)
        levelsplit (. Pattern compile "^$\n" (. Pattern MULTILINE)) ; each level separated by blank line
        levels (seq (. levelsplit split contents))]

    (map (fn [levelstr]
           (let [expl-level (line-explode levelstr)]
             (struct-map level
                         :player (first (filter-level expl-level \@ \+))
                         :boxes (filter-level expl-level \o \*)
                         :goals (filter-level expl-level \. \* \+)
                         :walls (filter-level expl-level \# \#))))
         levels)))

(def Levels (load-levels "sokoban_levels.txt"))
(def LvlWidth 19)
(def LvlHeight 16)
(def PlayerRenderOpen "♦")
(def PlayerRenderGoal "♦")
(def BoxRenderOpen "▨")
(def BoxRenderGoal "▨")
(def WallRender "█")
(def GoalRender "░")

(defn level-index [x y] (+ (* y LvlWidth) x))



(defn render-level-layer
  "my, what an insane level representation i have here"
  [target items if-empty if-full]
  (loop [target target
         remain (seq items)]
    (if remain
      (let [x (:x (first remain))
            y (:y (first remain))
            i (level-index x y)
            at (target i)]
        (recur (assoc target i (if (= at \space) if-empty if-full))
               (rest remain)))
      target)))

(defn render-level
  [lvl]
  (let [finallevel (reduce (fn [lvl data] (render-level-layer lvl (nth data 0) (nth data 1) (nth data 2))) ; todo how to splat `data'
                           (vec (replicate (* LvlWidth LvlHeight) \space))
                           `((~(:walls lvl) ~WallRender ~WallRender)
                             (~(:goals lvl) ~GoalRender ~GoalRender)
                             (~(:boxes lvl) ~BoxRenderOpen ~BoxRenderGoal)
                             (~(set (list (:player lvl))) ~PlayerRenderOpen ~PlayerRenderGoal)))]
    (dotimes y LvlHeight
      (print "")
      (dotimes x LvlWidth
        (print "")
        (print (finallevel (level-index x y)))
        (print ""))
      (print ""))))

(def AsciiToDx {72 -1,
                76  1,
                75  0,
                74  0})
(def AsciiToDy {72  0,
                74  1,
                75  -1,
                76  0})

(defn do-player-move
  "handle player movement, input is int ascii code for HJKL."
  [level input]
  (let [dx (get AsciiToDx input)
        dy (get AsciiToDy input)
        curpos (:player level)
        candidatepos (struct pos (+ (:x curpos) dx) (+ (:y curpos) dy))
        pastcandidatepos (struct pos (+ (:x curpos) dx dx) (+ (:y curpos) dy dy))
        walls (:walls level)
        boxes (:boxes level)]
    (if (walls candidatepos)
      level
      (if (boxes candidatepos)
        (if (or (walls pastcandidatepos) (boxes pastcandidatepos))
          level
          (assoc
            (assoc level :boxes (conj (disj boxes candidatepos) pastcandidatepos)) ; move box
            :player candidatepos)) ; and player
        (assoc level :player candidatepos))))) ; only player

(def JSCode "
function postwith (p) {
  var myForm = document.createElement('form');
  myForm.method='post';
  myForm.action='/';
  for (var k in p) {
    var myInput = document.createElement('input');
    myInput.setAttribute('name', k);
    myInput.setAttribute('value', p[k]);
    myForm.appendChild(myInput);
  }
  document.body.appendChild(myForm) ;
  myForm.submit() ;
  document.body.removeChild(myForm) ;
}

function handlekey(e) {
  if (!e) var e = window.event
  if (e.keyCode) code = e.keyCode;
  else if (e.which) code = e.which;
  if (code == 37) code = 72;
  if (code == 38) code = 75;
  if (code == 39) code = 76;
  if (code == 40) code = 74;
  if (code == 72 || code == 74 || code == 75 || code == 76 || code == 82 || code == 65 || code == 90) postwith({'code': code});
}
")

(defn restart-level [session]
  (alter session assoc :curlevel (or (session :curlevel) 0))
  (alter session assoc :complete (or (session :complete) (set nil)))
  (alter session assoc :nummoves 0)
  (alter session assoc :level (nth Levels (or (session :curlevel) 0))))

(defn next-level [session]
  (alter session assoc :curlevel (min
                                   (inc (session :curlevel))
                                   (- (count Levels) 1)))
  (restart-level session))

(defn prev-level [session]
  (alter session assoc :curlevel (max (dec (session :curlevel)) 0))
  (restart-level session))

(defservlet clojban-servlet
  (POST "/"
        (dosync
          (let [prevlevel (session :level)
                keycode (. Integer parseInt (params :code))]
            (if (= keycode 82)
              (restart-level session)
              (if (= keycode 65)
                (prev-level session)
                (if (= keycode 90)
                  (next-level session)
                  (let [moveresult (do-player-move prevlevel keycode)]
                    (if (= 0 (count (difference (:boxes moveresult) (:goals moveresult))))
                      (do
                        (alter session assoc :complete (conj (session :complete) (session :curlevel)))
                        (next-level session))
                      (do
                        (alter session assoc :nummoves (inc (session :nummoves)))
                        (alter session assoc :level moveresult)))))))))
        (redirect-to "/"))
  (GET "/"
       (let [levelstate (or (session :level) (dosync (restart-level session) (session :level)))]
         [{"Content-Type" "text/html"}
          (html
            (doctype :xhtml-transitional)
            [:html {:xmlns "http://www.w3.org/1999/xhtml" :lang "en"}
             [:head
              [:title "Clojban!"]
              [:meta {:http-equiv "Content-Type", :content "text/html; charset=utf-8"}]
              [:script {:type "text/javascript"} JSCode]]
             [:body {:onkeydown "handlekey(event);" :style "font-family: arial; font-size: 13px;"}
              [:h1 {:style "font-family: arial;"} "Clojban"]
              [:p "This is a silly Sokoban implemented in " (link-to "http://clojure.org" "Clojure") ". It's hitting the server every time you move (rather than Javascript) so it might not respond too quickly. The unicode box drawing craziness looks OK in FF, and reasonable in IE, but not so hot in Chrome/Webkit. Sorry."]
              [:table {:style "border-style: none; font-size: 36px; font-family: courier; padding: 0px 0px 0px 0px; margin:0px 0px 0px 0px; line-height: 1em;"
                       :border "0"
                       :cellpadding "0"
                       :cellspacing "0"}
               (with-out-str (render-level levelstate))]
              [:p "Use arrow keys or hjkl to move all the boxes into the goals. Press r to restart level, or a/z to give up and skip through levels."]
              [:p "Level: " (session :curlevel)]
              [:p "Moves: " (session :nummoves)]
              [:p "Completed: " (str-join " " (map (fn [i]
                                                     (let [complete (session :complete)]
                                                       (format "%d"
                                                               (if (complete i) "green" "#ccc")
                                                               i)))
                                                   (range (count Levels))))]
              ]])]))
  (ANY "*"
       (page-not-found)))

Configuring Vim, some more

Mon, 10 Nov 2008 23:14:00 -0800

As an addendum to http://items.sjbach.com/319/configuring-vim-right

Here’s a few more that I think are un-live-able-without:

" ease of use keyboard mappings (why do I care about top/bottom of screen?)
map H ^
map L $

" buffer switching/management, might as well use those keys for something useful
map :bnext
imap :bnext
map :bprev
imap :bprev
map :bd

" get rid of stupid scrollbar/menu/tabs/etc
set guioptions=a

" don't need /g after :s or :g
set gdefault

" i prefer this to visualbell
set noerrorbells
" Hide the mouse pointer while typing
set mousehide

I’ve used all of these for longer than I can remember, probably time to troll through recent help files and vim.org to find new and exciting juicy settings.

EDIT: forgot the one I miss the most when I don’t have my .vimrc:

cab o find

so that :o does something useful. I’d like one of the emacs-style smart-fuzz-file-opener command line thing, I should probably hunt around for a plugin to do that.

Bill C-61

Sun, 24 Aug 2008 18:48:54 -0700

Canada’s Bill C-61 is an even-worse version of the United States’ DMCA.

For more information, http://www.michaelgeist.ca/ is a reasonable starting point. I rolled up my sleeves and had a go at http://www2.parl.gc.ca/HousePublications/Publication.aspx?Docid=3570473&file=4 which is relatively readable.

Here’s the letter I just posted (yes, on actual paper, in an envelope!) to my MP.

If you’re Canadian, please read the above links and if you don’t agree with this Bill, as I’m confident you won’t, phone or write to your MP (especially if your MP is a Conservative Party member!)

————————————

Office of the Honourable Dr. Hedy Fry, P.C., M.P.
Confederation Building House of Commons
Ottawa, Ontario
K1A 0A6

Hello Dr. Fry

I am a resident of Vancouver Centre, and I’m writing to you to express my absolute horror at the current state of Bill C-61.

I am employed as a software engineer in the entertainment industry, and as such, fully respect and understand the need for copyright reform in Canada.

However, from reading this bill (at http://www2.parl.gc.ca/HousePublications/Publication.aspx?Docid=3570473), the reproduction rights afforded to Canadians are absolutely useless because of section 29.21(c). This section subordinates any time-shifting and media-shifting rights that should be allowed, merely by having any kind of digital lock mechanism on the content. But, virtually all media sold in Canada now contains a digital lock of some sort, so it’s almost pointless to “grant” these rights.

Inevitably, the devices or internet services which control the digital lock access fail, go out of business, or otherwise are not maintained. If we are unable to legally shift to other formats, and the media become un-unlockable, they are effectively gone. Will all of the companies and individuals controlling the locks exist in 5 years? Maybe. 50 years? Unlikely.

I would also like to especially point out that this does not solely concern things that could perhaps be considered “frivolous”, like pop-consumer-ish music and video. Over the next 10-15 years, it is all but guaranteed that most books, and crucially text books, will be delivered and consumed in electronic form. My wife is a high school teacher employed by the Vancouver School Board, and I would be horrified to find that our already underfunded education system had lost access to teaching resources, simply because the company controlling a digital lock had failed.

I sincerely hope you will make sure that this Bill is heavily modified, or defeated, when the time comes.

Thank you for your time,

Scott Graham

Braid

Sat, 09 Aug 2008 23:49:49 -0700

Braid is very cool. I often enjoyed reading The Inner Product in GDMag, but always got the impression Jonathan was a little “ivory tower”. Turns out, I don’t know shit. Congrats to Mr Blow! (just grabbed the full 360 version: it’s fantastic).

floating point

Wed, 06 Aug 2008 21:42:00 -0700

Floating-point tends to chafe my ass. I was thinking perhaps I’d try to really understand it. These look interesting:

http://citeseer.ist.psu.edu/goldberg91what.html

http://www.cant.ua.ac.be/ieeecc754.html

http://fluorescence.fjfi.cvut.cz/~adamek/nm/ieee754.pdf

Only way to understand something is to implement it though…

[Update]: even better by the looks of it: http://docs.sun.com/source/806-3568/ncgTOC.html

Second "das keyboard"

Tue, 29 Jul 2008 19:25:38 -0700

So, I just got my second http://www.daskeyboard.com/ in the mail. The first one I had was the “original”, and I loved and continue to love it. I’ve been using it as my work keyboard (where I do the majority of my coding) for the last 3 years or so.

I just got a second one, but it’s the “new” version (the only one they offer now). It’s cleaner design-wise, but there’s some things that I think they’ve made worse.

The first is that the keyboard is just too thick. It’s gotten half an inch (or so) thicker. It feels more solid now, and is quite a bit heavier (so it doesn’t move around at all, which is nice), but the angle of my forearms is slightly higher, which inevitably means my wrists are more crooked when I get more tired and drop my arms, and slouch, etc. Don’t like that very much, especially as I’ve had some wrist and arm pain recently.

They also seem to have killed the variable resistance on keys (or at least tuned them differently). The only key I notice that’s harder resistance is the backspace key, whereas the space key used to have a lot more resistance, and doesn’t all now. Perhaps the resistance has changed over time on my original one, so it’s just a matter of getting used to this one, or breaking it in more. Maybe it’s more expensive to do the bands of keys with different resistances, but I’m pretty sad about it, especially since this one ended up being about 30% more expensive than the original.

Oh, and the F and J have icky bumps instead of being nicely scooped. :( I’m guessing that one was a concession to people who weren’t very good typists, and couldn’t find the home row, but I prefer the scoops, since we are going for “stealth” here, after all. They just felt nicer on your finger tips too.

The sound of the switches has changed too, but that’s just… different, not really better or worse.

I’m going to guard my old one even more carefully now with the knowledge that they’re not really replaceable. Hopefully I’ll grow to love the new one as much, but the jury’s still out.

Problems with Vinagre

Sat, 26 Jul 2008 13:20:00 -0700

So, the default remote desktop app in Ubuntu changed from, um, I don’t know what actually, to a new app called “Vinagre”.

You’d think that’d be something I wouldn’t give a patooty about. The first thing you notice is that it has a list on the side that lets you keep track of servers you connect to which seemed nice enough.

I didn’t use it much at first, so I thought nothing more about it.

Today, I started using it. Dear god:

Tried to connect to a fully up-to-date Fedora box (from a fully up-to-date Ubuntu). vino-server crashes on the Fedora machine. I don’t know who’s fault it is, but I don’t really care. Working around that by using XDMCP for the time being, but that’s pretty irritating, interface-wise.
While repeatedly trying to connect to the Fedora box (it silently fails on the Ubuntu machine), Vinagre doesn’t save the last-entered machine name, so I have to keep entering “192.168.0….” every time. Irritating.
Insanely hard to send Ctrl-Alt-Del to log into Windows machines. For same reason, Ctrl-Alt was chosen as the “Capture/Release” input. So, in order to send Ctrl-Alt-Del to login to a Windows box, you have to first focus the Viagre app (click/whatever), then make sure you’ve uncaptured the input by doing Ctrl-Alt, then finally, recapture the input by doing Ctrl-Alt again, and then without letting go of Ctrl-Alt, press Del to get the final combo. If you just push that combo of course, the Ctrl-Alt first removes capture, and then sends Ctrl-Alt-Del to the local machine. Not very intuitive, especially since there’s very little (no?) indication of whether input is captured.
Related, there seems to be absolutely no way to send F11 to the client machine. The general hotkey behaviour is irritating enough as it is: Alt-F4 closes either all of Vinagre, or an app on the client, depending on whether you’ve pressed Ctrl-Alt recently, with no indication of which “mode” you’re in). But, it seems that F11 is even worse. If you’re in captured mode, then most things seem to be sent to the target machien, but apparently F11 was deemed too important to be handled normally, and there’s no configuration mechanism. Fine, until I try to debug something and naturally hit F11 to “Step Into” a function.
[Update] When input is captured, there’s no way to scroll the virtual desktop if it’s bigger than your current monitor. WTF?

Basically, it just seems like this app was pushed out way too quick to the main/default user stream. Please give me back my old VNC/RDP viewer. :(

Windows iTunes

Sat, 12 Jul 2008 13:46:56 -0700

I genuinely don’t understand.

I’m not trying to be difficult. I really tried to use iTunes this time. It seemed like the march of inevitability if I wanted to get iPhone apps, and I thought perhaps it would be nice to use. I grabbed the new 7.7 that has iPhone apps, since I wanted to have a look at what was available. It was a little large at 60meg, but hey, whatever, there’s lots of bandwidth to go around these days.

First of all, I had to reboot after installing it. Insane. Strike one. If that was it, well fine. But it’s completely unusably slow on my laptop. The laptop is about 2 years old. It was Dell’s top-of-the-line (XPS M170) when I bought it, so it’s not crazy fast, but it’s not so slow either. I’m pretty sure that it’s still well above the current median machine in performance.

I added my music collection (largely stored on a network drive). It’s about 65 gig, comprised mostly of mp3s and flacs, both ripped from CDs and downloaded. Maybe a little larger than some collections, but certainly not unreasonably large.

I started the “Import” last night around 8pm. It’s now 2pm the next day, and it’s still trying to download album artwork. That’d be fine, except that apparently while it’s doing that, it’s impossible for the UI to be responsive. WTF! Is this goddamn amateur hour? It only refreshes the UI at the end of each attempt to download an album cover?!

Pausing or unpausing music, or changing the volume (since apparently it feels the need to steal the functionality hardware media keys) takes over 10 seconds. That is not hyperbole! It actually takes longer than 10 seconds for anything to happen. On top of that, the mouse event handling also appears to be “sampling” rather than using the event queue properly, because if I just click the play/pause button nothing happens. I have to hold the fucking mouse button down until the UI responds (10 to 15 seconds, remember!), putting the button into the down state, and then release it.

On a side note, iTunes.exe currently owns roughly 300 threads, and has had a continuous IO delta of around 500k/sec for nearly 24 hours now. Jumped up Jesus Christ. You’re not controlling air traffic, you’re cataloging and playing some fucking music.

If this is Apple’s shitty attempt to create some sort of Mac “halo”, they’ve failed miserably. With 100% certainty, I will never, ever, by a Mac with this as the demo of the user experience.

Project Euler, problem #10 in F#

Sat, 12 Jul 2008 13:23:31 -0700

Problem’s quite simply stated this time:

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

First typed in solution was simply:

[2..1999999]
|> Seq.filter(isprime)
|> Seq.fold1(+)

Which got me a number pretty quickly that looked lovely, but was completely wrong. I ran it again, apparently hoping that’d it magically be right the second time. Then I tried for those below 1000000 instead and the sum was negative. Oops! So, the quick fix and working version (changing the “int” range to “bigint” range):

[2I..1999999I]
|> Seq.filter(fun x -> isprime(int x))
|> Seq.fold1(+)

I wonder if there’s a checked-overflow-arithmetic version of F#? Might be useful for some of these questions, since they’re so computationally light anyway.

FSharp Euler #9

Sat, 24 May 2008 10:56:01 -0700

The problem statement:

A Pythagorean triplet is a set of three natural numbers, a
a² + b² = c²
For example, 3² + 4² = 9 + 16 = 25 = 5².

There exists exactly one Pythagorean triplet for which a + b + c = 1000.

Find the product abc.

This is another one that’s probably really more “math”-y than programming-y, but I’m enjoying using my new F# hammer to solve these, so might as well keep at it.

It seems like another nice make-a-sequence-and-then-filter-it, but just doing 1..1000 for a, b, and c, results in an awfully big sequence (a billion long). So, a couple simple observations to make the numbers a lot smaller. The main one is that you can just make c = 1000 - a - b, since we know that all answers have to have that form anyway, and then we know a

seq { for a in 1..1000 do
        for b in a..1000 do
            let c = 1000 - a - b
            yield (a,b,c) }
|> Seq.first(fun (a,b,c) -> if a*a + b*b = c*c then Some(a,b,c) else None)

Voila!

Euler #8 in FSharp

Mon, 19 May 2008 13:59:00 -0700

The problem:

Find the greatest product of five consecutive digits in the 1000-digit number.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Treating it as a number is probably not going to be too pleasant.

let prob8num = "7316 ... 52963450"
let chars = prob8num.ToCharArray() |> Array.map(fun x -> Char.code(x) - Char.code('0'))
let rec prob8 (rest : array) =
    if rest.Length     else
        let tl = Array.sub rest 1 (rest.Length - 1)
        let curProd = Array.sub rest 0 5 |> Array.reduce_left( * )
        Math.Max(prob8(tl), curProd)
prob8 chars

So, store it as a string, but then convert it to a character array, and map to the actual numerical values (assuming ASCII I guess).

From that, just a simple recursive solution that does way too much Array.sub’ing. It would make much more sense to use List’s instead of Array’s for all of those .subs, but, there was no sub extraction built into List so I just did it that way instead.

I wrestled a little with the syntax of F# again in this question. I tried putting the “let tl” as inline into the body of the call to Math.Max, but I couldn’t get it to work correctly. Not sure what the required syntax is, maybe I need some of the keywords that I don’t know from non-#light yet?

Also, my copy of Expert F# has arrived, so I’m just starting to peruse it now. Hopefully my code will become more idiomatic soon enough.

And man, do I hate blog software’s handling of code. You’d think that maybe if I typed a less-than sign they could figure out how to escape it moderately properly, but apparently that’s way to complicated. Idiotic.

Project Euler, problem #7 in FSharp

Sun, 18 May 2008 17:04:11 -0700

The problem is:

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6^th prime is 13.

What is the 10001^stprime number?

Well, this sort of looks like another one that’s intended more for pencil-and-paper solvers than programming-language solvers. But, maybe prime #10001 is very big, so it becomes a problem for code too. My first thought is just to loop with a counter until we find the 10001st number, but that involves variables which I’m apparently trying to avoid in these problems. I didn’t get to use infinite lists in the last question, so let’s try again:

let rec getprime(n) =
    if n = 1 then 2
    else
        let prev = getprime(n - 1)
        Seq.init_infinite(fun x -> x + prev + 1)
        |> Seq.find(isprime)getprime(10001)

First, we assume we have the previous prime (say it’s “11”). Then, we generate an infinite list starting at the next number (i.e. [12..inf]). Then, find the first number in that list that’s prime, which is the prime after the previous one, which is the one we’re looking for. Finally, take that functionality and wrap it in a recursion stopping at prime #1 = 2 and we’re done.

When I first typed this code in, I messed up the initial value for the start of the sequence as (x + prev), which of course meant it kept finding “2” as the answer. Just a dumb mistake, but the interesting part is that I’d forgotten I even had a debugger since I was getting so used to using FSI to run bits of code. In the end I found the mistake by replacing Seq.find with Seq.nth(0), and adding a couple Console.WriteLine()s.

It’d be really nice if there was a way to put focus onto the FSI tab window though. I find myself defining functions by using Alt-Enter on the body of the function in the text editor, and then wanting to switch to the window to try passing it a few values to see how it works. Without a shortcut, I have to grab the mouse, click in the right place, sometimes Ctrl-End to find the prompt, etc. Maybe I just haven’t found the key yet, not sure.

Euler Project in F#, problem #6

Thu, 15 May 2008 11:08:48 -0700

Kick it, Euler:

The sum of the squares of the first ten natural numbers is,
1² + 2² + … + 10² = 385
The square of the sum of the first ten natural numbers is,
(1 + 2 + … + 10)² = 55² = 3025
Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Not much to this one. I learned about the exponentiation operator which seems to be a rewrite to calling a Pow method (it doesn’t seem to work on int). Here’s a “my brain is currently warped into thinking about everything as a sequence and operations on sequences”-solution:

([1.0..100.0] |> Seq.fold (+) 0.0) ** 2.0
- ([1.0..100.0] |> Seq.map(fun x -> x*x) |> Seq.fold(+) 0.0)

See y’all next time.

Euler is streaking in F#, problem #5

Tue, 13 May 2008 21:44:39 -0700

Problem #5:

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest number that is evenly divisible by all of the numbers from 1 to 20?

Speaking of infinite sequences, here’s the solution that seemed obvious to me at first.

open Microsoft.FSharp.Math
Seq.init_infinite (fun x -> BigInt.FromInt32 x)
|> Seq.find(fun (x:BigInt) ->
    x > 1I && Seq.for_all (fun (n:BigInt) -> x % n = 0I) [1I..20I])

Nice and simple, just iterate through all numbers, and find the first ne that’s evenly divisible by all the numbers from 1 to 20. Unfortunately let it run for an hour (!) while I had dinner, and it hadn’t completed. I just assumed was doing something dumb, but it seems to give sensible answers for the numbers in the range of 1..10 and 1..16. Apparently, at 1..17 or more though the answer becomes “quite” large. The first version just used int32’s rather than BigInt; I thought perhaps it was getting past 2^32 and so never finding the answer, but it’s hard to say since I wasn’t prepared to wait any longer for the BigInt version to finish.

As a side note, the bigint stuff is a bit ugly in this example, I guess an unfortunate side effect of .NET showing through where the numerical stack is fractured (sensibly and everything, just a little unfortunate here).

In any case, a more mathematical and less brute-force algorithmic approach seems to be required for this problem.

Here’s one that takes only milliseconds to run based on:
http://en.wikipedia.org/wiki/Least_common_multiple#Alternative_method

let rec numTimes(x, p) =
    if x % p = 0 then numTimes(x / p, p) + 1
    else 0
let maxNumTimes p =
    let num = float([1..20] |> Seq.map(fun x -> numTimes(x, p)) |> Seq.fold(max) 0)
    int(Math.Pow(float(p), num))
[1..20]
|> Seq.filter(isprime)
|> Seq.map(maxNumTimes)
|> Seq.fold1( * )

For all primes in the range, figure out the maximum number of times that prime appears in the prime factorization of any of the numbers, and find the product of those primes raised to the maximum number of powers. I learned a little F# in this one, but as far as the math, it would have taken me a long while to recall or figure that out, so it was basically just implementing what Wikipedia described. Oh well.

My “fold” got one better again, instead of passing a pointless anon function and a pointless initial value, last time I got rid of the function. This time I found “fold1” and got rid of the non-useful initial value too! :)

"… Because we couldn’t see how the system worked anymore! Small systems are not only..."

Tue, 13 May 2008 00:56:48 -0700

“

…

Because we couldn’t see how the system worked anymore!

Small systems are not only easier to optimize, they’re possible to optimize. And I mean globally optimize.

So when we talk about performance, it’s all crap. The most important thing is that you have a small system. And then the performance will just fall out of it naturally.

”

- http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html

Some more Euler Project, problem #4

Mon, 12 May 2008 21:15:00 -0700

This one was pretty straightforward.

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

The hardest part was just reversing the number to be able to tell if it was a palindrome. Unfortunately, when I searched for “reverse string f#” I got http://basildoncoder.com/blog/2008/04/21/project-euler-problem-4/ which while certainly a good search result, could have ruined the fun. Anyhow: the solution to reverse (why the heck isn’t there a .Reverse on the .net string anyway?) is the obvious thing. The only thing notable thing here is the “:string” on the argument to the function which is the first time I’ve had to write a type other than the type coercions from float <-> int. It reminds me of the irritating problem with C# generics where it’s often not possible to write the generic function because it has to be completely generic, or has to implement an interface so the type can be where-constrained (or in other words, generics are generics, not templates, I guess. The C++ approach definitely has benefits, sometimes, though.)

let rev (s:string) = new string(Array.rev(s.ToCharArray()))

{ for i in [100..999] do
    for j in [100..999] do
        let x = i * j
        if x.ToString() = rev(x.ToString()) then yield x }
|> Seq.fold(max) 0

After that, it’s pretty simple. I just make a list of all the palindromes created from 3 digit multiplicands, and then fold out the maximum of those. I noticed something very dumb in the last solution, I was folding an anonymous function that just directly passed its arguments to max, which is of course silly. I’m finding F#’s syntax a little weird, but getting better.

It occurs to me after reading Mr. Basildon’s solution that I don’t know the difference between Seq, List, etc. and when it matters. Maybe it’s just that seq can be infinite, vs. List is strictly an actual memory block?