Thanks MATLAB team, I’m already looking forward to the next time.

There will not be a late stage twilight in this contest. So it’s full daylight right to the end.

For anyone looking for a speed boost to that approach I recommend “Basic Bellman-Ford”.

I credit Oliver Woodford completely for the submissions I made to the 1000 Node challenge yesterday. I selected one of his earliest Dijkstra entries and reduced the node count to be less than 1000. I then slowly during the day added the small tweaks contained within the regular contest code. It could be seen I slowly pushed the 1000 node score lower until I had to leave for class. When I added the double to int data-type change that seemed to hold steady for quite some time until the rand function was introduced.

Unfortunately, unlike in any of the contests since I’ve been doing this, the leading code is so complicated I wasn’t able to fully understand or document it, even after spending several hours on it today.

Perhaps I’m just being dense lately, but I think part of the reason is there are some VERY sophisticated graph theory type calculations going on in the code, which I was having difficulty following. As a result, only about 80% of the code is documented, but that should be enough to give people a general idea of what’s going on.

Interestingly enough the cyc complexity and node counts of the code are equal to or less than what we’ve seen in other contests, so those aren’t really good measures this time around regarding the ‘readability’ of the code.

Hopefully this won’t discourage people from participating during the rest of the contest. If anyone with a better grasp of the various sections or graph theory is willing to pick up on commenting the code where I left off, I encourage you to!

score = k1*result + k2*e(k3*runtime) + k4*max(complexity-10,0) + k5*nodes

Where:

k1 = 0.01
k2 = 0.001
k3 = 1/12 (0.08333…)
k4 = 1
k5 = 0.001

The current leading entry has a time of 89s, result of 663581, cyc of 9, and nodes of 1961. Here’s a breakdown of the current tradoffs:

-cyc and score are a 1:1 ratio (i.e. each point shaved off cyc is a point shaved off the score)
-time and score are a 1:0.2 ratio
-result and score are a 1:0.01 ratio
-node and score are a 1:0.001 ratio

As is common at this point in the contest, Nick Howe’s entries have already settled in just below the ‘knee’ of the time exponential curve, which is rather flat until about ~110s. However, because of results are so high right now and change quite a bit with small tweaks, I think we are going to find more payoff in trying to reduce the results by searching the boards for a bit longer, at least until the times get up around the 120s range. Unfortunately that also means that during the various contest end times the queue is going to get very backlogged, since each entry will take several minutes to execute.

Sorry about that. I wrote the contest code in absolute indexing, and then changed it to match the rules. I pushed the absolute indexing version accidentally. My bad.

We just modified the rules to match the contest suite as it is on the File Exchange. Looks like some of the early entries figured it out and are doing well. Use ind2sub to convert to row column if you happen to need it.

sorry,
Doug

while in the distributed functions it is:
colors = solver(A,targetRowAndColumn)
This also fits the ‘testsuite_sample.mat’ is built.

What is the correct one (should we use a linear index of the target or subscripts)?

Thank you

Some of the intermediate challenges are predictable, but some of them are improvised. We’ll probably continue the tradition of a Sunday Push (best aggregate improvement over 24 hours by one player) and a Tuesday Leap (best single improvement over 24 hours). There will certainly be one or two others, but it’s hard to say exactly what or when.

Tell us your suggestions for a good creative intermediate prize.

The code will be uploaded when the contest starts at noon (Boston time) on November 4th.

Helen

It’s also a good learning experience for me. I learned how to manipulate text files using cell. By applying this new technique to my work I bet I can increase the efficiency of my company’s product by 50%, at least.

Cris: Good observation. The key is that I do not consider the correlation of the the programs, but the correlation of the *signature* of the programs. If the signature does not extract enough features from the programs, the self-correlation will be low. The signature that I used appears to be sufficient for a majority of the given test subjects, and I did not intend to make it too complicated.

I think it is weird, though, that an entry wins that computes correlation this way. Correlation of one program with itself should always be very high, I’d expect. It’s funny to see some very low values along the diagonal of the correlation matrices.

The optimization contests were getting a little long in the tooth, especially with the same people competing (and winning) every time. Let’s do this visualization one again!

http://www.mathworks.com/matlabcentral/fileexchange/23595
http://www.mathworks.com/matlabcentral/fileexchange/23596

They are actually both the same, I just messed up in zipping the file up on the first one and accidentally included the .asv instead of the .m file, so I corrected it. If you want to delete the first one so as to note ‘clutter up’ the FEX that’s fine by me.

I assume that entries which were submitted before noon, but not actually reviewed and approved for public posting before noon will still be allowed into the rankings?