ЗАДАЧА 981 (Diofant.ru). Перпендикуляр к диаметру 'Дана окружность o и прямая линия l, которая проходит через ее центр. На окружности отмечена точка A, не лежащая на прямой. При помощи одной линейки без делений постройте перпендикуляр от точки к прямой.Для решения таких задач я использую свой скрипт. Решить-то я решил, но поскольку задача проверяется в ручном режиме, надо было еще написать решение. Поэтому вчера я немного допилил скрипт (если кому-то интересно, смотреть как его подключить в коде) и теперь он худо-бедно документирует действия. Вот, можно попробовать решить вышеупомянутую задачу. Точки на пересечениях двух объектов ставятся их последовательным выделением (при включенном инструменте line).
Показаны сообщения с ярлыком скрипт. Показать все сообщения
Показаны сообщения с ярлыком скрипт. Показать все сообщения
понедельник, 19 мая 2014 г.
Визуальное решение задач на построение
Для профилактики слабоумия начал опять решать задачи на Diofant.ru. Вчера вот такую задачу увидел
пятница, 16 мая 2014 г.
Задание в методичку по квантовому программированию.
Есть квантовый компьютер с памятью 3 кубита. Определим однобитовые гейты\[\mathrm{H1}=\mathrm{Not}=\left(\begin{array}{cc}0&1\\1&0\end{array}\right)\,,\quad \mathrm{H2}=\mathrm{H}=\frac1{\sqrt{2}}\left(\begin{array}{cc}1&1\\1&-1\end{array}\right)\,,\quad \mathrm{H3}=\frac1{\sqrt{3}}\left(\begin{array}{cc}\sqrt{2}&1\\1&-\sqrt{2}\end{array}\right)\]
и их управляемые варианты $\mathrm{cnH1}\,,\ \mathrm{cnH2}\,,\ \mathrm{cnH3}$, которые выполняют над битом соответствующее преобразование только если остальные два бита равны единице.
Система комманд нашего компьютера состоит из четырех комманд: $\mathrm{H1}\,,\ \mathrm{cnH1}\,,\ \mathrm{cnH2}\,,\ \mathrm{cnH3}$. Надо написать алгоритм, который при подаче на вход двоичного числа от 0 до 7 строит состояние (с определенным спином и проекцией) с соответствующим номером:
и их управляемые варианты $\mathrm{cnH1}\,,\ \mathrm{cnH2}\,,\ \mathrm{cnH3}$, которые выполняют над битом соответствующее преобразование только если остальные два бита равны единице.
Система комманд нашего компьютера состоит из четырех комманд: $\mathrm{H1}\,,\ \mathrm{cnH1}\,,\ \mathrm{cnH2}\,,\ \mathrm{cnH3}$. Надо написать алгоритм, который при подаче на вход двоичного числа от 0 до 7 строит состояние (с определенным спином и проекцией) с соответствующим номером:
- $\sqrt{1/2}(|001\rangle-|010\rangle)$
- $\sqrt{1/2}(|101\rangle-|110\rangle)$
- $\sqrt{1/6}(|001\rangle+|010\rangle-2|100\rangle)$
- $\sqrt{1/6}(|101\rangle+|110\rangle-2|011\rangle)$
- $|000\rangle$
- $\sqrt{1/3}(|001\rangle+|010\rangle+|100\rangle)$
- $\sqrt{1/3}(|101\rangle+|110\rangle+|011\rangle)$
- $|111\rangle$
Boilerplate
|
Your Program
|
вторник, 6 мая 2014 г.
Квантовые программисты
Все, наверное, слышали о квантовых компьютерах, которые, ну вот
совсем скоро, будут созданы и будут решать все задачи, которые обычным,
классическим компьютерам не по зубам. Я о них, видимо, в первый раз
услышал где-то году в 97, сразу после прослушивания лекций по
криптографии, в которых как раз объяснялась криптосистема с открытым
ключом, основанная на сложности задачи факторизации. Поэтому важность
алгоритма Шора я понял довольно быстро и при случае гордо объяснял всю
историю.
Замечу, что никогда ни на одну секунду я не допускал, что реальный квантовый компьютер будет создан в обозримом будущем (ну, скажем, лет за сто). Под "реальным квантовым компьютером" я понимаю, конечно, устройство, способное успешно конкурировать с обычными классическими компьютерами, а не просто раскладывать на множители число 15. Однако новости от компании D-wave, если им верить, показывают, что пора уже подумать о новой специальности в CS --- квантовый программист, а азы квантовой информатики нужно учить в школах и детских садах.
Ниже --- мой вклад в дело ликвидации квантовой компьютерной безграмотности. Это симулятор двухбитного квантового компьютера с набором комманд {Not,H,cNot,cH}, где две первые комманды --- однобитовые квантовые гейты, а две последние --- двухбитовые. Полноценную программу писать пока нельзя (возможно, в последующих постах это будет реализовано), так что работать можно в интерактивном режиме. Задача --- написать программу производящую определенное преобразование над входными данными. Сейчас объясню какое.
Кубит, как известно, --- двухуровневая квантовомеханическая система, и одной из ее естественных реализаций (хотя, возможно, не на практике) является спин 1/2. Нолик и единица представляются как \[|0\rangle=|\downarrow\rangle\,,\quad |1\rangle=|\uparrow\rangle\,.\] Квантовый регистр (так сказать, курегистр), соответственно, это набор кубитов, которые могут находится в запутанных состояниях. Квантовое вычисление состоит в выполнении некоторого преобразования над курегистром. Напомним, кстати, важное отличие квантового вычисления от классического. В классическом вычислении одной из самых популярных операций является операция присваивания. Можно присвоить любому биту заданное значение ноль или единица. В частности, можно очистить регистр, присвоив всем его битам значение ноль. В квантовом вычислении операция присваивания невозможна, поскольку она нарушает унитарность. То же самое можно сказать и про операцию копирования. А вот операция инверсии бита Not, которая меняет ноль на единицу, и наоборот --- возможна. В значительной степени последствия унитарности можно описать как обратимость любого вычисления: зная output и зная программу вычисления можно однозначно восстановить input (в частности, в процессе квантового вычисления ничего нельзя стереть бесследно). Нужно, правда, сказать, что унитарность, и, в частности, обратимость не сильно мешают для симуляции классических вычислений. Просто надо добавить дополнительные биты, заранее установленные в определенное состояние. Кстати, легко сообразить, что максимально необходимое число дополнительных битов равно числу основных.
Итак, любое квантовое вычисление является унитарным преобразованием над курегистром.
Унитарное преобразование может затрагивать один или несколько битов. Важно, что любое унитарное преобразование может быть реализовано как суперпозиция одного типа двухбитного преобразования, cNot, и однобитных преобразований общего вида. С учетом линейности этих преобразований, их можно задать действием на базисные состояния: \[\mathtt{cNot}_{i,j}: |0_i,q_j\rangle\to |0_i,q_j\rangle\,,\quad |1_i,q_j\rangle\to |1,\bar{q}_j\rangle\,,\]
\[\left(\begin{array}{2}a&b\\c&d\end{array}\right)_{i}: |0_i\rangle\to a|0_i\rangle+b|1_i\rangle\,,\quad |1_i\rangle\to c|0_i\rangle+d|1_i\rangle\,.\] Здесь $\bar{0}=1\,,\ \bar{1}=0$, а во второй строчке $\left(\begin{array}{2}a&b\\c&d\end{array}\right)$ --- унитарная матрица. Операции $\mathtt{Not}$ и $\mathtt{H}$ являются частными случаями однобитовых операций: \[\mathtt{Not}_i=\mathtt{X}_i=\left(\begin{array}{2}0&1\\1&0\end{array}\right)_{i}\,,\quad \mathtt{H}_i=\left(\begin{array}{2}1/\sqrt{2}&1/\sqrt{2}\\1/\sqrt{2}&-1/\sqrt{2}\end{array}\right)_{i}\]
Операцию $\mathtt{cNot}$ удобно записать через проекторы: \[\mathtt{cNot}_{i,j}=\mathtt{P}^0_i\otimes \mathtt{I}_j+\mathtt{P}^1_i \otimes \mathtt{Not}_j\,,\] где $\mathtt{P}^0_i=\left(\begin{array}{2}0&0\\0&1\end{array}\right)_i\,,\,\, \mathtt{P}^1_i=\left(\begin{array}{2}1&0\\0&0\end{array}\right)_i$. Используя свойства проекторов легко проверить, что $\mathtt{cNot}$ -- действительно унитарная операция. Для удобства наш квантовый процессор в числе комманд будет иметь еще одну двухбитовую унитарную операцию \[\mathtt{cH}_{i,j}=\mathtt{P}^0_i\otimes \mathtt{I}_j+\mathtt{P}^1_i \otimes \mathtt{H}_j\,,\]
Ну вот, теперь можно сформулировать и задачу. На вход программы подаются запутанные состояния двух кубитов, соответствующие определенным спинам и проекциям спина системы: \[|S=0,S_z=0\rangle=\frac1{\sqrt{2}}\left(|01\rangle-|10\rangle\right)\]
\[|S=1,S_z=-1\rangle=|00\rangle,\quad |S=1,S_z=0\rangle=\frac1{\sqrt{2}}\left(|01\rangle+|10\rangle\right), \quad |S=1,S_z=1\rangle=|11\rangle.\]
Наша задача --- придумать алгоритм, который переставляет по циклу проекции. То есть, программа, получив на вход состояние $|S,S_z\rangle$ с $S_z<S$ должна выдавать состояние $|S,S_z+1\rangle$, а состояние $|S,S_z=S\rangle$ должна переводить в $|S,S_z=-S\rangle$.
Интерфейс такой: чтобы провести двухбитовую операцию (cNot или cH), нажимаем сначала на кнопку над первым битом, а затем над вторым. Однобитовые операции (Not или H) получаются двойным нажатием одной кнопки. Когда состояние уже такое, какое требуется, оно выделяется зеленым цветом. Например, $|S=0,S_z=0\rangle$ сразу зеленое, так как оно должно остаться на месте.
Замечу, что никогда ни на одну секунду я не допускал, что реальный квантовый компьютер будет создан в обозримом будущем (ну, скажем, лет за сто). Под "реальным квантовым компьютером" я понимаю, конечно, устройство, способное успешно конкурировать с обычными классическими компьютерами, а не просто раскладывать на множители число 15. Однако новости от компании D-wave, если им верить, показывают, что пора уже подумать о новой специальности в CS --- квантовый программист, а азы квантовой информатики нужно учить в школах и детских садах.
Ниже --- мой вклад в дело ликвидации квантовой компьютерной безграмотности. Это симулятор двухбитного квантового компьютера с набором комманд {Not,H,cNot,cH}, где две первые комманды --- однобитовые квантовые гейты, а две последние --- двухбитовые. Полноценную программу писать пока нельзя (возможно, в последующих постах это будет реализовано), так что работать можно в интерактивном режиме. Задача --- написать программу производящую определенное преобразование над входными данными. Сейчас объясню какое.
Кубит, как известно, --- двухуровневая квантовомеханическая система, и одной из ее естественных реализаций (хотя, возможно, не на практике) является спин 1/2. Нолик и единица представляются как \[|0\rangle=|\downarrow\rangle\,,\quad |1\rangle=|\uparrow\rangle\,.\] Квантовый регистр (так сказать, курегистр), соответственно, это набор кубитов, которые могут находится в запутанных состояниях. Квантовое вычисление состоит в выполнении некоторого преобразования над курегистром. Напомним, кстати, важное отличие квантового вычисления от классического. В классическом вычислении одной из самых популярных операций является операция присваивания. Можно присвоить любому биту заданное значение ноль или единица. В частности, можно очистить регистр, присвоив всем его битам значение ноль. В квантовом вычислении операция присваивания невозможна, поскольку она нарушает унитарность. То же самое можно сказать и про операцию копирования. А вот операция инверсии бита Not, которая меняет ноль на единицу, и наоборот --- возможна. В значительной степени последствия унитарности можно описать как обратимость любого вычисления: зная output и зная программу вычисления можно однозначно восстановить input (в частности, в процессе квантового вычисления ничего нельзя стереть бесследно). Нужно, правда, сказать, что унитарность, и, в частности, обратимость не сильно мешают для симуляции классических вычислений. Просто надо добавить дополнительные биты, заранее установленные в определенное состояние. Кстати, легко сообразить, что максимально необходимое число дополнительных битов равно числу основных.
Итак, любое квантовое вычисление является унитарным преобразованием над курегистром.
Унитарное преобразование может затрагивать один или несколько битов. Важно, что любое унитарное преобразование может быть реализовано как суперпозиция одного типа двухбитного преобразования, cNot, и однобитных преобразований общего вида. С учетом линейности этих преобразований, их можно задать действием на базисные состояния: \[\mathtt{cNot}_{i,j}: |0_i,q_j\rangle\to |0_i,q_j\rangle\,,\quad |1_i,q_j\rangle\to |1,\bar{q}_j\rangle\,,\]
\[\left(\begin{array}{2}a&b\\c&d\end{array}\right)_{i}: |0_i\rangle\to a|0_i\rangle+b|1_i\rangle\,,\quad |1_i\rangle\to c|0_i\rangle+d|1_i\rangle\,.\] Здесь $\bar{0}=1\,,\ \bar{1}=0$, а во второй строчке $\left(\begin{array}{2}a&b\\c&d\end{array}\right)$ --- унитарная матрица. Операции $\mathtt{Not}$ и $\mathtt{H}$ являются частными случаями однобитовых операций: \[\mathtt{Not}_i=\mathtt{X}_i=\left(\begin{array}{2}0&1\\1&0\end{array}\right)_{i}\,,\quad \mathtt{H}_i=\left(\begin{array}{2}1/\sqrt{2}&1/\sqrt{2}\\1/\sqrt{2}&-1/\sqrt{2}\end{array}\right)_{i}\]
Операцию $\mathtt{cNot}$ удобно записать через проекторы: \[\mathtt{cNot}_{i,j}=\mathtt{P}^0_i\otimes \mathtt{I}_j+\mathtt{P}^1_i \otimes \mathtt{Not}_j\,,\] где $\mathtt{P}^0_i=\left(\begin{array}{2}0&0\\0&1\end{array}\right)_i\,,\,\, \mathtt{P}^1_i=\left(\begin{array}{2}1&0\\0&0\end{array}\right)_i$. Используя свойства проекторов легко проверить, что $\mathtt{cNot}$ -- действительно унитарная операция. Для удобства наш квантовый процессор в числе комманд будет иметь еще одну двухбитовую унитарную операцию \[\mathtt{cH}_{i,j}=\mathtt{P}^0_i\otimes \mathtt{I}_j+\mathtt{P}^1_i \otimes \mathtt{H}_j\,,\]
Ну вот, теперь можно сформулировать и задачу. На вход программы подаются запутанные состояния двух кубитов, соответствующие определенным спинам и проекциям спина системы: \[|S=0,S_z=0\rangle=\frac1{\sqrt{2}}\left(|01\rangle-|10\rangle\right)\]
\[|S=1,S_z=-1\rangle=|00\rangle,\quad |S=1,S_z=0\rangle=\frac1{\sqrt{2}}\left(|01\rangle+|10\rangle\right), \quad |S=1,S_z=1\rangle=|11\rangle.\]
Наша задача --- придумать алгоритм, который переставляет по циклу проекции. То есть, программа, получив на вход состояние $|S,S_z\rangle$ с $S_z<S$ должна выдавать состояние $|S,S_z+1\rangle$, а состояние $|S,S_z=S\rangle$ должна переводить в $|S,S_z=-S\rangle$.
Интерфейс такой: чтобы провести двухбитовую операцию (cNot или cH), нажимаем сначала на кнопку над первым битом, а затем над вторым. Однобитовые операции (Not или H) получаются двойным нажатием одной кнопки. Когда состояние уже такое, какое требуется, оно выделяется зеленым цветом. Например, $|S=0,S_z=0\rangle$ сразу зеленое, так как оно должно остаться на месте.
| → |
| |||||||||||||||||||||||||||||||||
суббота, 15 марта 2014 г.
Про числа и игры
Что-то стал за собою замечать, что совсем разучился в качестве отдыха и развлечения читать художественную литературу. Вместо этого читаю какие-нибудь книжки по математике, которые поинтереснее и, по возможности, попроще.
Вот, недавно стал читать книгу Конвея "О числах и играх". Много лет назад прочитал вот здесь про комбинаторную теорию в Го. В частности, прочитал про инфинитезимали, и это было круто. Сейчас решил перечитать, и нашел ссылку на Конвея. Вот цитата из первого параграфа:
Но, конечно, самое интересное начинается, если рассматривать пары {L|R}, в которых нет условий на элементы. Получаем определение комбинаторных игр на двоих:
Ну, и скрипт, конечно. Кстати, обнаружил, что поддерживается ползунок — <input type="range" min="0" max="10"... />.
Вот, недавно стал читать книгу Конвея "О числах и играх". Много лет назад прочитал вот здесь про комбинаторную теорию в Го. В частности, прочитал про инфинитезимали, и это было круто. Сейчас решил перечитать, и нашел ссылку на Конвея. Вот цитата из первого параграфа:
"Дедекинд (а до него автор — как считается, Евдокс — пятой книги Евклида) строил вещественные числа из рациональных. Его метод заключался в том, чтобы разделить рациональные числа на два множества L и R так, чтобы ни одно число из L не было больше никакого числа из R, и использовать это "сечение" для определения нового числа {L | R} в случае, если ни L и R не имеют экстремальной точки."Фактически, вот это самое дедекиндовское определение и берется далее за основу:
"Если L, R — два множества чисел, и ни один элемент из L не ⩾ любого элемента из R, то есть число {L | R}. Все числа строятся таким образом."Отличие от дедекиндовского определения в том, что никаких чисел adhoc вводить не требуется. Конечно, еще нужно определить отношение ⩾ для таких чисел и операцию сложения (интересующимся смотреть книжку). Последняя позволяет отождествить определяемые числа с нормальными. Например, ноль выглядит как {∅ |∅}={|}. Вообще, одно и то же число можно представить разными способами, но это не страшно, с обыкновенными дробями тоже так.
Но, конечно, самое интересное начинается, если рассматривать пары {L|R}, в которых нет условий на элементы. Получаем определение комбинаторных игр на двоих:
"Если L, R — два множества игр, то есть игра {L | R}. Все игры строятся таким образом."Игры тоже можно складывать и вычитать. Числа в этом подходе — частный случай игр. А есть игры, числами не являющиеся, в частности, упомянутые инфинитезималы. Но про это как-нибудь в другой раз.
Ну, и скрипт, конечно. Кстати, обнаружил, что поддерживается ползунок — <input type="range" min="0" max="10"... />.
| Двоичное число | результат | |
| -1.1 | ||
вторник, 13 марта 2012 г.
Полезность.
Поскольку занимаюсь в настоящий момент добиванием пакета на Математике, пытаюсь облегчить себе жизнь всеми возможными способами.
Сегодня аспирант навел на полезную мысль. Нет, говорит, в Математике тестов. Выяснилось, что речь о следующем. Когда отлаживаешь какой-нибудь пакет, хорошо иметь набор тестов, который запускается после модификации пакета и сравнивает вновь получившиеся результаты с теми, что получались до модификации. Ну, действительно хорошо. Сказано-сделано, вот простейший пакет, призванный помочь пакетописателям. Работает так. Допустим, что ценой неимоверных усилий была написана функция, вычисляющая числа Фиббоначи:
Затем меняем наше определение
И проверяем на уже известных примерах:
f[1]=f[2]=1; f[n_Integer?Positive]:=f[n-1]+f[n-2];Работает функция правильно, но долго, и хочется ее переписать так, чтобы она работала быстро. И тут вы узнаете, что есть чудная формула\[f_n=\frac{\varphi ^n-(-\varphi )^{-n}}{\sqrt{5}}\,.\] Хочется переписать функцию, но страшно, вдруг где-нибудь сделаешь ошибку. Тогда делаем так: загружаем пакет Tests.m и со старым определением
f[n] создаем некоторое количество тестов:
<<"Tests.m" SaveTest[f[15],"Fib15"]; SaveTest[f[20],"Fib20"]; SaveTest[f[30],"Fib30"];
Затем меняем наше определение
Clear[f];
f[n_Integer?Positive]:=Expand[(((1 - Sqrt[5])/2)^n
+((1 + Sqrt[5])/2)^n)/Sqrt[5]]
И проверяем на уже известных примерах:
RunTests["Fib*"]Получаем гневные сообщения:
Fib15 Failed.
Input:f[15] -> 1364/Sqrt[5]
Output:610 -> 610
Fib20 Failed.
Input:f[20] -> 15127/Sqrt[5]
Output:6765 -> 6765
Fib30 Failed.
Input:f[30] -> 1860498/Sqrt[5]
Output:832040 -> 832040
{"Fib15" -> "Failed", "Fib20" -> "Failed", "Fib30" -> "Failed"}
Значит, где-то затупили... Ага, забыли минус, исправляем:
Clear[f];
f[n_Integer?Positive]:=Expand[(-((1 - Sqrt[5])/2)^n
+ ((1 + Sqrt[5])/2)^n)/Sqrt[5]]
Ну вот, теперь все в порядке:
Fib15 Passed.
Fib20 Passed.
Fib30 Passed.
{"Fib15" -> "Passed", "Fib20" -> "Passed","Fib30" -> "Passed"}
Ну, там есть еще некоторые возможности, желающим глядеть в код или использовать ?"Tests`*". Кстати, тесты хранятся в виде файла "tests.tst" в рабочей директории, поэтому не теряются от сессии к сессии.
четверг, 9 февраля 2012 г.
Processing
Узнал на днях про язык Processing для забав с анимацией и интерактивностью. Действительно, сделать простую анимацию можно с полпинка, возьму на вооружение. Что приятно, можно сделать экспорт в апплет, а в новой альфа версии и в javascript. Хотя для анимации java более подходяща, т.к. быстрее.
Built with Processing
среда, 25 января 2012 г.
Скрипт для задач на построение
Тестовая версия скрипта для задач на построение с помощью циркуля и линейки. Инструменты:
- point
- ставит свободные точки и пересечения кривых. Чтобы поставить точку на кривой нужно два раза по ней кликнуть. Чтобы поставить точки пересечения двух кривых нужно кликнуть на одну (она выделится), а затем на вторую.
- line
- функционал линейки. Чтобы провести линию через две точки, нужно на них кликнуть по очереди.
- circle
- функционал циркуля. Чтобы провести окружность с центром в заданной точке заданного радиуса, нужно кликнуть сначала на точку центра, а затем на пару точек, определяющих радиус.
- delete
- стирательная резинка.
четверг, 24 ноября 2011 г.
Выключи ХАЛа
Для меня лучший способ избавиться от идефикса -- воплотить в жизнь. На этот раз пришлось потратить два вечера, чтобы по мотивам клипа из Гришиного Г+ и задачи с Диофанта сваять скрипт под рабочим названием "Выключи ХАЛа". Сделать это можно, нажимая на кнопки и добившись, чтобы все стали темными. Проблема в том, что переключать можно только зеленые и черные кнопки и действовать максимум двумя руками (т.е., можно переключать за один ход кнопки не более, чем из двух рядов). ХАЛ, соответственно, сохранив остатки уважения к человеку, будет тоже переключать кнопки не более, чем в двух рядах, и доступны для него только красные и зеленые кнопки. Когда ход закончен, жмем Done. Пасовать можно только первый раз, а следующие пасы (или переключения, сохраняющие количества красных, зеленых и черных кнопок во всех рядах) приведут к пасам ХАЛа. Если зеленых кнопок не осталось, приходится нажимать на черные (а ХАЛу на красные).
>
| N rows: | |
| Nmax columns: |
P.S. Блин, опять мой любимый FF притормаживает (хотя на локальной версии работал отлично). Круче всего эта страничка смотрится Chrome-ом.
четверг, 4 августа 2011 г.
Проверка жизнью javascript в браузерах
Чтобы совсем не потерять форму в программировании, накатал сегодня на javascriptе известную игру жизнь, только на треугольной решетке. Вскрытие показало, что градиентные заполнения даются браузерам с трудом и что победителем в этом является Opera. Мой любимый FF жутко тормозит, а Google chrome в спешке "не выговаривает слова", т.е., не рисует градиент вообще.
воскресенье, 13 февраля 2011 г.
О вреде азартных игр
Все знают игру "Орел или Решка". Это когда один бросает монетку, а другой угадывает. Мы в эту игру в теор. отделе с Ваней иногда играем. Выигравший спокойно допивает чай, а проигравший бежит по мелкому, но срочному делу, например бумажки за двоих подписывать. Все честно, теория вероятности учит, что в среднем будешь проигрывать столько же, сколько выигрывать. Но это только если действительно бросаешь монетку. А если просто задумываешь число, то может быть и не так. Не каждый ведь может датчиком случайных чисел работать. Человек склонен придерживаться какого-то рецепта даже в таком деле. Какой бы этот рецепт ни был, его можно использовать в свою выгоду.Вот только как?
Ниже скрипт, который делает выводы из предшествующей игры и пытается увеличить вероятность своего выигрыша. Объясню как им пользоваться. Нужно загадать Tails или Heads и дальше нажать на кнопку Guess. Алгоритм покажет свою догадку и нужно сказать ему, угадал он или нет, нажав на одну из появившихся кнопок (только честно). И так много раз. Во втором поле показываются число побед компьютера,ваших побед и ваш выигрыш, а если число с минусом --- то проигрыш. Конечно, чтобы выигрыш компьютера стал заметен на фоне статистического шума, придется, наверное, долго монетку бросать. Следующие два поля и кнопка призваны облегчить задачу. Только если ими пользоваться, вам придется мне поверить, что компьютер сначала выдает догадку, а потом бросает монету, не подглядывает. В первом поле нужно указать паттерн, а во втором --- количество его повторений. Потом нажать на кнопку Iterate. Формат паттерна такой: h-heads,t-tails, ?-честно кинуть монетку, *- кинуть или не кинуть монетку (т.е., звездочка позволяет избежать периодичности). Например, если паттерн ht*, а число итераций 2, то реальная последовательность бросаний при нажатии на Iterate может быть одной из девяти: hthhth,hthhtt,hthht,htthth,htthtt,httht,hthth,hthtt,htht.
Короче, Enjoy. Только не надо сильно много повторений заказывать, а то зависнет браузер.
P.S. Кстати, можно устраивать бойни между скриптами, так что если кто-нибудь напишет свой скрипт, можно его с моим стравить. Ну, чтобы было понятно, всегда есть нейтральная стратегия: честно бросать монетку. Тогда в среднем никто в проигрыше не останется, так что датчик случайных чисел не предлагать. Исход каждого раунда, естественно, будет передаваться и вашему скрипту. Играть понятно как: оба выкладывают монеты и один выигрывает при совпадении, а другой при несовпадении.
P.P.S. Да, и еще, чтобы не забыть, минизадача: понять закономерность в последовательности
0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,...
Ниже скрипт, который делает выводы из предшествующей игры и пытается увеличить вероятность своего выигрыша. Объясню как им пользоваться. Нужно загадать Tails или Heads и дальше нажать на кнопку Guess. Алгоритм покажет свою догадку и нужно сказать ему, угадал он или нет, нажав на одну из появившихся кнопок (только честно). И так много раз. Во втором поле показываются число побед компьютера,ваших побед и ваш выигрыш, а если число с минусом --- то проигрыш. Конечно, чтобы выигрыш компьютера стал заметен на фоне статистического шума, придется, наверное, долго монетку бросать. Следующие два поля и кнопка призваны облегчить задачу. Только если ими пользоваться, вам придется мне поверить, что компьютер сначала выдает догадку, а потом бросает монету, не подглядывает. В первом поле нужно указать паттерн, а во втором --- количество его повторений. Потом нажать на кнопку Iterate. Формат паттерна такой: h-heads,t-tails, ?-честно кинуть монетку, *- кинуть или не кинуть монетку (т.е., звездочка позволяет избежать периодичности). Например, если паттерн ht*, а число итераций 2, то реальная последовательность бросаний при нажатии на Iterate может быть одной из девяти: hthhth,hthhtt,hthht,htthth,htthtt,httht,hthth,hthtt,htht.
Короче, Enjoy. Только не надо сильно много повторений заказывать, а то зависнет браузер.
P.S. Кстати, можно устраивать бойни между скриптами, так что если кто-нибудь напишет свой скрипт, можно его с моим стравить. Ну, чтобы было понятно, всегда есть нейтральная стратегия: честно бросать монетку. Тогда в среднем никто в проигрыше не останется, так что датчик случайных чисел не предлагать. Исход каждого раунда, естественно, будет передаваться и вашему скрипту. Играть понятно как: оба выкладывают монеты и один выигрывает при совпадении, а другой при несовпадении.
P.P.S. Да, и еще, чтобы не забыть, минизадача: понять закономерность в последовательности
0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,...
пятница, 11 февраля 2011 г.
Продолжая тему (Задача Томсона)
Остановиться на достигнутом не удалось. Во-первых, сразу стало интересно, сколько существует правильных многогранников в четырехмерии и в n-мерии. Интуитивно почему-то казалось, что чем больше размерность, тем больше правильных многогранников. Подключение к всемирному разуму показало, что жестоко ошибался. После просмотра изумительной красоты картинок, естественно, захотелось завращать все и вся, тем более, что всего-то и надо было научиться правильно определять вершины. Но тут я застрял. Поскольку мыслительного процесса хватает на работе, решил схитрить и решить задачу по-физически, а именно, посадить нужное число точек на сферу и организовать между ними отталкивание. Идея была такая, что эта конфигурация сама устаканится в правильный многогранник. Наивный... Долго ждал, но так и не дождался... Потом решил хоть в трехмерии метод опробовать. Бросил 8 точек и понял, что вовсе не куб получился. Родилась задача: Восемь одинаковых точечных зарядов находятся на сфере. Найти минимум кулоновской энергии.
P.S. Чтобы система устаканивалась, нужно, конечно, не ускорение, а скорость приравнивать силе. В принципе, это тоже довольно физично: частицы плавают в жидкости.
P.S. Чтобы система устаканивалась, нужно, конечно, не ускорение, а скорость приравнивать силе. В принципе, это тоже довольно физично: частицы плавают в жидкости.
Подписаться на:
Сообщения (Atom)