The challenge was first posted here. The problem is as follows:

Write a counter function that counts from 1 to max but only returns numbers whose digits don't repeat.

For example, part of the output would be:

* 8, 9, 10, 12 (11 is not valid)
* 98, 102, 103 (99, 100 and 101 are not valid)
* 5432, 5436, 5437 (5433, 5434 and 5435 are not valid)

Also:

* Display the biggest jump (in the sequences above, it's 4: 98 -> 102)
* Display the total count of numbers
* Give these two values for max=10000

So without further ado, here's my solution:

import Data.List
 
noDups :: String -> Bool
noDups l = length l == length (nub l)
 
items :: [Int]
items = filter (noDups . show) [1..10000]
 
main :: IO ()
main = print $ (maximum (zipWith (-) (tail items) items), length items)

It's probably not as concise as it could be, and I'm sure a more experienced Haskeller would be able to tidy it up a little bit. Despite that, it still performs quite well:

Thu Jul 24 21:34 2008 Time and Allocation Profiling Report  (Final)

	   main +RTS -p -RTS

	total time  =        0.00 secs   (0 ticks @ 20 ms)
	total alloc =   4,121,500 bytes  (excludes profiling overheads)

COST CENTRE   MODULE   %time %alloc

CAF           Main       0.0  100.0

                                            individual    inherited
COST CENTRE   MODULE       no.    entries  %time %alloc   %time %alloc

MAIN          MAIN           1           0   0.0    0.0     0.0  100.0
 CAF          Main         152          14   0.0  100.0     0.0  100.0
 CAF          GHC.Handle    88           4   0.0    0.0     0.0    0.0

Thoughts? How could I make this better/faster/more elegant? I'm keen to get some insight from a more experienced Haskell coder Cheers!

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.

Plus, the first keygenme that I've ever written is now approved and available for download. So if you're up for a 64-bit RCE challenge, go check it out (or download it directly from here).

Feel free to let me know how good/bad/ugly you think this stuff is!

Write a program that asks the user for their date of birth using the date format YYYY-MM-DD (eg. 1978-12-05 in my case). The program should respond by telling the user what day of the week they were born on.

You're allowed to use any language you want, but you're not allowed to use the built-in date object functionality other than to determine the current system date. That is, you can't date difference functions to determine time that's passed. You have to figure that out for yourself.

For those C# coders, don't even think about posting: dateOfBirth.Day You're supposed to do the hard bit yourself

Anyway, it's easy peasy Don't forget about leap years and stuff! I look forward to seeing your answers. I'll post up a solution in a week or so. Let me know if I haven't been clear.

Your job is to write a program that generates a text-based ruler. For a clearer definition of what I mean, see the little text pic below:

|                               |                               |
|               |               |               |               |
|       |       |       |       |       |       |       |       |
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

The user of the program must be able to specify a couple of parameters: those being the height of the ruler and the number of sections in the ruler (at the top level). In the above example, the values would be 6 and 2 respectively. Another example, using the values 3 and 3 would result in:

|   |   |   |
| | | | | | |
|||||||||||||

The only other thing that you have to do is make sure that your solution uses recursion instead of iteration. Feel free to use any language you want, you can write to screen or to file, it's your call. But you must use recursion.

I look forward to seeing your responses. Happy coding!

So as well as having lots of industry-specific rants, posts on what's considered good and bad, and large chunks of text relating to experiences while out on site working for clients, I thought it'd be a good thing to post some other bits and pieces that are a bit more light hearted, and dare I say it... FUN!

Way back before I went to the U.K. I used to have a site up and running that had a small community of people interested in programming - specifically game development. While this site is long gone, never to be remembered, there were a few things that we used to do there which I thought were really good. One of which was listing programming challenges. Every now and then I'd come up with (or rip off) a programming challenge that I thought would be a good exercise for members of the community to undertake. It was surprising how many people were interested, and we ended up with many responses and submissions containing solutions to the problems.

The beauty of it was that people learned a lot from the exercise - especially from each other's varied approaches. They would come up with a solution and be eager to post it. After noticing that someone else had created a "better" solution than them, members would go away and try and improve what they had. It was great, as it bred a mindset of iteration and improvement, and over time most of the community members ended up being comfortable with the idea that their first solution generally isn't perfect and they immediately look to make it better.

I'm of the view that the first solution that you write to solve a given problem is designed to give you a better understanding of the problem space. Sure, it's not always the case that you can throw away the code you've written (depending on what you're working on, and what timelines you have to adhere to), but if you can it's a good idea to do it and start again fresh with the knowledge you've gained from your first attempt.

I would like to get this type of thing going again. I'm going to get some ideas together for problems and start posting them here for other people to have a stab at. I'll be giving some of them a go as well, and if people are interested in sharing their solutions and discussing them, they can post their solutions as comments. If the idea becomes popular and the number of submissions goes up, then I may think about setting up a basic Coding Challenges forum for the discussion and submission of the problems and solutions. If people don't like it, I'll probably continue to post them anyway just in case someone at some stage finds them as interesting as I do If anyone's interested in seeing my solution, then I'd be happy to post it.

The problems themselves will most likely be small. I won't be suggesting that people should go away and write a 3D rendering engine just to see the frames-per-second they can achieve on a 386! The problems will have a very small scope - meaning that solutions can be built quickly, and people won't feel that they need to put a massive amount of time in to get the results required. Hopefully they'll be quite challenging despite being small in stature.

One thing I will attempt to do when writing these problems up is make sure that the specification forces the programmer to do as much of the work as possible - without relying on the supporting framework or library set that comes with the language. In general the problems will not have a target language (or language set), but there may be cases where I state that the problem is intended to be solved using C++ or Miranda!

I hope that you'll find the challenges interesting, and that you'll perhaps find the time to give a few of them a go to exercise the mind. I think some of them will be more useful to beginners learning the ropes of development, but I can't see why experienced programmers shouldn't give them a shot. There's always the possibility that we'll learn something.

So let's begin with the first one that's popped into my head. It's a bit of a classic problem, but there's still a chance that people out there might not have heard it before - or more importantly attempted to solve it themselves in code. I first heard about this problem through a friend of a friend of a friend of a ... you get the idea

Challenge #1 - Linked List Loops

"What do you think is the most efficient and resource-friendly way to determine if a singly-linked-list contains a loop?"

When you have an instance of a linked list, it is usually NULL-terminated, that is, the last reference is a NULL reference which tells you that the end of the list has been found. The question asks how you determine if the list is not NULL-terminated, instead the "last" item in the list points back to another item in the list (thus creating a loop in the list).

To solve this problem you will need to have an understanding of Singly-linked lists. You don't need to write code, I'm just interested in the algorithm you'd use.

Sounds easy, and there are quite a few ways of doing it. So give it a shot! I'm interested to see what you guys come up with.

Happy problem solving!