The problem is as follows:

Your input is a string which is composed from bracket characters. The allowed characters are:’(', ‘)’, ‘[', ']‘, ‘{’, ‘}’, ‘<’ and ‘>’. Your mission is to determine whether the brackets structure is legal or not.

Example of a legal expression: “([](<{}>))”.

Example of an illegal expression: “({<)>}”.

Is what I'm about to show the most efficient? No. Is it the most elegant? Hell no! But it works

It's surprisingly similar to this solution over at Fsharp.it. It is different in that it allows non-bracket characters to be entered into the string as well.

#light
 
let parens = [| ('(',')');('[',']');('{','}');('<','>') |]
let isOpen l = Array.exists (fun(o,c) -> o = l) parens
let isClose l = Array.exists (fun(o,c) -> c = l) parens
let isPair p = Array.exists (fun l -> p = l) parens
 
let validate inp =
  let rec v' str stack =
    match str with
    | [] -> stack = []
    | c :: cs when isOpen c -> v' cs (c :: stack)
    | c :: cs when isClose c ->
        if isPair ((List.hd stack), c)
            then v' cs (List.tl stack)
            else false
    | c :: cs -> v' cs stack
  v' (List.of_seq inp) []

Call the function like so:

validate "thisIsAFunction(int[] foo, delegate{}, bar()); // < testing >"

In short, the function uses an internal "stack" (which is actually a list) to keep track of open brackets. When a closed bracket is found, it's validated against the open bracket at the top of the stack.

Fairly simple stuff. There are optimisations that can be made around the searching for items in the parens array, but I couldn't be bothered changing it For me at the moment it's more about playing with F#.

Thoughts?

The question apparently originates from an interview that someone had with Google, and goes something like this:

There is an array A[N] of N integers. You have to compose an array Output[N] such that Output[i] will be equal to the product of all the elements of A[] except A[i].

Example:
    INPUT:[4, 3, 2, 1, 2]
    OUTPUT:[12, 16, 24, 48, 24]

Note: Solve it without the division operator and in O(n).

Since I had a spare 10 minutes, I decided to give it a shot ... in Haskell.

I'll cut to the chase, here's the source to my solution:

vals :: [Int]
vals = [ 4, 3, 2, 1, 2 ]
 
answers :: [Int]
answers = [ front !! (x-1) * back !! (x+1) | x <- [1..length vals] ]
  where
    front = scanl1 (*) temp
    back = scanr1 (*) temp
    temp = [1] ++ vals ++ [1]

I'm hoping that this is quite self-explanatory. But in case it's not, I'll cover some of the gory bits.

The core of the problem is coming up with a way of determining the value of the product of numbers from the start of the list up to a given index, and to do the same at the other end of the list from that given index.

I thought that the easiest way would be to create two lists: both of them containing the compounded products of the numbers in the list, but each of them in different directions. To generate those lists, I thought that I'd add the value of 1 to the list, both at the start and at the end, as it would allow me to do two things:

1. Generate the lists using the scanl1 and scanr1 functions.
2. Index into the list using a counter that's based on the size of the original values without having to worry about going past the bounds of the list.

Yup, quite lazy, but very handy.

Here's the output when I execute answers in GHCi:

Prelude> :l google.hs
[1 of 1] Compiling Main             ( google.hs, interpreted )
Ok, modules loaded: Main.
*Main> answers
[12,16,24,48,24]
*Main>

Problem solved in O(n). Neato! After feeling rather chuffed with myself I thought I'd go back to Fsharp.it and check out the answer posted there. The principle was similar, but the implementation listed was a little longer.

So I thought I'd have a go at writing up my solution using F#. It didn't seem like a stretch until I realised how little of the language I know (I'm currently reading through Expert F#, but I'm still far from being one myself). Here's what I came up with:

#light
 
let vals = [ 4; 3; 2; 1; 2; ]
 
let mul a b = a * b
let (++) = List.append
 
let answers =
  let temp = [1] ++ vals ++ [1]
  let front = List.scan1_left mul temp |> List.to_array
  let back = List.scan1_right mul temp |> List.to_array
  seq { for x in [1 .. vals.Length] -> front.[x-1] * back.[x+1] }

A few things you might notice:

1. My syntax highlighter plugin doesn't currently support F#
2. I use a similar method to the Haskell solution, but ended up having to convert the front and back lists to arrays. The reason was because I need to be able to index into the resulting integer set, and I can't do that with lists (if I'm wrong, please let me know!)
3. I defined a function called mul which does a simple multiplication. I wanted to pass (*) as the first parameter to the scan1_* functions, but the interpreter took that as the start of a comment instead! So I had to resort to a dodgey hack. If you know a way around this, please let me know.
4. I wrote my own (++) operator because I didn't want to have to write List.append more than once

In other words, my F# version smells like n00b. I'm sure there are so many better ways to implement this using the built-in features of the language and supporting libraries, but I'm yet to get to the level when I can write it. I'd love for someone to show me how

I did enjoy having a dabble with F# for the first time in ages, though I have to admit I much prefer using VIM and fsi.exe instead of Visual Studio and the interactive F# add-in.

As always, feedback and criticism welcomed (and needed).

Update

After some great feedback (see below), I've come to realise that the !! operator in Haskell is actually O(n) itself. Hence it was a bad choice for inclusion. Back to the drawing board for me!

Here are a couple of submitted Haskell solutions.

-- by lf
scanm f z xs = zipWith f (scanl f z xs) (tail $ scanr f z xs)
main = print $ scanm (*) 1 [4,3,2,1,2]
 
-- by Henning
answers :: [Int] -> [Int]
answers vals = zipWith (*) front (drop 1 back)
	where
	front = scanl (*) 1 vals
	back = scanr (*) 1 vals
 
-- by desp
problem input = zipWith (*) front back where
  front = init (scanl (*) 1 input)
  back = tail (scanr (*) 1 input)
 
-- by foobar
foo [] _ = ([], 1)
foo (x:xs) acc = let (l, m) = foo xs (acc*x)
                 in ((m*acc):l , m*x)

Thanks for the submissions guys Sorry for not including the imperative versions in the update.

The well-respected secretGeek, also known as Leon Bambrick, is going to be giving an introductory talk on the F# language tomorrow night, Tuesday 18th March at 6pm. If you're keen to go, best check out the link and register your interest. It'll no doubt be a great presentation by someone who's not only smart but a bloody nice chap to boot.

If you have time, make sure you tag along. You won't regret it! I might even see you there if I can shake this damned cold!

I'm dedicating this post to all those things that I currently find interesting and would love to invest time in. Some of these things are old, some new. All of them I've either not touched on at all, or have touched on only briefly (not enough to be satisfied). I thought I'd share them with you in case you find them interesting yourself, or perhaps have some insights which you'd like to share.

Haskell

Haskell is a fairly well-known functional programming language that's been around for quite some time. It's extremely powerful, and it is a lot of fun to work with. I'm certainly no expert in Haskell-land, but so far I've been able to do some fairly nifty stuff. I've been ploughing through the Project Euler challenges using Haskell and I've been amazed at how concise the solutions can be. I have a lot more to learn, and I'm hoping that I'll get the chance to do just that. If you haven't played with a pure functional language before then give this one a spin. There are a selection of compilers out there, I personally use GHC.

F#

F# is a relatively new functional language that runs on the .NET platform. It was created (I believe) by a chap called Don Syme and is gaining momentum amongst the geek community. It looks like a lot of fun and is apparently extremely powerful. If it's anything like Haskell, then I'm sure I'll love fiddling with it ... especially when it's got the backing of the .NET framework to leverage from. For your info, I stumbled on this little doozy which is quite an interesting read.

ASP.NET MVC

I've dabbled with Ruby on Rails in the past, and while I liked it I wasn't "blown away" by it like so many other people. The Ruby language is a nice one to work with, but I feel that the interpreter needs a bit more work before I could consider it a serious choice for my needs. On top of that, Rails isn't exactly blisteringly fast. So when the ASP.NET MVC appeared I was excited at the chance to toy with something that would fit a similar mould to Rails (as far as structure is concerned) but based on .NET (allowing me to toy with a few different languages). I've been a ASP.NET WebForms dev for many years now, and I never really liked the Page Model. I believe that the MVC framework is a really good step in the right direction, and I hope that when the time comes, Microsoft decides to cull the old Page Model and push ahead with the MVC as the main ASP.NET development framework. I think that this is going to be "the way of the future" as far as web development is concerned, so it's definitely worth taking for a spin. There are stacks of resources out there to help learn, so if you've got time and have an interest in this sort of thing then check it out.

WPF

The latest fad from Microsoft in the rich-client area is WPF (Windows Presentation Foundation). I've always been an advocate for rich-client applications over web applications. Being a game dev geek and a fan of graphics with rich user interfaces, I'm always interested to play with new libraries and technologies that make it easier to develop such applications. It looks like a great technology that really does make WinForms look primitive. It's a worthy option if you're going to do some rich client dev.

Silverlight

Is it a killer for Flash? Who knows, but it's a worthy contender. Silverlight is essentially a direct competitor of Adobe's Flash product. It runs on the .NET platform (again) and is a subset of WPF (I believe, correct me if I'm wrong). It looks to be a viable way of getting rich interaction over the web.

Flash

As mentioned already, Flash is Adobe's product which delivers rich experiences over the web (they acquired it when they bought Macromedia). It's a cross-platform doohicky and runs on ActionScript. It's been around for a long time and has a huge established user-base. I have also heard rumblings that Adobe are going to be releasing a tool which allows you to write code in other languages (such as C++) and convert it to ActionScript for use in Flash. Pretty nifty really! I think it's a good move if they hope to stay in the game now that Sliverlight is a player.

Merb

Merb is a Ruby MVC development framework which is a viable alternative to Rails. If you're happy to ignore the performance issues of Ruby and feel the need to build a web application with it, I'd recommend checking out Merb. I've heard some really good things about it.

They're my current areas of interest. Feel free to post with stuff that's sparking your interest! Cheers.