真有趣！但是，只有三位数，乐趣还为时过早。这个挑战是相似的，但我们会继续保持乐趣。

挑战

尽可能多地打印黄金比例 φ的数字。黄金比率定义为满足φ=（φ+ 1）/φ的数字，并且前100位数字由下式给出：

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

这个挑战不是关于计算φ！这是关于尽可能多地打印数字，而无需使用任何方法进行两次打印。因此，请找到尽可能多的创造性方法来获取数字！

限制条件

就其本身而言，打印φ的数字有点太简单了，因此规则如下：

1. 您必须按从左到右的顺序构造数字，方法是逐段打印，也可以从左至右构造一个字符串，最后打印它-您甚至可以生成一个数字字符数组，然后将其连接起来并打印它，只要您按顺序进行即可。在以下规则中，“打印”和“输出”可能是指那些过程中的任何一个（例如，如果您正在构建字符串，并且该字符串包含已被1.6视为1.6已打印的字符串）。
2. 对于您的代码，每位预算为15个字符。该期间不计入该预算，但也必须打印出来。请注意，该限制仅针对总代码大小：您可以对任何数字使用超过15个字符，只要您平均不使用更多字符即可。实际上，您可能会在字符中累积一个“债务”，并在以后“偿还”。例如，要打印，1.618您有60个字符。
3. 标准库包含/导入不计入代码大小。但是您不能免费给这些包含速记别名的东西！
4. 您不得使用当前正在生成的数字，也不得使用任何已打印的数字。例如1，在源代码中可能没有出现，因为它是第一位。输出8in 的代码1.618可以使用任何或所有数字[0234579]，但不使用任何数字[168]。为此，将所有等同于单个数字的文字视为该数字。因此，如果您的语言可以表示9，'\t'那么您将不能在任何地方使用该语言，9而不能使用它。
5. 您不能一次产生多个数字。应该有可能将您的代码清楚地分成几块，一次生成一个数字。

6. 您不得引用在生成较早数字的代码中使用的任何内置函数，数学/布尔值/按位/字符串运算符，变量或常量。整数到字符串的转换，字符串连接和打印功能可能是例外，您可能需要为每个数字输入。请注意，您使用哪个名称来指代任何内置都没关系：仅仅因为您PI为两者都内置了别名p，q并不意味着您可以p一次使用q一次。同样，如果名称引用了两个不同的内置名称（例如string 和array），则允许您使用两次名称。lengthlength

   _{如果您的编程语言没有函数，请根据其最佳判断（例如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. Class＃new是一种方法。在Ruby， ，，Mutex.new 等等指的是相同的方法，。我用来产生一位数字。由于限制6，我可能永远不会再使用。Random.newTime.newClass#newSignalException.newClass#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解析此行并加载其标准库的六个部分，就像by一样require 'date'，require 'digest'依此类推。我不算这56个字符，因为限制3排除了“标准库导入/包含”。

程序的其余部分print使用一长串参数进行调用，以将其转换为字符串并按顺序打印。这些参数是：

1. 1from 2/2：除法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＃+是不同的方法。它们都加数字，但是它们的实现方式不同，从左侧数字的不同类型开始。
    • 像2rRuby 这样的有理文字是Ruby 2.1中的新增内容。2r+2调用Rational＃+并返回另一个有理数；再次2r+2+5调用Rational＃+。
    • Ruby像一样打印有理有理，像一样2/1进行浮动2.0。为了解决这个问题，我将其转换为整数：to_i朝零舍入，ceil向上舍入，floor向下舍入。
14. 8from (2.2+5).ceil：浮点数Float＃+ Float＃ceil
    • 通过解释1，我可以使用括号()并.再次点。
15. 9来自(55r/5-2).floor：有理除法和减法Rational＃/ Rational＃-Rational＃floor
16. 4from (2.2*2).to_i：浮点乘法Float＃* Float＃to_i
17. 8来自(2r*2*2).ceil：有理乘法Rational＃* Rational＃ceil
18. 4来自(2.2**2).floor：有理指数幂有理＃**
19. 8从2.to_bn<<2：左移，带有OpenSSL大数字Fixnum＃to_bn OpenSSL :: BN＃<<
20. 2来自__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. 8来自?a.encoding.name.sub(/\D+/,'')：编码名称的一部分String＃encoding 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：set 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：1582年10月15日（星期五）的工作日编号，当时意大利转换为公历日期：: jd日期#wday
32. 6来自*Digest::MD5.digest(?j).scan(/\d/)：“ j”的二进制MD5摘要中的第一个ASCII数字Digest :: MD5 :: digest String＃scan
    • String＃scan返回所有匹配项的数组。所述*传递数组元素作为参数print。此数组为[“ 6”]。
33. 3from Set[?a,?b,?c].count：计算所有元素Set :: [] Enumerable＃count
    • 通过解释2，Array＃count和Enumerable＃count是不同的方法。
34. 8从SignalException.new('FPE').signo：SIGFPE 类的数目#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. 7from :aaaaaaa.size：符号长度Symbol＃size
39. 2来自Prime.first：第一个素数Enumerable＃first
40. 0来自?/.next：“？”之后的下一个字符串 字符串＃下一个
41. 3from {a:p,b:p,c:p}.size：哈希值的长度Hash＃size String＃p
42. 0from STDIN.lineno：标准输入IO＃lineno的当前行号
    • 通过解释8，我可能不会重用$<。我用STDIN。区别在于这$<是一个全局变量，并且STDIN是一个常数。程序可以设置$<为其他输入，但STDIN始终为的原始值$<。
43. 3来自?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)：数组Array＃index中第一个“ b”的索引
47. 7from :aaaaaaab=~/b/：符号匹配的索引/ b / Symbol＃=〜
48. 9from ?\t.ord：制表符“ \ t”的ASCII值String＃ord
49. 8from 'aaaaaaaab'=~/b/：字符串匹配的索引/ b / 字符串＃=〜
    • 通过解释2，Regexp＃=〜和String＃=〜是不同的方法。
50. 0从open(?/).pos：打开根目录“ /”作为文件后在文件中的位置内核#open IO＃pos
51. 5from 'aaaaab'.index(?b)：字符串String＃index中第一个“ b”的索引
52. 7from ?\a.bytes{|b|break b}：警报“ \ a”的ASCII值字符串#bytes
    • 这通过迭代“ \ a”中的字节来工作，但是通过返回第一个字节来中断循环。
53. 6来自'aaaaaaa'.rindex(?a)：字符串String＃rindex中最后一个“ a”的索引
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
    );
  }
}

Ruby，74个字符，10位数字

这只是一个开始；我必须走，以后再改善。

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

我保存了76个字符供以后使用，否则将变得更加困难！

Ruby，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)]*''

取消高尔夫：

$><<[
  -~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
]*''

还没有被迫做任何特别聪明的事情，我可能会回来并添加数字。

Golfscript，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

Bash，65个字符中的5位数字

我将尽快更新！目前，它仅打印1.6180，并且不包含任何数字。

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

说明

以下方法用于生成数字：

1：退出状态 false

6：字符串长度

1：nl滥用

8：kill信号编号

0：空表达式的数值

数学9 8个位数，在86 83 78个字符。

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

输出：

1.6180339

朱莉娅-345个字符中的23位数字（每位精确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;
}