# Phillip Trelford's Array

## POKE 36879,255

This weekend I had the pleasure of sitting on the Ocean Q&A panel at Revival 2014 in Wolverhampton. I worked at Ocean in Manchester in my early 20s on titles like Jurassic Park (PC & Amiga) and Addams Family Values (SNES & Megadrive). It was fun to reminisce about the good old days with other former Ocean employees and people who’d played the games.

The panel closely coincided with the public release of The History of Ocean Software book by Chris Wilkins which was funded as a Kickstarter:

There were plenty of old games to play at the event too. I particularly enjoyed Rez on a PS2, Omega Race on a Vic-20 and a Flappy Bird clone on a Commodore 64.

When we got home, my 7yo and I pulled the Vic-20 out of the garage, and played some more Omega Race with the joystick we’d just picked up:

My 7yo has been picking up Python recently, with a Coding Club - Python Basics book.

One of the tasks is to print out the 5 times table:

```number = 1
while i <= 12:
print(number,"x 5 =",number*5)
number = number + 1```

Funnily enough Vic-20 Basic (circa 1981) was easily up to the challenge too:

And good old FizzBuzz was no bother either:

Then my son had a go at Magic 8-ball, but sadly lost the code he’d spent a while typing in when it is closed, so we re-wrote it again in F# so there was less to type:

```let answers =[
"Go for it!"
"No way Jose!"
"I'm not sure. Ask me again."
"Fear of the unknown is what imprisons us."
"It would be madness to do that!"
"Only you can save mankind!"
"Makes no difference to me, do or don't - whatever."
"Yes, I think on balance that is the right choice"
]

printfn "Welcome to Magic 8-Ball."

printfn "Ask me for advice and then press enter to shake me"

for i = 1 to 4 do printfn "Shaking..."

let rand = System.Random()

Why not dig out your old computers and have some programming and games fun! :)

Last month Grant Crofton popped down from Leeds to the F#unctional Londoners meetup at Skills Matter to run a fun hands on code golf session. The idea of code golf is to implement a specific algorithm in the fewest possible characters. This is not the kind of thing you should be doing in enterprise code, but it is fun, and an interesting way of exploring features in a programming language.

On the night we attempted condensed versions of FizzBuzz and 99 bottles of beer, with Ross and I winning the first challenge and Simon & Adrian the second.

Thanks again to Grant for a really fun session.

F# FizzBuzz

A while back I strived to squeeze an F# implementation of FizzBuzz into a tweet, and with white space removed it weighs in at 104 characters (excluding line breaks):

`for n=1 to 100 do `
` printfn"%s"`
`  (match n%3,n%5 with 0,0->"FizzBuzz"|0,_->"Fizz"|_,0->"Buzz"|_,_->string n)`

The implementation, although quite clear, requires a fair number of characters for the pattern matching portion.

After some head scratching we came up with the idea of using a lookup to select the string to display:

 N %3 N % 5 Index Output 0 0 0 N >0 0 1 “Fizz” 0 >0 2 “Buzz” >0 >0 3 “FizzBuzz”

This took the implementation down to 89 characters (without line breaks):

`for i=1 to 100 do`
` printfn"%s"["FizzBuzz";"Buzz";"Fizz";string i].[sign(i%5)*2+sign(i%3)]`

Another trick is to abuse the sign function, to get 1 if the result of the modulus is above 0 and 0 otherwise.

The lookup trick can be used in other languages, and here’s a few examples, just for fun.

VB.Net FizzBuzz

VB.Net has a reputation for being a little verbose, but using the lookup trick it was possible to it get down to 96 characters (excluding line breaks):

`For i=1 To 100:`
`Console.WriteLine({i,"Fizz","Buzz","FizzBuzz"}(-(i Mod 3=0)-(i Mod 5=0)*2))`
`:Next`

In VB.Net true values translate to –1 and false to 0. This allowed me to simply negate the result of i % N = 0 to compute an index.

Python FizzBuzz

Using a similar trick in Python, where true translates to 1 and 0 to false, I was able to get to a very respectable 79 characters (excluding line breaks):

`for x in range(1,101):`
` print([x,"Fizz","Buzz","FizzBuzz"][(x%3==0)+2*(x%5==0)])`

Python’s simple print function also helped to keep the character count down.

Amanda FizzBuzz

Amanda is a variant of David Turner’s quintessential functional programming language Miranda. Amanda runs on Windows, and is used for teaching FP at some universities.

Using a list comprehension it was possible to squeeze in to a mere 67 characters:

`[["FizzBuzz","Buzz","Fizz",itoa x]!(min[1,x%3]+min[1,x%5]*2)|x<-[1..100]]`

Note: this is cheating a little as we are not explicitly writing to the console.

APL FizzBuzz

APL is a very mature language, dating back to the 1960s, and is still used commercially today. It also wins hands down in code golf with just 54 characters:

`⍪{'FizzBuzz' 'Buzz' 'Fizz'⍵[1+(2×1⌊5|⍵)+1⌊3|⍵]}¨⍳100`

APL is particularly strong at matrix processing and provides single character representations for common operations:

 Notation Name Meaning ⍳B Index generator Creates a list from 1 to B ¨ Each for each loop ⍪ Table Produces a one column matrix ⌊B Floor Greatest integer less than or equal to B

Try APL in your browser now.

Challenge

Can you beat the APL implementation of FizzBuzz?

Have fun!

When you want to set a date literal in F# (or C#) you create a new DateTime instance:

```let today = DateTime(2014,26,4)
```

If you’re rocking VB.Net you get date literals which are checked at design & compile time:

`Dim d = #2014/04/26#`

I thought it’d be nice to add design and compile time checked date literals to F#, & throw in code completion for good measure. Enter F# Type Providers. No need to open millions of lines of compiler code, instead simply implement a class to provide the types & voilà:

`let today = Date.``2014``.``04``.``26```

As you type the date, you can only enter valid values:

Or you can for example use it to easily find the last Saturday of the month:

The code is up on BitBucket & there’s a Nuget package, it’s pretty simple, less than a 100 lines of code, and no compilers were harmed in the process. Being what it is, this is really just scratching the surface of the power of F# Type Providers, which can give you typed access to data from web services or databases all the way through to other languages.