Константа Хинчина как можно больше десятичных разрядов в 64 байтах или меньше

22

Константа Хинчина является любопытной математической константой, которая, по словам Вольфрама Матвольда , «общеизвестно сложно вычислить с высокой точностью» .

Вот оно до 100 цифр:

2,685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

Написать программу на 64 байта или менее, которая выводит константу Хинчина в максимальное количество правильных десятичных разрядов.

  • Вы не можете использовать любые встроенные библиотечные константы или функции, непосредственно связанные с константой Хинчина. (например, Math.Khinchin (точность) определенно не допускается.)
  • Вы можете использовать математические библиотеки для вычисления логарифмов, суммирования и т. Д.
  • Вы можете жестко закодировать весь или часть своего ответа.
  • Ваша программа должна производить конечный вывод и запускаться менее чем за час на достаточно современном компьютере (например, перечисленных здесь ).
  • Вы должны вывести на стандартный вывод. Там нет ввода.
  • Вы можете использовать любые символы, которые хотите, если http://mothereff.in/byte-counter регистрирует 64 байта или меньше.

счет

Ваша оценка - это число последовательных цифр в константе Хинчина, которое ваша программа выводит правильно, начиная с 2,68 ... Вы можете выводить неправильные цифры, но только последняя правильная цифра засчитывается в ваш счет.

Например, вывод

2.68545200 2 06530644530971483548179569382038229399446295305115234555721

набрал бы 9 баллов. Один для каждой из цифр, 2 6 8 5 4 5 2 0 0но ничего после 2, которое должно быть 1.

Кальвин Хобби
источник
2
Почему вы разрешаете жестко задавать весь ответ?
Уильям Барбоза
5
@WilliamBarbosa почему бы и нет? в идеале должно быть решение с оценкой лучше 31. Если нет, то это неудачно.
Мартин Эндер
1
Разрешен ли Юникод? Как считать это?
aditsu
3
Вы должны разрешить 64b вместо 32 и считать все символы как байты UTF-8 ( mothereff.in/byte-counter ) (= от 1 до 4 байтов на символ в зависимости от плоскости Unicode). Кроме того, существующие решения могут быть легко адаптированы к 64b
xem
3
@PeterTaylor Я кодировал решение CJam с плавающей запятой, и позвольте мне сказать, что ограниченная точность - не главная проблема: p
aditsu

Ответы:

11

Клен, 200+

Следующая команда Maple вычисляет константу Хинчина с требуемой точностью (здесь 200 цифр):

evalf[200](exp(sum((-1)^k*(2-2^k)*ζ(1,k)/k,k=2..∞)/ln(2)));

Этот код должен работать, если вы копируете и вставляете его в графический интерфейс Maple. Он ζзанимает два байта в UTF-8, а три байта в общей сложности 62 байта.

Запись ASCII-версий этих символов, даже с уловкой использования min()вместо infinity, увы, увеличивает число байтов до 66:

evalf[200](exp(sum((-1)^k*(2-2^k)*Zeta(1,k)/k,k=2..min())/ln(2)));

Количество вычисляемых цифр можно легко скорректировать, изменив число в квадратных скобках после evalf. На моем довольно старом компьютере 200 цифр заканчиваются примерно через полчаса; ваш может быть способен на большее. Обратите внимание, что клен раундов результат до требуемой точности, а не обрезает его, поэтому фактическое количество совпадающих цифр может быть несколько меньше.

Этот метод вычисления константы основан на формуле (9) со страницы MathWorld , на которую ссылается Gosper (1996, личн. Комм.):

            Уравнение

Это был самый эффективный метод, который мне удалось (едва) сжать в 64 байта или меньше.

Илмари Каронен
источник
Довольно аккуратно. Если бы только у меня был клен: /
Увлечения Кэлвина
12

CJam - 118

2'."*;TeT?_aN{.i9B*ZEay
G`9~eW}nE=Lr-`B}    )D>9m9"136b

Попробуйте это на http://cjam.aditsu.net/

Так как stackexchange уничтожает некоторые символы, вот программа, которая генерирует программу выше; сначала запустите его, а затем запустите его вывод:

"2'.\""685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697995153465905288090 136b:c"\"136b"

Объяснение:

2pushes 2
'.pushes точка
"…"- строка, содержащая оставшиеся цифры в закодированном виде,
128bпреобразует строку в число, обрабатывая символы как цифры в базе 128 (через их код ASCII)

aditsu
источник
2
Очень хорошо. Можете ли вы объяснить это немного?
Кайл Канос,
@KyleKanos добавил объяснение
aditsu
Это потрясающе. Я должен однажды выучить CJam ... Кроме того, я не могу заставить вашего онлайн-переводчика работать в браузере Opera, хотя он работает на моем Firefox. Вероятно, проблема с оперой, но я подумал об этом.
Кайл Канос
1
@ Calvin'sHobbies В 1997 году Ксавье Гурдон вычислил первые 110 000 цифр за 22 часа, используя максимум 250 МГц процессор. Таким образом, вы можете вычислить в 1000 раз больше цифр, чем это решение за час. web.archive.org/web/20120218093629/http://pi.lacim.uqam.ca/…
Алекс Л
1
@ Calvin'sHobbies см. Эту ссылку для полной программы, которая, как сообщается, рассчитала 2000 цифр за 7 секунд.
aditsu
5

Кона 63

Простой жестко заданный ответ:

2.68545200106530644530971483548179569382038229399446295305115234
Кайл Канос
источник
ммм не так ли 63?
xem
@xem: небольшая опечатка. Исправлена. : D
Кайл Канос
1
Также работает в GNU BC
Digital Trauma
@DigitalTrauma: Возможно, работает и на нескольких других языках, я просто придерживался Kona, потому что уже отвечал на него раньше.
Кайл Канос,
5

Хаскелл, 5

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

main=print$product[(1+1/r/(r+2))**2`logBase`r|r<-[1..99999999]]

Это вычисляет 2.6854453689859192, что является колоссальными 5 символами константы. Вольфрам был прав, когда они сказали, что «трудно вычислить с высокой точностью».

Zaq
источник
63-байтовая программа - 1 байт, чтобы сэкономить! Ницца!
Цифровая травма
Дополнительный байт мог бы быть другим 9, но мой компьютер не мог справиться с этим, и даже если бы он мог, я не уверен, приведет ли это к другой точной цифре.
Зак
Используя Ruby, я в основном достиг максимума, который мог сделать, используя эту формулу, выполнив это за 60 секунд. Я получил 2.685451312659854: tio.run/##KypNqvz/P9vWkEvDUE/…
Просто Красивое Искусство
3

Математика, 6

(Times@@Rest@ContinuedFraction[Pi,977])^(1.`9/976)

дает

2.68545843

и использует только 50 байтов, так что есть место для поиска чего-то лучшего, чем Piиспользование большей непрерывной дроби, но я не уверен, что это станет намного лучше с продолжительностью работы в час. (Особенно после нахождения лучшей комбинации, вероятно, займет несколько дней, если я просто использую грубую силу.)

(Конечно, вы были достаточно умны, чтобы запретить Khinchin~N~2000, где 2000можно заменить любое число, которое дает вам результат в течение часа;).)

Мартин Эндер
источник
1
+1 за использование значения константы, а не только формулы.
Ви.
2

wxMaxima 3

Фактически вычисляемый метод!

bfloat(product((1+1/(n*(n+2)))^(log(n)/log(2)),n,1,10000));

Примерно через 25 минут он вернулся

2.681499686663101b0

Теперь я понимаю, почему страница Mathematica так заявляет. У меня есть 6 символов для игры, но я не могу представить, что добавление 6 0 будет (а) проходить через <60 минут и (б) даст мне более точное решение.

Кайл Канос
источник
Подозрение: каждый дополнительный ноль добавляет менее одной правильной цифры: '(
Просто Красивое Искусство
1

GNU BC , 5 цифр (54-байтовая программа)

Попытка реально рассчитать. GNU BC ужасно медленный. Это продолжалось 53 минуты на виртуальной машине Ubuntu 14.04, работающей на MacBook Pro Retina в середине 2012 года. Странно, но в виртуальной машине он работает быстрее, чем голая железная OSX - вероятно, версия GNU лучше оптимизирована для этой задачи, чем версия BSD.

for(k=r=1;r++<10^7;)k*=e(l(1/(r*(r+2))+1)*l(r)/l(2))
k

Выход:

2.68544536902156538295

Заметка:

bc -lдолжен быть использован для e()и l()функции (и настройки шкалы = 20).

Цифровая травма
источник
1

Расчет с плавающей запятой CJam - 6

1e8{I{1.II2+*/)I2mL#*}1.?}fI

Вписывается в оригинальные 32 байта :)

Работая с Java-интерпретатором с использованием Java 8, он выводит это примерно через минуту на моем ноутбуке:

2.6854513126595827

Онлайн переводчик, вероятно, займет слишком много времени.

aditsu
источник
1

Python, 64 66

print"2.%i"%int('anljsgqif7gwwwsrntcz7zv2obv6gv5us7fzfwjcaj',36)

Выходы:

2.68545200106530644530971483548179569382038229399446295305115234555
Дэн Гетц
источник
Вы можете сократить пространство после, printчтобы втиснуть в другого персонажа.
xnor
1

Рубин - 73

К сожалению, вы можете конвертировать только в базу 36, используя to_iв Ruby:

"2.#{"hmegxpkvliy1vaw4lb054ep8wsqwkz2yx9cm9jvc9yfd48j".to_i 36}"

который возвращается

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"
О.И.
источник
1

RPL / 2, 7 вычисленных цифр, 61 байт

'LN(FLOOR(1/X))/(X+1)/LN(2)' { 'X' 1e-9 1 } 1e-7 INT DROP EXP

возвращает 2.68545210493822 за одну минуту на моем старом (intel Core2) ноутбуке.

Насколько мне известно, в RPL / 2 нет дзета-функции, поэтому я использовал интеграцию (формула 15 со страницы Mathworld). В принципе, точность можно улучшить, заменив 1e-9 и 1e-7 меньшим числом, но мне явно не хватало памяти для этого.

Конечно, прибегая к бесконечному продукту, решаем этот вопрос, похоже,

1 1 1e9 FOR I 1 1 I dup 2 + * / + I LN 2 LN / ^ * NEXT

и будет работать как на калькуляторе HP RPL, но оказывается на два порядка медленнее (на ноутбуке, не пробовал на моем HP!) и дает только 6 цифр.

Таким образом, алгоритм интеграции в RPL / 2 действительно неплохо работает.

Перламутр
источник
0

Многие языки репл, 61

извините, не нашел лучшего решения.

"2.685452001065306445309714835481795693820382293994462953051152"

Правила не говорят, что правильной числовой последовательности не может предшествовать кавычки, поэтому я использую это. Выполнив это, например, в консоли JS, вы получите ту же строку, включая кавычки.

XEM
источник
1
Да, это действительно даже с цитатой впереди. Имеет значение только то, что 2.685 ... не прерывается.
Увлечения Кэлвина
0

Python (5)

x=3**.1
p=1
for _ in[1]*10**6:p*=(x//1)**1e-6;x=1/(x%1)
print(p)

Output: 2.6854396408091694

(Вывод занимает ~ 2 секунды.)

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

Забавно: я заморозил мой компьютер и должен был сделать жесткое выключение после попытки сократить этот код с Python для гольфа трюка замены for _ in[1]*10**6:codeс exec("code"*10**6).

XNOR
источник
0

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`
elipszilon
источник