Seems the author was not interested and this is now retired.

So, here we go:

• no random tests
• only one non squared grid
• no actual performance tests: only a wrong algo could fail (even if the crude one may fail from time to time, if the user is out of luck)
• the signature of the solution setup is wrong: int width, int height, int startCol, int startRow, int endRow, int endCol should be int height, int width, int startRow, int startCol, int endRow, int endCol to be able to pass all the tests

So now, about those perf tests and random tests... @sendelufa: do you know how to use a better algorithm? And do you know how to mplement random tests?

Note: again, your kata is too close to a lot of others. The one I linked, but it's actually too close to any kata related to that kind of algo (and we already have a lot of them, as I said below). So I still believe that you should unpublish it.

cheers

note: we already have a lot of katas about those algorithms, tho. Even the more efficient one... so is that actually a good idea...?

closing here, reopening with more infos.

well, why not... But there are a lot of things to tackle on this one, for now (to make it worth of an approval)

True, but if we considering this as harder version of another kata, there's plenty of other katas with same problem (that have harder versions) =/ And they get approved - no problem :P Should this one? Idk...

sort of, yes. But there would still be the problem that a solution to this could solve the other one.

Btw, assuming random tests are added (and enough of them), that could push the kata to a spot where it can be considered valid. It's up to the author now :>

Yes, many bits ;)

"a lot", you mean. ;)

Ye it was a basic algo, took around the same time for both, meaning duplicate, unless tests are ramped up a bit.

na, the real questions are: did you prune your code from the most efficient parts? Or did a basic algo solve the beta too? If so, the present one is definitely a duplicate (no additionnal perf requirements). Note: I didn't go read your code so I don't know what approach you used.

Maybe :> In my defense, I didn't know there were alternative solutions :P

soooo... Did you just spoiled the present beta by posting your solution there? x)

I just tried the other kata and I'm afraid it's very close to a duplicate =/ Essentially it's the same task, except:

• 8x8 grid vs NxN (N up to 1000) grid
• different representation of inputs (chess board notation string vs numbers of indices)
• The other kata always has a solution, this one doesn't.

I'm not sure if that's enough to differentiate between the 2 =/ Because the board is so small for the other one, there may be simpler algorithms and bruteforcing, but not here.