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

Вот оно до 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.

Клен, 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 байта или меньше.

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)

Кона 63

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

2.68545200106530644530971483548179569382038229399446295305115234

Хаскелл, 5

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

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

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

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

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

дает

2.68545843

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

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

wxMaxima 3

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

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

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

2.681499686663101b0

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

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).

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

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

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

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

2.6854513126595827

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

Python, 64 66

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

Выходы:

2.68545200106530644530971483548179569382038229399446295305115234555

Рубин - 73

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

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

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

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

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 действительно неплохо работает.

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

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

"2.685452001065306445309714835481795693820382293994462953051152"

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

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).

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`