Здравствуйте, HoseCo, Вы писали:

HC>Здравствуйте, baily, Вы писали:

B>>С таким допущением задача просто неинтересна, так как это просто прямое решение в лоб.

HC>Не назвал бы эту задачу не интересной и приведённое решение решением в лоб. Во первых данные допущения мне видятся очевидными. Во вторых до такого решения нужно ещё додуматься, а удалось это сделать только Spiceman'у.

Невнимательно читаете ветку. Вот только то, что мне удалось найти. Не исключаю, что есть еще.

baily 14.10.08 17:02

Автор: baily
Дата: 14.10.08

Spiceman 14.10.08 23:54

Автор: Spiceman
Дата: 14.10.08

NotImplemented 15.10.08 17:09

Автор: NotImplemented
Дата: 15.10.08

WolfHound 15.10.08 20:58

Автор: WolfHound
Дата: 15.10.08

Кодт 16.10.08 18:35

Автор: Кодт
Дата: 16.10.08

Кроме того, уверен, что многие до этого догадались, но просто не стали писать, так как все же это решение является решением "на глазок"

Здравствуйте, Нэчер, Вы писали:

Н>Пусть имеется трое одинаковых песочных часов на 16 минут каждые.
Н>Как точно(не на глаз)отмерить 24 минуты?

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

Здравствуйте, baily, Вы писали:

HC>>Не назвал бы эту задачу не интересной и приведённое решение решением в лоб. Во первых данные допущения мне видятся очевидными. Во вторых до такого решения нужно ещё додуматься, а удалось это сделать только Spiceman'у.

B>Невнимательно читаете ветку. Вот только то, что мне удалось найти. Не исключаю, что есть еще.

я говорил о том, что именно такое решение предложил только Spiceman(а решение заслуживает внимания хотябы потому, что с его помощью можно отмерить произвольное время). Хотя некоторые решения я не понял

B>baily 14.10.08 17:02

Автор: baily
Дата: 14.10.08

похоже на решение Spiceman'а
B>Spiceman 14.10.08 23:54

Автор: Spiceman
Дата: 14.10.08

ага
B>NotImplemented 15.10.08 17:09

Автор: NotImplemented
Дата: 15.10.08

совсем другое решение
B>WolfHound 15.10.08 20:58

Автор: WolfHound
Дата: 15.10.08

этого я понять не в силах
B>Кодт 16.10.08 18:35

Автор: Кодт
Дата: 16.10.08

Нониуса-Вернье не знаю, а второй метод, тот же что и у NotImplemented ну и я его вроде тоже предлагал в начале.

B>Кроме того, уверен, что многие до этого догадались, но просто не стали писать, так как все же это решение является решением "на глазок"

А на глазок тут только 2 вещи: 1) конечное число песчинок в часах 2) возможность зафиксировать одновременно истекшие часы.

Здравствуйте, Erop, Вы писали:

E>В целом следует, IMHO, заметить, что никто не обещал, что песок сыплется равномерно. Что если насыпать песка в два раа больше, то будет в два раза дольше и т. п.

В отличие от водяных часов, песочные идут равномерно (за исключением самого-самого последнего отрезка времени).
Потому что они не зависят от давления и инерции.

Здравствуйте, HoseCo, Вы писали:

B>>Кодт 16.10.08 18:35

Автор: Кодт
Дата: 16.10.08

HC>Нониуса-Вернье не знаю, а второй метод, тот же что и у NotImplemented ну и я его вроде тоже предлагал в начале.

Штангенциркуль видел? У него как раз шкала Нониуса.
Всё тот же фокус с наименьшим общим кратным.

Берём две линейки с разным шагом (одна линейка — 16-минутная, вторая — что-то меньшее).
Находим совпадающие штрихи (одно совпадение — в точке 0, другое — 16*i == t*j).
Находим штрих (j/2) на линейке "t" — он приходится на 8*i и лежит точно посередине между штрихами [i/2] и ]i/2[ на линейке "16".

Но это, естественно, при условии, что j чётно.
А если мы совершенно случайно взяли t такое, что оно нечётно (например, t = 16./3)?

На самом деле, если песочные часы способны строго отмерить 8 минут — т.е. количество песчинок в них чётно, то нечётный результат получить невозможно.
Беда лишь в том, что эта нечётность может быть с точностью до одной песчинки.

Например, у нас 16'000'000 песчинок. t = 5'333'333'333 (одна треть).
Каждые 16 минут у нас будет добавляться расхождение в 1 песчинку. То есть, через 8'000'000 циклов мы наконец получим искомый результат.

При этом надо заметить, что погрешности — в измерении момента финиша, в выполнении переворота — существенно больше, чем эта песчинка.
То есть, из-за флуктуаций мы вообще никогда не добьёмся расхождения, а так и будем колбаситься вокруг 16*1==t*3.

Поэтому метод Нониуса в чистом виде неприменим.
Нужна процедура коррекции. Скажем, если мы зафиксировали i=99 (нечётное!), отложили 16*99 и обнаружили, что j = [16*99/t] нечётно, то — с помощью третьих часов отмеряем t1, примерно полуцелое кратное t.
И работаем уже с новым значением t := t1.
После одной-двух коррекций точность превысит погрешности измерений.

Чем меньше количество циклов i, тем больше коррекций придётся совершить.
Чем больше количество циклов, тем большая погрешность измерений (сумма переходных процессов на переворотах). Думаю, что 99 — непозволительно много.
Где-то в районе 5-10 будет достаточно. Опять же, каждый забег — это больше часа. Если больше — замучаешься.

Здравствуйте, samius, Вы писали:

S>Действительно. Освежил знания по маятникам — период не зависит от амплитуды! Но есть шанс, что амплитуда упадет до 0-я менее чем за 16 минут. Тогда будет облом с подсчетом колебаний.

Можно несколько раз перезапустить

Здравствуйте, Нэчер, Вы писали:

Н>Здравствуйте, Нэчер, Вы писали:
Н>........................................
Как и ожидалось — решение "на глазок"

Н>Неизвестное время t, выступает в роли нашей собственно единицы измерения............
Н>Сразу оговорюсь, t – это целое число, равное секундам или миллисекундам или любым другим единицам измерения, с точностью до которых мы считаем. ........................

Скажите какой хронометр следует использовать чтобы неизвестное время t сделать целым числом.
И вообще странно как-то. Время-целое число. Дла меня это непонятно.

Расскажите метод как получить "время-целое число" имея трое часов по 16.
Тогда можно и дальше "решение" почитать.

А может быть сразу сделать неизвестное время t==8.
По моему разумное решение и часы не надо иступлённо переворачивать.
Один разок и готово.
Да и "число" целое.

По-моему моё решение проще и элегантнее.


P.S.
А у меня просто 3 экземпляра идентичных песочных часов.
Никто не знает на какое количество часов, минут и секунд.
Как бы мне отмерить в 1.5 раза больше?

К тому же часы не прозрачные и только сигналят о том что песок закончился.
(это условие подразумевается априори во ВСЕХ задачах о песочных часах)

P.S.S.
Ну не имеет задача решения...
Нету и всё!












.

Здравствуйте, VMin, Вы писали:

VM>P.S.
VM>А у меня просто 3 экземпляра идентичных песочных часов.
VM>Никто не знает на какое количество часов, минут и секунд.
VM>Как бы мне отмерить в 1.5 раза больше?

VM>К тому же часы не прозрачные и только сигналят о том что песок закончился.
VM>(это условие подразумевается априори во ВСЕХ задачах о песочных часах)
См мое решение.

Здравствуйте, baily, Вы писали:

B>Кроме того, уверен, что многие до этого догадались, но просто не стали писать, так как все же это решение является решением "на глазок"
Вот не надо. У меня точное решение.
Ессно если допустить что мы можем точно определить момент "песок кончился" и мнгновенно перевернуть/остановить/запустить часы.
Причем сходится оно как правило за время не сильно больше 16 минут.
А если добавить "глазок" и смотреть за тем чтобы rnd.NextDouble() давал примерно 0.5 то варемя схождения будет 16 минут и несколько секунд.

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();
    }
}

получаем что-то типа:

16	0	0	0
7,92703722339451	8,07296277660549	8,07296277660549	8,07296277660549
0	0,145925553210976	8,07296277660549	16
0,0760347774980851	0,0698907757128907	7,9969279991074	16,0760347774981
0,00614400178519439	0	7,9969279991074	16,145925553211
0,00296082987549867	0,00318317190969572	8,0001111710171	16,1491087251207
0	0,000222342034197044	8,0001111710171	16,1520695549962
0,000129086725076028	9,32553091210162E-05	7,99998208429202	16,1521986417212
3,58314159550117E-05	0	7,99998208429202	16,1522918970304
1,49405519971572E-05	2,08908639578545E-05	8,00000297515598	16,1523127878943
0	5,95031196069736E-06	8,00000297515598	16,1523277284463
2,58299119449444E-06	3,36732076620292E-06	8,00000039216478	16,1523303114375
0	7,84329571708476E-07	8,00000039216478	16,1523328944287
4,52843384562954E-07	3,31486187145522E-07	7,9999999393214	16,1523333472721
1,21357197417433E-07	0	7,9999999393214	16,1523336787583
5,15319746645584E-08	6,98252227528742E-08	8,00000000914662	16,1523337485835
0	1,82932480883158E-08	8,00000000914662	16,1523338001155
1,0898375254374E-08	7,39487283394175E-09	7,99999999824825	16,1523338110139
3,50350242043228E-09	0	7,99999999824825	16,1523338184087
1,64521338672837E-09	1,85828903370391E-09	8,00000000010654	16,152333820267
0	2,1307564697554E-10	8,00000000010654	16,1523338219122
1,03054755985607E-10	1,10020890989933E-10	8,00000000000348	16,1523338220153
0	6,96613500432551E-12	8,00000000000348	16,1523338221183
3,6464353494614E-12	3,31969965486411E-12	7,99999999999983	16,152333822122
3,26735694597287E-13	0	7,99999999999983	16,1523338221253
1,40298234572747E-13	1,86437460024541E-13	8,00000000000002	16,1523338221255
0	4,61392254517939E-14	8,00000000000002	16,1523338221256
2,06977092319376E-14	2,54415162198563E-14	8	16,1523338221256
0	4,74380698791862E-15	8	16,1523338221257
2,61908613255725E-15	2,12472085536137E-15	8	16,1523338221257

Остаток в первых часах означает что мы недосыпали 2Х песка. Остаток во вторых означает что мы пересыпали 3Х песка.

ЗЫ Ни о каких ~17 часах в моем решении речи не идет. Даже без "глазка".

Здравствуйте, WolfHound, Вы писали:

WH>Здравствуйте, baily, Вы писали:

B>>Кроме того, уверен, что многие до этого догадались, но просто не стали писать, так как все же это решение является решением "на глазок"
WH>Вот не надо. У меня точное решение.
WH>Ессно если допустить что мы можем точно определить момент "песок кончился" и мнгновенно перевернуть/остановить/запустить часы.
WH>Причем сходится оно как правило за время не сильно больше 16 минут.
WH>А если добавить "глазок" и смотреть за тем чтобы rnd.NextDouble() давал примерно 0.5 то варемя схождения будет 16 минут и несколько секунд.

Даже и не знаю, что сказать Вы может знаете, что double имеет ограниченную точность, и что с некоторого момента числа в последовательности 2^(-n) при n стремящемся к бесконечности в double станeт "точно" равнs 0. Но утверждать, что 2^(-n) = 0 с некоторого не очень большого n

Вспоминаю, как то давно, еще в школе, участвовал в олимпиаде, и там была одна простенькая задачка. Существует ли такое натуральное число n, что 1996^n делится на 5. Так нашелся один товарищ, между прочим неглупый, который посчитал на калькуляторе для малых n, чтобы проверить. Проблема в том, что калькулятор у него был 10-тиразрядный. Поэтому уже 1996^3 у него оканчивалось на 0, а потому делилось на 10, а значит и на 5. Убедить его, что это не так, нам так и не удалось. На меня тогда это произвело сильное впечатление

Здравствуйте, baily, Вы писали:

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();
    }
}

1000000000	0	0	0
342497556	657502444	657502444	657502444
0	315004888	657502444	1000000000
252373809	62631079	405128635	1252373809
189742730	0	405128635	1315004888
37394024	152348706	557477341	1467353594
0	114954682	557477341	1504747618
103791684	11162998	453685657	1608539302
92628686	0	453685657	1619702300
44043668	48585018	502270675	1668287318
0	4541350	502270675	1712330986
3759349	782001	498511326	1716090335
2977348	0	498511326	1716872336
2939802	37546	498548872	1716909882
2902256	0	498548872	1716947428
2171758	730498	499279370	1717677926
1441260	0	499279370	1718408424
654721	786539	500065909	1719194963
0	131818	500065909	1719849684
22638	109180	500043271	1719872322
0	86542	500043271	1719894960
538	86004	500042733	1719895498
0	85466	500042733	1719896036
65822	19644	499976911	1719961858
46178	0	499976911	1719981502
16652	29526	500006437	1720011028
0	12874	500006437	1720027680
10565	2309	499995872	1720038245
8256	0	499995872	1720040554
7893	363	499996235	1720040917
7530	0	499996235	1720041280
1729	5801	500002036	1720047081
0	4072	500002036	1720048810
2776	1296	499999260	1720051586
1480	0	499999260	1720052882
434	1046	500000306	1720053928
0	612	500000306	1720054362
44	568	500000262	1720054406
0	524	500000262	1720054450
353	171	499999909	1720054803
182	0	499999909	1720054974
122	60	499999969	1720055034
62	0	499999969	1720055094
54	8	499999977	1720055102
46	0	499999977	1720055110
19	27	500000004	1720055137
0	8	500000004	1720055156
4	4	500000000	1720055160

Как видишь часы из 1'000'000'000 песчинок быстро сходятся на 500'000'000.

Если добавить "глазок" будет еще быстрее.

Более того можно и дальше делить пополам до тех пор пока остается четное колличество пестинок.

Короче что ни говори, а алгоритм точный.

Здравствуйте, WolfHound, Вы писали:

...............
WH>См мое решение.


Классное решение!!!

А где?











.

Здравствуйте, WolfHound, Вы писали:

WH>Здравствуйте, VMin, Вы писали:

VM>>К тому же часы не прозрачные и только сигналят о том что песок закончился.
VM>>(это условие подразумевается априори во ВСЕХ задачах о песочных часах)

WH>См мое решение.

Уверен, что прога работает блестяще.

Один вопрос:
По каким критериям определяем:

if (c1 > c2)

Вот сюда вопрос:

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

Наверное "на глазок".


Вопрос на засыпку:
Вот ЧАСЫ (сам нарисовал ):




... где песка больше вверху или внизу?

Подсказка 1: Треугольники одинаковые.
Подсказка 2: внизу ещё квадраная кучка слева и пустоты внутри.
Подсказка 3: больше вверху

... так-то.
Даи и часы не прозрачные...









.

Здравствуйте, WolfHound, Вы писали:

WH>Здравствуйте, baily, Вы писали:

B>>Даже и не знаю, что сказать Вы может знаете, что double имеет ограниченную точность,
WH>Знаю.
WH>А песок еще более ограниченную точность. Более того он целочисленный:
WH>Как видишь часы из 1'000'000'000 песчинок быстро сходятся на 500'000'000.

WH>Если добавить "глазок" будет еще быстрее.

WH>Более того можно и дальше делить пополам до тех пор пока остается четное колличество пестинок.

WH>Короче что ни говори, а алгоритм точный.

Совершенно верно, а 2^(-100000000000000000000....0000) точно равно нулю.

Здравствуйте, Кодт, Вы писали:

К>В отличие от водяных часов, песочные идут равномерно (за исключением самого-самого последнего отрезка времени).
Что-то как-то гложат меня смутные сомнения... Хотя утврждать точно не возьмусь...

К>Потому что они не зависят от давления и инерции.
От чего бы?

Здравствуйте, Erop, Вы писали:

К>>Потому что они не зависят от давления и инерции.
E>От чего бы?
Свойство есть такое у сыпучих сред. После некоторого уровня у них давление на дно перестаёт расти линейно.

Здравствуйте, VMin, Вы писали:

VM>По каким критериям определяем:
VM>Наверное "на глазок".
Нет.
Чтобы было понятнее этот код:

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

эквивалентен такому:

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

Те высыпаем песок из двух часов пока в одних не останется песка.

Как я уже говорил "глазок" алгоритму не нужен. И может использоваться лишь для ускорения схождения алгоритма.

Здравствуйте, baily, Вы писали:

B>Совершенно верно, а 2^(-100000000000000000000....0000) точно равно нулю.
Ты что сказать то хочешь?
Что мой алгоритм не точен? Так он точен что прекрасно демонстрирует целочисленная версия при том что песок также штука целочисленная.

Здравствуйте, Cyberax, Вы писали:

C>Свойство есть такое у сыпучих сред. После некоторого уровня у них давление на дно перестаёт расти линейно.

Что-то тут не так. А куда же двается вес песка? Неужели передаётся на стенки? Что-то с трудом верится, так как стенки довольно таки скользкие...

Здравствуйте, Erop, Вы писали:

E>Что-то тут не так. А куда же двается вес песка? Неужели передаётся на стенки? Что-то с трудом верится, так как стенки довольно таки скользкие...
Да, передаётся на стенки. От их гладкости и материала тоже зависимость есть.

Например, если взять обычную бочку и наполнить цементом, а потом перевернуть вверх дном — то заметная часть цемента останется внутри бочки. Точно так же и при разгрузке вагонов-хопперов с цементом заметная часть цемента остаётся на стенках.

PS: это я как-то давно занимался халтуркой с рассчётом прочности стенок цилиндрического контейнера для сыпучих грузов.