# It's kind-of like Minesweeper

Have you ever played "Minesweeper" or "Lights Out!" and wondered what it would be like to reverse the process? Me too! Say hello to a 10 by 10 grid that I like to call "Number Dash":

Your objective is simple; activate all of the tiles in the grid in the fewest moves possible.

##### How to Play

To activate tiles you must tap on tiles that are already active. Tapping an active tile will cause a few things to happen. To define this, let $$T$$ represent the tapped tile.

1. Any inactive adjacent tiles are activated.
2. The face value of $$T$$ is reduced by the number of active adjacent tiles.
• This count excludes tiles that were inactive before step 1.
3. For each adjacent tile (excluding tiles that were inactive before step 1):
• If its face value is odd, subtract the newly reduced face value of $$T$$.
• If its face value is even, add the newly reduced face value of $$T$$.
• The opening move is exempt from reductions in face value.
• A tile's face value cannot exceed 9, any greater value is simply truncated.
• A tile's face value cannot go negative, it stops at zero.
• When a tile's face value is equal to zero, it is inactive.
##### The Interactive Puzzle

I've built an interactive version of the puzzle (e.g. the game can actually be played) that will let you quickly test theories. Feel free to use it to avoid the hassle of paper solving for everything. The tag was removed to enable the community to use the interactive puzzle. However, keep in mind that even though the is no longer specified, answers relying on brute force or computer programming to solve this puzzle will be disqualified.

Furthermore, to simplify writing your answer, if you open your developer tools (typically by pressing the F12 key), the console logs each move you make:

If you need further information on opening developer tools in your respective operating system and web browser, here is an article that should be able to help.

For simplicity, answers can use a simple notation of $$T[x, y]$$ to represent moves:

T[1,4]
T[1,7]
T[2,6]
...


Additionally, answers should use $$1$$ based indexing for consistency; so the grid has a minimum value of $$T[1, 1]$$ and a maximum of $$T[10, 10]$$. On a final note, this format should not be considered as case-sensitive. If you prefer $$t$$ over $$T$$, then use $$t$$.

What is the fewest number of moves required to activate every tile in this grid?

Using the simulator, I was able to find 2 sequences requiring 41 moves each (see edit history for details, formatted T[y, x]). I was also able to find a single sequence requiring 40 moves (formatted t[x, y]):

Move 1: t[2, 2]
Move 2: t[2, 1]
Move 3: t[3, 1]
Move 4: t[4, 1]
Move 5: t[4, 2]
Move 6: t[4, 3]
Move 7: t[2, 3]
Move 8: t[2, 4]
Move 9: t[2, 5]
Move 10: t[2, 6]
Move 11: t[3, 8]
Move 12: t[2, 8]
Move 13: t[1, 8]
Move 14: t[3, 9]
Move 15: t[3, 10]
Move 16: t[5, 5]
Move 17: t[5, 6]
Move 18: t[5, 7]
Move 19: t[6, 7]
Move 20: t[6, 8]
Move 21: t[6, 9]
Move 22: t[6, 10]
Move 23: t[7, 10]
Move 24: t[8, 10]
Move 25: t[9, 10]
Move 26: t[10, 1]
Move 27: t[9, 1]
Move 28: t[8, 1]
Move 29: t[7, 1]
Move 30: t[7, 2]
Move 31: t[7, 3]
Move 32: t[7, 4]
Move 33: t[7, 7]
Move 34: t[8, 7]
Move 35: t[9, 3]
Move 36: t[9, 4]
Move 37: t[9, 5]
Move 38: t[9, 7]
Move 39: t[10, 7]
Move 40: t[10, 10]

Here's another 40 moves sequence that I found using the simulator:

Note the brackets are [column, row]

Move 1: T[2, 2]
Move 2: T[2, 3]
Move 3: T[2, 4]
Move 4: T[2, 5]
Move 5: T[2, 6]
Move 6: T[2, 7]
Move 7: T[2, 8]
Move 8: T[2, 9]
Move 9: T[2, 1]
Move 10: T[3, 2]
Move 11: T[3, 1]
Move 12: T[4, 2]
Move 13: T[5, 2]
Move 14: T[6, 2]
Move 15: T[7, 2]
Move 16: T[8, 2]
Move 17: T[9, 2]
Move 18: T[9, 3]
Move 19: T[9, 4]
Move 20: T[9, 5]
Move 21: T[9, 6]
Move 22: T[5, 5]
Move 23: T[6, 5]
Move 24: T[4, 5]
Move 25: T[4, 6]
Move 26: T[4, 7]
Move 27: T[4, 8]
Move 28: T[4, 9]
Move 29: T[4, 10]
Move 30: T[7, 5]
Move 31: T[7, 6]
Move 32: T[7, 7]
Move 33: T[7, 8]
Move 34: T[7, 9]
Move 35: T[7, 10]
Move 36: T[8, 10]
Move 37: T[9, 10]
Move 38: T[10, 10]
Move 39: T[10, 9]
Move 40: T[10, 8]