Nope I seem to come to no proof. I bruteforced n=5 and can confirm that one is solvable but I could not see a pattern. If I was you I would try to formalize what that ring looks like and what you can do with it. I tried focusing on segments you can rotate:
A segment is part of the ring
If you rotate the ring, the bulbs in your segments shift to a side
At one side, rotating results in a bulb to disappear
At the other side, rotating results in a bulb to appear
If the ring is larger than your segment, the new bulb was not yet in the segment and can be either on or off
If the ring is as large as your segment, the appearing bulb has the state of the disappearing bulb
If the ring is smaller than your segment, the appearing bulb has the state of a bulb that is still in your segment (left bulb = right bulb if the segment is 1 larger than the ring)
That way you can focus on these key actions:
rotate left
rotate right
toggle the switch in the middle
And work with the bulb pattern and see if you can set all you can see to on. That’d be the proof. Because if the ring is larger, you can always rotate to the remaining bulbs and apply the algorithm again.
Rotating is actually what I was thinking of. I did not come to a proper proof for it but for any set of bulbs, rotating the segments can lead to a single bulb off. Then I tried to see whether I can do anything with rings that only have one bulb off, and I also considered the value n mod 3 as the switching changes the state of 3 bulbs.
If you can wait some more, I will look at it today again. Gonna write a test script that brutforces the shortest steps for lighting up a 8bit ring. Maybe the steps show a good approach you can conclude a proof from.
Was interested setting the script up so it is done already.
It generates unique starting situations (unique even when comparing rotated settings) and prints the shortest solution for a ring of 8 bulbs.
If you are interested, this is the script.
I kinda optimized it so it should not (always) time out if you hit Run.
You can try to find a pattern from that and generalize it to rings of other sizes. It seems the maximum number of toggles is equal to the number of bulbs.
Why, does it bother you to wait 2.5 seconds including compile time? Rust is on the same level of C++ performance wise. I guess your time is better spent on finding a pattern in the result.
Note that my script is not a proof for anything but a ring of 8 bulbs. If you conclude an algorithm for other sized rings from that, you have to proof that is actually working for any ring.
Would anyone want to voice an NPC in my latest H3 cartoon? You should have the accent that they have in Dartmoor, England (or be able to convincingly fake it). And a good mic. I can’t pay you because I’m broke, but you would get a mention in the credits. It would be like maybe 3 sentences and them freaking out over seeing something. Thought it might be worth asking here. It could be fun.
Might depend on what kind of accent from Dartmoor you might want, but I know RP and cockney so it shouldn’t be too difficult if I just need a reference from the level itself
I would absolutely love to give it a try for the fun of it, but while I think I can fake some kind of English accent pretty convincingly, I sadly lack a good mic (or any mic for that matter… I suppose I could try asking around for one though).
The output is now starting at all-bulbs-on with previous steps below. Note that a step is now not only to toggle a switch but also to rotate the ring so the integer value of the ring is the minimum.
That way finding a pattern should be more easy as the arms are lower in their number.
Interestingly, if a bulb configuration has multiple unique configurations one step further from all-bulbs-on, not more than one of these configurations has it’s own set of configurations further away.