1)0|0|0        -запускаем 1,2,3
2)5|5|5        -в любой момент останавливаем
3)0|6|5        - 11-5=6
4)4|2|9        - 5+4=9
5)2|0|9        - 4-2=2
6)1,5|0,5|8,5    -9-0.5=8.5
7)1|0|8.5
8)0.5|0.5|8
9)0|0|8        - бинго

R|R|R
WaitRand(1)
ChangeOrientation(2)
R|R|S
Wait(1, 2)
if Empty(1)
{
    Switch(1, 2)
}
do
{
    if (Empty(1) && Empty(2))
        return Bingo()

    ChangeOrientation(2)
    R|R|R
    WaitRand(1)
    ChangeOrientation(2)
    R|R|S
    Wait(1, 2)
    if Empty(1)
    {
        Switch(1, 2)
        ChangeOrientation(3)
    }
}
while(true)

HC>1)0|0|0        -запускаем 1,2,3
HC>2)5|5|5        -в любой момент останавливаем
HC>3)0|6|5        - 11-5=6
HC>4)4|2|9        - 5+4=9
HC>5)2|0|9        - 4-2=2
HC>6)1,5|0,5|8,5    -9-0.5=8.5
HC>7)1|0|8.5
HC>8)0.5|0.5|8
HC>9)0|0|8        - бинго
HC>

1)0|0|0        -запускаем 1,2,3                     |               0|               0|       |        
2)5|5|5        -в любой момент останавливаем        |               n|               n|      n|
3)0|6|5        - 11-5=6                             |               0|           16-2n|      n|   
4)4|2|9        - 5+4=9                              |               k|         16-k-2n|    n+k|   
5)2|0|9        - 4-2=2                              |        16-2k-2n|               0|    n+k|   
                                                    n=k+n;
                                                    часы 1 и 2 меняем местами.
3==5)0|6|5        - 11-5=6                          |               0|           16-2n|      n|   
                                                    goto p. 4).
                                                    
                                                    Не скоро бинго.
                                                    Ох не скоро. :( 

6)1,5|0,5|8,5    -9-0.5=8.5                         |                |                |        |   
7)1|0|8.5                                           |                |                |        |   
8)0.5|0.5|8                                         |                |                |        |   
9)0|0|8        - бинго                              |                |                |        |

VM>>Или 0.5.

VM>>4=k;

А>|               0|               0|       |        
А>|               n|               n|      n|
А>|               0|           16-2n|      n|   
А>|               k|         16-k-2n|    n+k|   
А>|        16-2k-2n|               0|    n+k|  // либо 0| 16-2k-2n| n+k

|        16-2k-2n|               0|    n+k| == (Тождественно равно следующей строке)
|       16-2(k+n)|               0|    n+k| == (Тождественно равно следующей строке)
|           16-2N|               0|     N |

А>|               0|           16-2n|      n|   // это окуда взялось?

|           16-2N|               0|     N |

|               0|           16-2N|     N |

|               0|           16-2n|      n|

x < 16

a*x = 16*b, где a и b - целые положительные числа.

x = 16*b/a

m*x = 16*n - 8
или (подставляя x)
m*16*b/a = 16*n - 8
, сокращая на 8,
2*m*b = (2*n - 1)*a

x = 16 * 5600 / 16000 = 16 * 7 / 20.

2*m*b = (2*n - 1)*a, a = 20, b = 7
2*m*7 = (2*n - 1)*20
7*m = 10*(2*n - 1)
m = 10
n = 4

S>>x < 16
S>>

Как откладывать интервалы по x минут.
Перевернем первые часы. Через некоторое время (это и будет время x) меньшее 16 перевернем их обратно и одновременно перевернем вторые часы. Переворачивая первые и вторые часы таким образом можно отсчитывать интервалы по x минут.
Третьи часы нам пригодятся для отсчитывания интервалов по 16 минут.

using System;
using System.Console;
using Nemerle.Utility;

module Program
{
    Main() : void
    {
        def rnd = Random();

        def removeSand(c1 : double, c2 : double, c3 : double)
        {
            if (c1 > c2)
                (c1 - c2, 0.0, c3);
            else
                (0.0, c2 - c1, c3);
        }
        def loop(c1 : double, c2 : double, c3 : double)
        {
        | (0.0, 0.0, _) => () // сошлось
        | (_  , 0.0, _) => // недосыпали
            _ = ReadKey();
            WriteLine($"a $c1 $c2 $c3");
            def m = c1 * rnd.NextDouble();
            def (c1, c2, c3) = removeSand(c1 - m, c2 + m, c3 + m);
            WriteLine($"b $c1 $c2 $c3");
            loop(c1, c2, c3);
        | (0.0, _  , _) => // пересыпали
            _ = ReadKey();
            WriteLine($"a $c1 $c2 $c3");
            def m = c2 * rnd.NextDouble();
            def (c1, c2, c3) = removeSand(c1 + m, c2 - m, c3 - m);
            WriteLine($"b $c1 $c2 $c3");
            loop(c1, c2, c3);
        }
        loop(16, 0, 0);
        _ = ReadKey();
    }
}

Н>>Вы же понимаете, что песочные часы не могут мерять время так же точно как атомные . Переворачивание набок и обратно + время реакции человека ведущего измерение, все это неизбежно вносит свою погрешность... Но и с практической точки зрения подход подходу рознь. Пересчитывать писчинки или разгонять часы до скоростей сопостовимых со скоростью света -- это явная утопия. Просто отмерять на глаз, тоже не самая замечательная идея, ибо нет способа минимизировать погршность глазомера, а он у всех очень разный.

VM>Я так и знал ... решение "на глазок"!!!

VM>У меня глаз.... Ну просто офигеть...

Просто отмерять на глаз, тоже не самая замечательная идея, ибо нет способа минимизировать погршность глазомера, а он у всех очень разный.

using System;
using System.Console;
using Nemerle.Utility;

module Program
{
    Main() : void
    {
        def rnd = Random();

        def removeSand(e : double, c1 : double, c2 : double, c3 : double)
        {
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            if (c1 > c2)
                (e + c2, c1 - c2, 0.0, c3);
            else
                (e + c1, 0.0, c2 - c1, c3);
        }
        def wait()
        {
            def min = 0.4;
            def max = 0.6;
            min + rnd.NextDouble() * (max - min);
        }
        def loop(e : double, c1 : double, c2 : double, c3 : double)
        {
        | (_, 0.0, 0.0, _) => ()
        | (_, _  , 0.0, _) =>
            _ = ReadKey();
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            def m = c1 * wait();
            def (e, c1, c2, c3) = removeSand(e + m, c1 - m, c2 + m, c3 + m);
            loop(e, c1, c2, c3);
        | (_, 0.0, _  , _) =>
            _ = ReadKey();
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            def m = c2 * wait();
            def (e, c1, c2, c3) = removeSand(e + m, c1 + m, c2 - m, c3 - m);
            loop(e, c1, c2, c3);
        }
        loop(0, 16, 0, 0);
        _ = ReadKey();
    }
}

B>Даже и не знаю, что сказать Вы может знаете, что double имеет ограниченную точность,

using System;
using System.Console;
using Nemerle.Utility;

module Program
{
    Main() : void
    {
        def rnd = Random();

        def removeSand(e : int, c1 : int, c2 : int, c3 : int)
        {
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            if (c1 > c2)
                (e + c2, c1 - c2, 0, c3);
            else
                (e + c1, 0, c2 - c1, c3);
        }
        def loop(e : int, c1 : int, c2 : int, c3 : int)
        {
        | (_, 0, 0, _) => ()
        | (_, _, 0, _) =>
            _ = ReadKey();
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            def m = rnd.Next(c1);
            def (e, c1, c2, c3) = removeSand(e + m, c1 - m, c2 + m, c3 + m);
            loop(e, c1, c2, c3);
        | (_, 0, _, _) =>
            _ = ReadKey();
            WriteLine($"[tr][td]$c1[/td][td]$c2[/td][td]$c3[/td][td]$e[/td][/tr]");
            def m = rnd.Next(c2);
            def (e, c1, c2, c3) = removeSand(e + m, c1 + m, c2 - m, c3 - m);
            loop(e, c1, c2, c3);
        }
        loop(0, 1000000000, 0, 0);
        _ = ReadKey();
    }
}

        def removeSand(c1 : double, c2 : double, c3 : double)
        {
            if (c1 > c2)
                (c1 - c2, 0.0, c3);
            else
                (0.0, c2 - c1, c3);
        }