Это было весело! Однако с тремя цифрами веселье закончилось слишком рано. Эта задача похожа, но мы продолжим веселье.

Соревнование

Выведите как можно больше цифр Золотого сечения φ. Золотое сечение определяется как число, которое удовлетворяет φ = (φ + 1) / φ, и первые 100 цифр определяются как:

1,6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Эта задача не о вычислении φ! Речь идет о печати как можно большего количества цифр без использования какого-либо метода для этого дважды. Так что найдите как можно больше творческих способов получить свои цифры!

ограничения

Само по себе печатание цифр φ было бы слишком простым, поэтому вот правила:

1. Вы должны построить число по порядку слева направо , либо печатая его по частям, либо создавая строку слева направо и печатая ее в конце - вы даже можете сгенерировать массив цифр, а затем соединить его и распечатайте его, пока вы делаете это по порядку. В следующих правилах «печать» и «вывод» могут относиться к любому из этих процессов (например, если вы строите строку, и строка содержит 1.6то, что считается 1.6уже напечатанным).
2. За ваш код вы получаете бюджет в 15 символов на цифру . Период не засчитывается в этот бюджет, но также должен быть напечатан. Обратите внимание, что ограничение распространяется только на общий размер кода: вы можете использовать более 15 символов для любой цифры, если вы не используете больше в среднем. На самом деле, вы можете создать «долг» в персонажах и «погасить его» позже. Например, для печати у 1.618вас есть 60 символов.
3. Стандартные библиотеки include / import не учитываются в размере кода. Но вы не можете дать эти псевдонимы бесплатно!
4. Вы не должны использовать цифру, которую вы в настоящее время генерируете, или те, которые вы уже напечатали. Например, 1в вашем исходном коде может нигде не появляться, потому что это самая первая цифра. Код, который выводит 8in, 1.618может использовать любую или все цифры [0234579], но ни одну из [168]. Для этой цели все литералы, которые эквивалентны одной цифре, обрабатываются как эта цифра . Так что, если ваш язык может представлять, 9как '\t'вы не можете использовать это где-либо, где вы не могли бы использовать 9вместо этого.
5. Вы не должны производить несколько цифр одновременно. Должна быть возможность четко разделить ваш код на куски, которые генерируют одну цифру за раз.

6. Вы не должны ссылаться на какую - либо встроенную функцию, математический / логический / побитовый / строковый оператор, переменную или константу, которые вы использовали в коде, который сгенерировал более раннюю цифру. Исключением являются преобразование целых чисел в строку, конкатенация строк и функции печати, которые могут вам понадобиться для каждой отдельной цифры. Обратите внимание, что не имеет значения, под каким именем вы ссылаетесь на какое-либо встроенное: просто потому, что вы используете псевдоним встроенного в PIобоих, pи qэто не значит, что вы можете использовать его pодин раз и qодин раз. Кроме того, вы имеете право использовать имя дважды , если это относится к двум различным встроенным функциям, как строка lengthи массив length.

   _{Если ваш язык программирования не имеет функций, используйте ваше лучшее суждение о том, каким будет эквивалент - например, для сценариев bash, при вызове других программ следует соблюдать правила, наложенные на функции}

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

Последствия

Следующие пункты все подразумеваются вышеуказанными правилами, но я добавляю их здесь, чтобы избежать вопросов, которые уже возникли в песочнице:

• Вам не разрешается перезаписывать части вашего вывода, печатая некоторые пробелы (обычно '\b') между ними.
• Циклы, которые генерируют / выводят несколько цифр, запрещены. (Циклы, которые вычисляют одну цифру, все же хорошо.)
• Использование запутанной версии (1 + √5)/2или деление чисел Фибоначчи для получения более чем одной цифры запрещено.
• Вы не можете предварительно вычислить 10 цифр и сохранить их в 10 переменных, а затем просто ссылаться на них, потому что эти ссылки на переменные не генерируют цифру - код, заполняющий переменную, делает, что является нарушением правила 6.
• Фактически, вы не можете повторно использовать любые предыдущие (или промежуточные результаты), потому что это будет означать, что две цифры будут совместно использовать код для генерации .
• В противном случае вы можете использовать любые средства (которые не должны быть чисто математическими) для генерации цифр. (А ты должен!)
• На самом деле нет необходимости что-либо вычислять, если вы можете извлечь правильные цифры из разных мест, используя вашу стандартную библиотеку.
• Вы можете использовать оператор несколько раз, генерируя одну цифру, поэтому 2+2+2будет честной игрой генерировать первую цифру 6(хотя она вряд ли самая короткая).
• Вы можете использовать любые литералы так часто, как хотите, потому что они не являются встроенными константами. Поэтому до тех пор, пока вам не нужно печатать 5, вы можете использовать 5в своем коде столько символов, сколько захотите.
• Вы не можете жестко закодировать вывод, потому что это будет связано с использованием цифр, которые вы выводите.

Вкратце: не используйте метод генерации цифр дважды и не используйте цифру, которую вы выводите в данный момент или уже напечатали.

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

счет

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

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

PS: если кто-то бьет 100 цифр выше, вот еще несколько .

PHP, 100 цифр

Я, вероятно, немного изменяю правила, но в PHP есть десятки констант на выбор:

<?php
echo TRUE . '.' . PM_STR . DNS_A . MSG_EOR . LC_ALL . T_FMT . LOCK_UN . SQL_DATE
. E_NOTICE . IMG_WBMP . INI_ALL . E_PARSE . SOCKET_EBADF . LOG_USER .
IMAGETYPE_JPC . IMG_PNG . GLOB_MARK . LOCK_NB . LOG_NDELAY . D_FMT . PHP_ZTS .
GLOB_ERR . AM_STR . SQL_DOUBLE . SOL_TCP . FILE_APPEND . LOG_ERR . SORT_ASC .
SOCK_RAW . LOG_INFO . LC_TIME . SQL_FLOAT . SORT_DESC . INFO_MODULES . E_ERROR .
IMG_GIF . SQL_REAL . LOG_DEBUG . DNS_NS . CODESET . CAL_FRENCH . CURLE_OK .
LDAP_OPT_RESTART . LOCK_SH . XML_PI_NODE . SQLITE_INTERRUPT . MYSQLI_ASYNC .
CURLM_OK . SNMP_NULL . SQLITE_NOMEM . LC_MESSAGES . IMG_JPG . SO_KEEPALIVE .
SOCKET_ENXIO . LOCK_EX . D_T_FMT . ENT_QUOTES . LOG_NOTICE . SOCK_RDM .
INPUT_ENV . CURLAUTH_NTLM . INPUT_SESSION . AF_INET . IMG_JPEG . SQL_CONCURRENCY
. SEEK_SET . SOCKET_EIO . LC_CTYPE . PHP_URL_QUERY . LOG_KERN . INI_SYSTEM .
IMAGETYPE_BMP . SEEK_END . JSON_HEX_QUOT . LOG_PID . LIBXML_DTDATTR .
XML_DOCUMENT_NODE . PHP_DEBUG . LOG_CRIT . ENT_IGNORE . LC_NUMERIC .
DOM_NOT_SUPPORTED_ERR . PHP_URL_FRAGMENT . FILE_TEXT . IMAGETYPE_TIFF_II .
LOG_CONS . LOG_EMERG . UPLOAD_ERR_CANT_WRITE . MSG_PEEK . SQLITE_OK . FNM_PERIOD
. AF_UNIX . CURLPROTO_FTPS . STREAM_NOTIFY_FAILURE . MYSQL_BOTH .
CURLE_FTP_ACCESS_DENIED . MSG_OOB . FTP_TEXT . LC_MONETARY .
CURLE_COULDNT_CONNECT . SQLITE_BUSY . "\n";

Это, вероятно, не очень переносимый код, но он отлично работает в моей системе. Вот код, который его сгенерировал:

<?php
$phi = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375";
echo "<?php\necho TRUE . '.' . ";
$consts = get_defined_constants();
foreach($consts as $k=>$v) if (preg_match('/\d|TRUE|PHP_EOL/',$k)) unset($consts[$k]);
for ($p=0;$p<strlen($phi);$p++) {
  $d = ord($phi[$p]) - 48;
  $min = 999;
  foreach($consts as $k=>$v) {
    if (strlen("$v")==1 && $v==$d && strlen($k)<$min) {
      $min = strlen($k);
      $maxk = $k;
    }
  }
  if ($min==999) break;
  echo "$maxk . ";
  unset($consts[$maxk]);
}
echo "\"\\n\";\n";

Perl - 37 цифр

use Math::Trig;
use POSIX;

print
  !0,'.',chop$=||$=,A==A,2**3,$|,++$^F,75/5/5,pi*pi%\_,4+4,a^Y,w&'?',~"\xcb",$^=~y/_//c,
  ord"\b",unpack(h,"\t").@{[c,c,c,c]},$#{[b..j]},"$^W"|'$',$^H>>log$^H,cos()- -cos,$[,
  $-=sqrt%SIG,$%=$],$+[*$=~/($)/],split('',$~).map(glob,"{,,,}{,}"),index(\L,L),
  exp(exp)<<exp,ceil(sinh acosh$^C).keys{stat$0},rindex(\R,R),($s=ssssss)=~s/s//g,
  $?=acos(--$z),$^T=pack(u,$^T.$^T.TTTT),B~~B,C<=C,length$^V,

392 байта в настоящее время (10,6 на цифру).

Выход:

1.618033988749894848204586834365638117

Добровольные ограничения

Я добавил несколько дополнительных ограничений, чтобы ограничить использование языковых функций, которые могли бы тривиализировать проблему. Например, разыменование @{...}массива и окончательный индекс массива $#{...}используются только один раз. Каждый массив используется генерируется другим способом (сравните [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Кроме того, ни один символ или голое слово не используются более одного раза, хотя это явно разрешено в описании вызова. Я думаю, что это хорошая идея для perl (или любого языка со специальными переменными только для int (есть ли другие?)), Потому что он ограничивает количество неявных int-преобразований.

Частей

!0                       # returns 1
'.'
chop$=||$=               # $= is 60, chop the 0, returns 6
A==A                     # returns 1 (because 0==0)
2**3                     # returns 8
$|                       # auto flush, returns 0
++$^F                    # max system filehandle pre-incremented, returns 3
75/5/5                   # returns 3
pi*pi%\_                 # pi² mod a large value, returns 9
4+4                      # returns 8
a^Y                      # bitwise 'a' xor 'Y', returns 8
w&'?'                    # bitwise 'w' and '?', returns 7
~"\xcb"                  # bitwise inversion of char 203, returns 4
$^=~y/_//c               # count non-underscores in $^, returns 9

ord"\b"                  # returns 8
unpack(h,"\t")           # unpack "\t" as a hex nibble, returns 9
@{[c,c,c,c]}             # anonymous array, returns 4 in scalar context
$#{[b..j]}               # final index of the range b..j, returns 8
"$^W"|'$'                # bitwise '0' or '$', returns 4
$^H>>log$^H              # $^H is 256, log$^H is ~5, returns 8
cos()- -cos              # cos(undef) is 1, subtract -1, returns 2
$[                       # array start index, returns 0

$-=sqrt%SIG              # set $- to sqrt(23), returns 4
$%=$]                    # set $% to the version number, returns 5
$+[*$=~/($)/]            # match end on *$ (aka *main::$), returns 8
split('',$~)             # split "STDOUT" into chars, returns 6 in scalar context
map(glob,"{,,,}{,}")     # an array of 8 empty strings, returns 8 in scalar context
index(\L,L)              # finds 'L' in 'SCALAR(...)', returns 3

exp(exp)<<exp            # 2.718281828 << 1, returns 4
ceil(sinh acosh$^C)      # ceil(2.30129...), returns 3
keys{stat$0}             # stat$0 is an array with 13 entries, which has 6 keys when
                         # interpreted as a hash, returns 6 in scalar context
rindex(\R,R)             # finds 'R' in 'SCALAR(...)' in reverse, returns 5
($s=ssssss)=~s/s//g      # replace the every 's' in 'ssssss' with nothing, returns 6

$?=acos(--$z)            # set $? to 3.14159... implicit int conversion, returns 3
$^T=pack(u,$^T.$^T.TTTT) # set $^T to "8,30P,...", returns 8
B~~B                     # returns 1 (because B represents the same thing as B)
C<=C                     # returns 1 (because 0<=0)
length$^V                # string length of $^V, returns 7

Python 2.7, 19 цифр, 231 соответствующий символ

from math import ceil, pi, trunc, gamma, sin

print ''.join(map(str,
[33-32,
chr(46),
~-7,
8>>3,
trunc(gamma(4.3)),
'x'.find('x'),
22/7,
range(4).pop(),
len('am I phi?'),
52%44,
2*4,
5|2,
ord('/'),
'\b',
5+2+2,
2<<2,
eval("5+2+2"),
ceil(pi),
'\b',
'\b',
str(sin(5))[5],
5&52]))

Ruby 2.1 для 54 цифр, 808 символов

#!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket
print 2/2,?.,9-3,3&5,2*4,2^2,7%4,55>>4,5+4,2<<2,-~7,5|2,2**2,(2r+2+5).to_i,(2.2+5).ceil,(55r/5-2).floor,(2.2*2).to_i,(2r*2*2).ceil,(2.2**2).floor,2.to_bn<<2,__LINE__,$<.to_i,IO::LOCK_NB,Errno::EIO::Errno,File::APPEND,'aaaaaa'.size,?a.encoding.name.sub(/\D+/,''),%w[a a a].size,%w[a b c d].to_set.size,%w[a a a].count,Socket::AF_NS,Date.jd(Date::ITALY).wday,*Digest::MD5.digest(?j).scan(/\d/),Set[?a,?b,?c].count,SignalException.new('FPE').signo,Float::ROUNDS,begin
exit false
rescue Object
$!.status
end,Process::RLIMIT_NPROC,:aaaaaaa.size,Prime.first,?/.next,{a:p,b:p,c:p}.size,STDIN.lineno,?a.crypt('at')[/\d/],{a: :a}.find_index([:a,:a]),/b/=~'aaaaaaaaab',[?a,?b].index(?b),:aaaaaaab=~/b/,?\t.ord,'aaaaaaaab'=~/b/,open(?/).pos,'aaaaab'.index(?b),?\a.bytes{|b|break b},'aaaaaaa'.rindex(?a),%w[a a].map.size

Эта программа работает с ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Системы, отличные от OpenBSD 5.5, могут иметь разные значения для нескольких цифр.

Интерпретации

Ограничения этой задачи, особенно ограничение 6, не являются точными для Ruby. Поэтому я добавляю свои собственные интерпретации:

1. Круглые скобки, точка и двойное двоеточие не являются операторами. Скобки просто меняют порядок операций. Точка вызывает методы, как в $<.fileno, а двойное двоеточие получает константы, как в IO::LOCK_NB. Имя метода или константы является частью операции. Поскольку () . ::не являются операторами, я не применяю к ним ограничение 6. Я могу использовать их повторно, чтобы генерировать больше цифр.
2. Метод с другой реализацией - это другой метод. Например, Array#countи Enumerable#countне являются одной и той же функцией для ограничения 6. Оба метода действуют одинаково, но Array#countпереопределяют Enumerable#countс другой реализацией. Если я использую Array#countдля создания одной цифры, я могу использовать Enumerable#countдля создания другой цифры.
3. Класс # новый является одним из методов. В Ruby Mutex.new, Random.new, Time.newи так далее относятся к той же методе, Class#new. Я использую, SignalException.newчтобы сгенерировать одну цифру. Из-за ограничения 6 я больше никогда не смогу использовать Class#new.
4. Константы для классов или модулей все еще являются константами. В Ruby имена классов как Floatи IOявляются константами! Я использую, IO::LOCK_NBчтобы сгенерировать одну цифру. Из-за ограничения 6 я больше никогда не смогу использовать IO. Эта интерпретация связывает только Ruby, а не другие языки, где имена пакетов не являются константами.
5. Литералы не являются константами. Хотя 2 является математической константой (независимой от любых переменных), в Ruby она не является константой. Я не применяю ограничение 6 к литералам, и я могу повторно использовать литерал 2 для более чем одной цифры.
6. Литералы не являются операторами. Я не применяю ограничение 6 к скобкам или кавычкам, которые образуют буквенные массивы, хэши, регулярные выражения или строки, как в [] {} // ''. Я всегда могу использовать такие литералы, чтобы генерировать больше цифр.
7. Две константы с одинаковым значением - это одна и та же константа. File::APPENDи IPSocket::LOCK_UNдва имени для одного и того же числа 8. Ограничение 6 говорит: «не имеет значения, под каким именем вы ссылаетесь на какой-либо встроенный». Потому File::APPENDи IPSocket::LOCK_UNотличаются только по имени, они должны быть таким же постоянным, поэтому я не могу использовать их для двух цифр.
8. Две цифры могут не относиться к одной и той же глобальной переменной. Это закрывает лазейку. Ограничение 6 распространяется только на функции, операторы и константы. Ограничение 4 распространяется только на литералы. $SAFEявляется встроенной глобальной переменной, а не функцией, оператором, константой или литералом. $SAFEимеет значение 0. С помощью лазейки, я могу использовать повторно, $SAFEчтобы генерировать каждую цифру 0 в программе. Я закрываю лазейку, интерпретируя ограничение 6 для ограничения глобальных переменных.

Комментарии

Первая линия #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Ruby анализирует эту строку и загружает шесть частей своей стандартной библиотеки, как если бы require 'date', require 'digest'и так далее. Я не считаю эти 56 символов, потому что ограничение 3 исключает «импорт / включение стандартной библиотеки».

Остальная часть программы вызывает printдлинный список аргументов, чтобы преобразовать их в строки и вывести их по порядку. Аргументы таковы:

1. 1from 2/2: Division Fixnum # /
   . from ?.: буквенная односимвольная строка
2. 6из 9-3: вычитание Fixnum # -
3. 1от 3&5: поразрядно и Fixnum # &
   • По толкованию 5 я могу использовать 3снова.
4. 8от 2*4: умножение Fixnum # *
5. 0от 2^2: побитовый эксклюзив или Fixnum # ^
6. 3от 7%4: модуль Fixnum #%
7. 3от 55>>4: сдвиг вправо Fixnum # >>
8. 9от 5+4: дополнение Fixnum # +
9. 8от 2<<2: сдвиг влево Fixnum # <<
10. 8от -~7: отрицание дополнения Fixnum # - @ Fixnum # ~
    • Вычитание Fixnum # - и отрицание Fixnum # - @ - это разные методы.
11. 7от 5|2: побитовое или Fixnum # |
12. 4от 2**2: возведение в степень Fixnum # **
13. 9от (2r+2+5).to_i: рациональное сложение Rational # + Rational # to_i
    • В интерпретации 2 Fixnum # + и Rational # + - это разные методы. Они оба добавляют числа, но имеют разные реализации, начиная с разных типов для левого числа.
    • Рациональные литералы вроде 2rновы в Ruby 2.1. 2r+2вызывает Rational # + и возвращает другое рациональное; снова 2r+2+5вызывает Rational # + .
    • Рубин печатает рационально, как 2/1и плавает, как 2.0. Чтобы исправить это, я конвертирую в целое число: to_i округляет до нуля, ceil округляет вверх, этаж округляет вниз.
14. 8от (2.2+5).ceil: дополнение float Float # + Float # ceil
    • При толковании 1 я могу использовать скобки ()и .снова ставить точки .
15. 9от (55r/5-2).floor: рациональное деление и вычитание Rational # / Rational # - Rational # floor
16. 4от (2.2*2).to_i: умножение с плавающей точкой Float # * Float # to_i
17. 8от (2r*2*2).ceil: рациональное умножение Rational # * Rational # ceil
18. 4от (2.2**2).floor: рациональное возведение в степень Rational # **
19. 8от 2.to_bn<<2: сдвиг влево с большим числом OpenSSL Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: магическая константа для текущего номера строки
21. 0from $<.to_i: файловый дескриптор стандартного ввода IO # to_i
22. 4from IO::LOCK_NB: флаг для неблокирующей блокировки файла
    • Это первая из многих констант, зависящих от системы. OpenBSD имеет 4.
    • По толкованию 4 я больше не могу пользоваться IO. По интерпретации 7 я больше не могу использовать какую-либо константу со значением 4.
23. 5from Errno::EIO::Errno: номер ошибки ввода / вывода
24. 8from File::APPEND: флаг для добавления в файл
    • Это лазейка в интерпретации 4. Я не могу использовать IO, но Fileнаследую от констант IO, так File::APPENDчто это другой способ получить IO::APPEND.
25. 6from 'aaaaaa'.size: длина строки String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): часть имени кодировки String # encoding Кодировка # name String # sub
    • В интерпретации 6 я могу снова использовать строковые кавычки.
    • Начиная с Ruby 2.0, кодировкой по умолчанию является UTF-8. Я беру имя "UTF-8" и заменяю / \ D + / на "UTF-" пустой строкой. Это дает «8».
27. 3from %w[a a a].size: длина массива Array # size
28. 4from %w[a b c d].to_set.size: количество элементов в наборе Array # to_set Set # size
29. 3from %w[a a a].count: считать все элементы Array # count
    • Разница между Array # size и Array # count заключается в том, что последний принимает необязательные аргументы для выбора элементов для подсчета. Я не передаю аргументы, поэтому он считает все элементы.
30. 6от Socket::AF_NS: номер для семейства адресов NS
31. 5с Date.jd(Date::ITALY).wday: номер дня недели для пятницы 15 октября 1582 года, когда Италия перешла на григорианский календарь Date :: jd Date # wday
32. 6от *Digest::MD5.digest(?j).scan(/\d/): первая цифра ASCII в двоичном дайджесте MD5 дайджеста "j" :: MD5 :: дайджест String # scan
    • Строка # scan возвращает массив всех совпадений. *Передает элементы массива в качестве аргументов print. Этот массив ["6"].
33. 3из Set[?a,?b,?c].count: считать все элементы Set :: [] Enumerable # count
    • Согласно интерпретации 2, Array # count и Enumerable # count являются разными методами.
34. 8от SignalException.new('FPE').signo: номер SIGFPE Class # new SignalException # signo
35. 1из Float::ROUNDS: режим округления, здесь 1 для округления до ближайшего
36. 1с begin(новая строка) exit false(новая строка) rescue Object(новая строка) $!.status(новая строка) end: выход из состояния для сбоя
    • Это то же значение SystemExit.new(false).status, что и в интерпретации 3, я больше не могу называть Class # new . Вместо этого я поднимаю и спасаю SystemExit.
37. 7from Process::RLIMIT_NPROC: номер ограничения ресурса для количества процессов для одного пользователя
38. 7от :aaaaaaa.size: длина символа символ # размер
39. 2from Prime.first: первое простое число Enumerable # first
40. 0from ?/.next: следующая строка после "?" Строка # следующая
41. 3from {a:p,b:p,c:p}.size: длина хэша Hash # size String # p
42. 0от STDIN.lineno: текущий номер строки для стандартного ввода IO # белья
    • По толкованию 8 я не могу повторно использовать $<. Я использую STDIN. Разница в том, что $<это глобальная переменная и STDINявляется константой. Программа может установить $<другой вход, но STDINвсегда имеет исходное значение $<.
43. 3from ?a.crypt('at')[/\d/]: первая цифра ASCII в зашифрованном пароле String # crypt String # []
    • Система с другой функцией crypt () даст другой результат.
44. 0from {a: :a}.find_index([:a,:a]): индекс первого ключа: a, значение: a в хэше Enumerable # find_index
    • Я использую хэш, а не массив, потому что Array # find_index является псевдонимом для Array # index , который я планирую использовать в ближайшее время.
45. 9from /b/=~'aaaaaaaaab': индекс, где строка соответствует / b / Regexp # = ~
46. 1from [?a,?b].index(?b): индекс первого "b" в массиве Array # index
47. 7from :aaaaaaab=~/b/: индекс, где символ соответствует / b / Symbol # = ~
48. 9from ?\t.ord: ASCII значение табуляции "\ t" String # ord
49. 8from 'aaaaaaaab'=~/b/: индекс, где строка соответствует / b / String # = ~
    • Согласно интерпретации 2, Regexp # = ~ и String # = ~ являются разными методами.
50. 0from open(?/).pos: позиция в файле после открытия корневого каталога "/" в виде файла Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): индекс первого "b" в строке String # index
52. 7from ?\a.bytes{|b|break b}: ASCII значение оповещения "\ a" Строка # байт
    • Это работает путем итерации байтов в "\ a", но прерывая цикл, возвращая первый байт.
53. 6from 'aaaaaaa'.rindex(?a): индекс последнего "a" в строке String # rindex
54. 2from %w[a a].map.size: размер перечислителя, который отображается из массива Array # map Enumerator # size

Java, 21 цифра, 276 символов

class C{public static void main(String[]a){System.out.print((3&5)+"."+(2|4)+Byte.BYTES+2*4+"".length()+(7-4)+~-4+(7+2)+(2<<2)+(int)Math.sqrt('@')+(2^5)+(int)Math.pow(2,2)+32%23+Byte.SIZE+('$'>>2)+Float.BYTES+Long.BYTES+Integer.BYTES+Double.BYTES+Short.BYTES+Math.round(.2));}}

class C {
  public static void main(String[] a) {
    System.out.print(
      (3&5)+       // 1
      "."+         // .
      (2|4)+       // 6
      Byte.BYTES+  // 1
      2*4+         // 8
      "".length()+ // 0
      (7-4)+       // 3
      ~-4+         // 3
      (7+2)+       // 9
      (2<<2)+      // 8
      (int)Math.sqrt('@')+  // 8
      (2^5)+       // 7
      (int)Math.pow(2,2)+   // 4
      32%32+       // 9
      Byte.SIZE    // 8

      // rest of explanation to come later today
    );
  }
}

Рубин, 74 знака, 10 цифр

Это только начало; Я должен идти, поэтому я улучшу это позже.

$><<[3-2,?.,3+3,?..size,2**3,$*.size,24/8,7%4,[*7..77][2],2*4,7.next].join

У меня есть 76 символов, сохраненных на потом, когда это станет сложнее!

Рубин, 17 цифр, 168 байтов

$><<[-~0,'.',9-3,3/3,2**3,$.,25%22,'   '=~/$/,2+7,2<<2,"10".oct,2|5,[2,2,2,2].size,[*$....2*5].last,(2^5).succ,'a'.to_i(25).pred,'aaaa'.count('a'),eval(55.chr.next)]*''

Ungolfed:

$><<[
  -~0,                # 1
  '.',                # .
  9-3,                # 6
  3/3,                # 1
  2**3,               # 8
  $.,                 # 0
  25%22,              # 3
  '   '=~/$/,         # 3
  2+7,                # 9
  2<<2,               # 8
  "#{'a'.hex}".oct,   # 8
  2|5,                # 7
  [2,2,2,2].size,     # 4
  [*$....2*5].last,   # 9
  (2^5).succ,         # 8
  'a'.to_i(25).pred,  # 9
  'aaaa'.count('a'),  # 4
  eval(55.chr.next)   # 8
]*''

Я еще не был вынужден делать что-то особенно умное, я могу вернуться и добавить цифры.

Гольфскрипт , 17 цифр

Простая попытка. В Golfscript может быть много не буквенно-цифровых однобуквенных встроенных модулей, но в целом он не имеет много встроенных модулей!

".",                         # 1: string length (separate from array length)
'.'    
3 3+                         # 6: addition
''[49]+                      # 1: string concatenation
-9~                          # 8: bitwise not
2!                           # 0: boolean not
7 4%                         # 3: modulus
4(                           # 3: decrement
7))                          # 9: increment
257 2/2/2/2/2/               # 8: division
4 2*                         # 8: multiplication
22 5- 5- 5-                  # 7: subtraction
2 2?                         # 4: power
[2 5] 2 base                 # 9: base conversion
[2 2 2 2 2 2 2 2],           # 8: array length (separate from str length)
[2 2 2 2 2 2 2 2 2 5]5?      # 9: array.find()
2 2+                         # 4: addition
"2 2*2*"~                    # 8: eval

Баш, 5 цифр в 65 символов

Я скоро обновлю это! На данный момент он просто печатает 1.6180и не содержит никаких цифр.

false
tr -d ' '<<<$?.`wc -c<<<abcde``nl<<<' '``kill -l FPE`$(())

объяснение

Следующие методы используются для генерации цифр:

1: выход из состояния false

6: длина строки

1: nlзлоупотребление

8: killномера сигналов

0: числовое значение пустого выражения

Mathematica 9 8 цифр, в 86 83 78 символов.

10`8FromDigits@#/10^Length@#&@{a/a,3!,-I I,2π/(45°),#&''[],Prime@2,Sqrt@9,4+5}

Выход:

1.6180339

Юлия - 23 цифры из 345 символов (15 точно за цифру)

print(div(2,2),'.','/'+7,length(" "),2^3,size([])[end],isqrt(9),int(cbrt(27)),54-45,'h'$'P',[2:22][7],endof("2222222"),count(isodd,[5,5,5,5]),search("Hello man",'n'),nextpow2(5),rsearch("Love boat",'t'),sizeof('й'),("I"summary(b"H"))[22],iceil(float(pi)),iround(cosh(e)),ifloor(exp(catalan)),cmp(5,5),itrunc(5sin(one(Int))),uint(erfcx(-ones())))

Выход: 1.6180339887498948482045

Я интерпретировал символы и строки как пригодные для использования, пока я не использовал повторно определенный символ или строку (символы в строке можно использовать повторно, если строка не использовалась); однако я не позволял себе напрямую использовать значение int символа. Есть один не-ASCII символ (й).

Более читабельным способом (не реальный код):

1> div(2,2)
.> '.'
6> '/'+7
1> length(" ")
8> 2^3
0> size([])[end]
3> isqrt(9)
3> int(cbrt(27))
9> 54-45
8> 'h'$'P'
8> [2:22][7]
7> endof("2222222")
4> count(isodd,[5,5,5,5])
9> search("Hello man",'n')
8> nextpow2(5)
9> rsearch("Love boat",'t')
4> sizeof('й')
8> ("I"summary(b"H"))[22]
4> iceil(float(pi))
8> iround(cosh(e))
2> ifloor(exp(catalan))
0> cmp(5,5)
4> itrunc(5sin(one(Int)))
5> uint(erfcx(-ones()))

C ++ 12,4 символа на строку, было 14 символов на строку для каждой цифры

Исправлена ​​моя ошибка повторного использования операторов.

#include <iostream>
#include <math.h>
#define S std::string
#define C(x) std::cout<<x
int main()
{
C(cos(0));
C(char(46));
C('j'%'d');
C('\0'+3-2);
C(sqrt('@'));
C(log(1));
C('c'/'!');
S s("xyz");
C(s.size());
return 0;
}

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

#include <iostream>
#define C(x) std::cout<<x
int main()
{
C('b'-'a');//1
C(char(46));//.
C('g'-'a');//6
C('b'-'a');//1
C('i'-'a');//8
C('a'-'a');//0
C('d'-'a');//3
C('d'-'a');//3
C('j'-'a');//9
//etc
return 0;
}