It's a bit hard to explain too!

Ok so the second row has been sorted left and right by taking the digits that have a top left segment in their symbol representation and putting them on the left, those that don't have it go on the right. The extra symbol you see in the right most column is showing that top left segment for clarity (that was the intention, at least : ) - let's call it the 'filter' for now.

The idea is to try to keep a 50/50 split left and right - but it doesn't *have* to be 50/50 as we have a little leeway due to the run over of log_{2}10 being a snip over 3 - anyways, so I opt for a 6/4 split here.

We now go to the next line and start the challenge again - but a little trickier as we have to split *each* side (again, near to 50/50) but using the *same* filter for each side. This takes a while to find, but the segments that make up a '7' work here

We now have 4 splits, 2 of 3 from the 6, and 2 of 2 from the 4 - again, we have to find a 'filter' that will split these *all* and again at close to 50/50 - this took even longer to find, but the combo of top AND middle AND bottom do the trick. You wouldn't have 3 sensors logically AND'd here by the way, that would make an arse of the concept in the first place, but you'd somehow *physically* AND them (mask the photodiode somehow).

Anyways, rinse and repeat - but even harder harder - find a segment that splits all 8 now ! agh but no, it's easy again , because 6 of them are already fully defined by now - so we just need to split the 2 lots of 2, which is done here using the bottom left segment only.

The final implementation would have 4 sensors, each giving a 0 or 1 that is, depending if the segments were fully lit or not. The tree of 16 results would have 10 valid answers with each being one of the digits (make a look up table, or better yet order it such that the binary result *actually was the binary* for that digit).

The 4 invalid results should never eventuate except perhaps for very small amounts of time when the segments change symbol, easily solved with timers and what not ...

It has a recursive flavour but the 'filter' is I guess more global at each level.

Interesting huh!

Although I can't prove it (and I can't prove that I can't) but intuition says there will be many more solutions - some much more clearer.

'Dynamic Programming' I think is the concept behind finding them all efficiently.