Распечатать Золотое сечение


26

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

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

Выведите как можно больше цифр Золотого сечения φ. Золотое сечение определяется как число, которое удовлетворяет φ = (φ + 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 цифр выше, вот еще несколько .


Комментарии очищены; пожалуйста, сообщите мне о любой возможной потерянной информации.
Дверная ручка

«Использование запутанной версии ...» Это просто использование квадратной формулы на x = (x+1)/x(или x^2 = x+1) (или x^2-x+1).
Коул Джонсон

.... Могу ли я ссылаться на оператор, определенный реализацией, более одного раза?
Stackstuck

Кроме того, я могу повторно использовать назначение?
Stackstuck

Ответы:


18

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";

Хм, я должен признать, что это, вероятно, действительно. Единственное, к чему это может относиться - это «несколько имен, относящихся к одной и той же константе», но я не собирался использовать эту формулировку для охвата этого случая. Я пояснил в ответе Керни, что это будет недействительно, только если оно действительно указывает на одно и то же целое число, но я думаю, что это маловероятно. Тот факт, что многое зависит от вашей системы, является позором, но не частью правил. Так что, если кто-то еще не может обнаружить проблему здесь, я должен признать, что ваш ответ совершенно верен. ;)
Мартин Эндер

<?for(;;);использует 9 МБ памяти. Теперь я знаю, почему ... Мне нравится само наложенное ограничение @ kernigh # 7, которое закрывает такую ​​лазейку. Кроме того, что бы это ни стоило, выходные данные в моей системе таковы
primo

Несмотря на то, что запуск генератора дает правильное представление, +1 для этого;) Версия, которая запускается на сервере кодовой
primo

2
Поздравляю, вы преодолели вызов. ;) ... Не совсем ... этот ответ несколько обходит реальный вызов, но, насколько я понимаю, он вполне укладывается в правила, поэтому мне придется признать поражение и принять его. :)
Мартин Эндер

11

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

8

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

Этот ответ был опубликован до того, как лазейка была закрыта. Поскольку это довольно умный трюк и в этом случае он не наносит вреда задаче (и поскольку именно этот ответ фактически указал мне на лазейку), этот ответ может остаться таким, как есть - поэтому, пожалуйста, не отрицайте его на основании этого, Скорее, отдай это за ум. :)
Мартин Эндер

6

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

Впечатляет! В любом случае, большинство ваших интерпретаций соответствуют правилам. 1. Я никогда не хотел ограничивать операторы вызова, разыменования и доступа, поэтому я сказал «математические, логические, битовые и строковые» операторы. 2. Охватывается правилом 6. 3. Повторное использование new было бы хорошо в других языках, потому что обычно это оператор - его просто нельзя повторно использовать в том же классе, потому что он вызывает конструктор (встроенную функцию). Как это в Ruby? newДействительно ли всегда вызывается одна и та же имплементация или она переопределена в подклассах? [ctd.]
Мартин Эндер

4. Хорошо, если бы вы сделали исключение для Руби, но спасибо за ваше спортивное мастерство. ;) 5. и 6. Нет, это не так, поэтому некоторые правила изложены так, как они есть. 7. Это хороший тонкий момент, о котором я не думал. Технически, если они не ссылаются на одну и ту же восьмерку, было бы хорошо использовать их обоих. 8. Хороший вопрос, я не думал о встроенных переменных. Я проверю, не нарушает ли это какие-либо другие представления, и исправлю правило 6. Спасибо за честную игру! :)
Мартин Эндер

В этом ответе я не нашел нарушения правил, поэтому принял его. Тем не менее, я хотел бы вознаградить ваш ответ, так как он, безусловно, самый длинный, который фактически соответствует тому, как задача была задумана. Поэтому я предложу награду за этот вызов. Награда будет действовать в течение семи дней, и, если придет ответ, который превзойдет ваш «честно», я соответственно присуду награду. (Конечно, вы можете попробовать победить любого соперника;).) Надеюсь, вы в порядке с этим!
Мартин Эндер

5

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

Ха, мне нравится 7-4& -4+7, это умно! :)
Мартин Эндер

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

1
@rangu 7не постоянная, а буквальная
Мартин Эндер

Так почему ты остановился там?
Валентин Грегуар

4

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

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

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

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


Это хорошее начало! Наконец-то ответ в духе вопроса. :)
Мартин Эндер

3

Рубин, 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
]*''

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


1
«Еще не был вынужден делать что-то особенно умное». Да, я полагал, что Ruby, Perl и обычным подозреваемым не будет очень сложно с 15 символами на цифру, но я хотел оставить место для таких вещей, как C-производные и Mathematica с большими стандартными библиотеками, но более запутанными именами.
Мартин Эндер

«Если они действительно только псевдонимы, нет [вы не можете использовать их]». succи nextпсевдонимы.
Дверная ручка

1
Первый вызывается для Fixnum, второй для String, поэтому я не думаю, что они считаются одним и тем же методом.
гистократ

Ах, хорошая мысль. Тем не менее, вопрос также говорит: «Вы не должны ссылаться на любую ... константу, которую вы использовали в коде, который сгенерировал более раннюю цифру», и вы используете $.дважды. Хотя, должен любить $....: D
дверная ручка

2

Гольфскрипт , 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

2
Я думаю, что вы могли бы продолжить 5,)\; # range, right uncons, flip, and pop.
Питер Тейлор

1

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

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

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

объяснение

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

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

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

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

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

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


1

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

Ах, я знал, что где-то допустил ошибку. Кажется, префиксная запись не совсем работает в этом случае. Использование Unicode Pi и Degree, кажется, все еще работает.
Tally

Да, # & '' [] сгенерирует ошибку из-за отсутствия ввода, в то время как в этой форме он игнорирует отсутствие ввода. Тем не менее, не извините меня от использования его там, где он работает.
Tally

1
Спасибо. Я лично любил # & '' [] (В основном вторая производная от f [x] = x
Tally

(Подчищены комментарии.) То есть довольно хорошо, но вы могли бы , вероятно , сохранить характер, путем замены #с разрешенной цифрой и отбрасыванием одного из черточек.
Мартин Эндер

Если подумать, я смогу сохранить эту цифру для будущего использования.
Tally

1

Юлия - 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()))

0

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

Литералы хороши (потому что они не эквивалентны однозначным числам), но вы продолжаете многократно использовать -оператор. Также мне нравится, как вы посчитали комментарий для длины строки. : D
Мартин Эндер

Да, это выглядит намного лучше, но вы используете 1для производства 0(что запрещено, потому что 1появился ранее в золотом сечении). Также вам нужно сосчитать #define S(не другой), так как это не включение, а просто определение сокращенного псевдонима.
Мартин Эндер
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.