Would it be interesting to add a batch of relatively small random tests that also output N on error, just to give users an idea in which phase of their algorithm their mistake is? Or is the fact this Query is a total black box part of the difficulty level and challenge of this kata?

Should error number 6 exist? Or does it make sense to translate a vector by another vector of a higher dimension?

If you change the specs on a kata that is actively being solved, maybe give people a heads-up in Discourse.

In Beta, sure, specs are fair game. And I fully understand you don't want to do it in the Description, which will be read for ( hopefully ) eternity by people who never saw a previous version of it. But changing the playing field under me grinds my gears. Taking out the "no touching" rule may materially affect solutions. Your Beta testers deserve fair warning of that, they are working for you finding things you didn't before you hit Publish.

( Yes, I am getting a bit fed up with all the problems this kata has. A lot of those you could have found yourself ( granted, maybe only if you hadn't started with something this complex as your first kata ) and could have been solved before you published. Your testers deserved better, the kata deserved better. /grumpy )

My [ first ] solution has a bug where it can wrap around edges looking for the next step. That wasn't caught by the random tests ( or any fixed test ), but it should be possible to compose a twisting, forking river that would expose that bug.

That test should then be added as a fixed one.

( Please invalidate my solution! :P )

You closed this issue because "you had invalidated my solution". Too soon.

My solution had myriad other uncaught problems and was not invalidated because you added the test I was asking for.

My new solution has ( at least some of ) the other uncaught problems fixed and addresses the wrapping problems - which part I then commented out and still passed all tests.

As long as my second solution passes tests with that part commented out, tests do not accurately target wrapping. When it fails, but passes with the commented part uncommented, that test works.

Keep in mind that the path that becomes possible only because of wrapping has to be longer than the longest valid path.

Also, please ask for verification that issues are solved if you're not going to accurately verify that yourself. "I shot at the bear. The bear is now dead." is not the same as "I shot the bear to death."

Random tests don't generate "trick" cases, and the fixed ones can be easily hardcoded. Without such cases this kata is effectively a yet another flood fill, and it should be unpublished as a duplicate unless the random test generator is improved.

Hi,

• The kata needs more fixed and sample tests. So far, your incorrect algo and a correct one are returning the very same results in all fixed tests, meaning you don't cover enough edge cases with them.
• In the random tests, the message of the it blocks is rather cryptic => HxW, N steps?
• In problems like this, the description should provide the characteristics of the tests, so that the user knows up front what are the needs in terms of performances. => typical sizes of the grids, typical number of steps, number of tests (and ideally, typical number of possible paths)

Cheers

In light of the backstory, wouldn't it make more sense if the volume only increased at a join?

Slightly different logic, but only slightly, I'd think.

Sources need not always start at 1 either. They'll still be unambiguously defined.

Forward generator is a duplicate of any fibonacci/tribonacci/n-bonacci kata (e.g. this ignoring the requirement to create an infinite generator instead of generating first n elements) out there; the backwards generator is practically the same thing except each window is reduced with (a, b) => a - b instead of (a, b) => a + b, so I wouldn't consider it any novel for that too.

If I understand correctly, unless the length of the input is 3, it will be a polynomial and I will already know the degree.

If it's length 3, it might be a linear or a geometric progression.

Maybe a little more randomness would be good?