如果您愿意，请考虑参加：

• 该官方Dyalog APL 2016年游戏

• 每月Dyalog APL 2017 Code Golf挑战赛

用相同的语言制作12个摘要/表达式，分别得出数字0到10和42，但不写任何文字数字，字符串或字符数据。

内置数据（如PI()和ALPHABET()）很好，例如CJam的U，X，Y，Z和A常数，以及Processing的BLEND，CHORD，CENTER，BREAK和LINES。

每个摘录都必须能够独立存在，即它们可能不是相互依赖的。但是，在单个代码段内，您可以分配一个变量并自由使用它，只要您直接通过名称而不是通过包含其名称的字符串来引用它即可。

所有摘要在提交时（在SE的报告中）必须在提交者的计算机上有效，但可能不依赖于异常的本地条件，例如目录中文件的数量，确切的日期或时间或用户的特定输入。

有效片段的示例

3：INT(LOG10(YEAR(TODAY()))) 因为在可预见的将来仍然如此
4：CUBICROOT(LEN(CHARACTERSET())) 因为256个字母字符集非常常见
8：SQRT(SYSTEMTYPE()) 因为64位系统非常常见

无效摘要的示例

5：LEN(USERNAME()) 因为大多数人不使用“ Admin”作为登录名：-)
9：LOG10(SYSTEMMEMORY()) 因为它仅在具有1 GB内存的系统上运行
42：CODE("*") 因为它包含字符串/字符文字

每个代码段的结果都必须产生一个实际数字（值，整数，浮点数等），该数字可用于使用与代码段相同的语言进行进一步的计算，即不是表示该数字的文本字符串。

仅允许使用基于字符的语言。

分数是所有12个摘要的总字节数。不含摘要的换行符不计在内。

请注意，以上规则可能会阻止某些语言参与，即使它们已经完成了图灵设计。

常问问题

问程序可以接受任何输入吗？
答：可以，但您可能不仅仅要求输入并输入相关号码。

问：是否允许使用物理数字（非数据数字）数字？
A是，例如LOG10()。

问：Ruby中的符号是否算作文字？
一个是。

问分数是否在每个摘录之间包含换行符？
A号

问：TI-BASIC“基于字符”足够有效吗？
一个是。

问：假和真算作数字文字吗？
答：不可以。

问：如果那是唯一的方法，并且数字不影响函数的输出，我们可以使用数字文字来调用函数吗？
一个是，如果这是你的语言编写代码的正常方式。

问：我的语言假定每个程序/表达式的开头都有[something]。我是否必须包含它，或者如果放在程序/表达式的中间，我的代码片段是否应该起作用？
答：他们应该只在程序/表达式的中间工作。

问：正则表达式文字呢？
一个故宫，除了语言，只有做的正则表达式。

问：可以打印所有指定数字的一段代码是否可以接受？
一个没有，他们必须是独立且相互独立的。

问：我可以假定样板int main() {}...或类似样板吗？
一个是。

问：允许哪些输出数据类型？
阿任何数值数据类型，如整数，浮点等等。

问我需要打印每个代码段的结果吗？
一个没有，使供后续使用，结果就足够了。

问是否允许使用预设变量？
答：是的，并且每个代码段都会重置（如果更改）。

问： π和e是否视为数字文字？
答：不，您可以使用它们。

问：我可以在不同的单元格中返回4和2以获得42吗？
答：不能，它们必须作为一个数字连接。

Q字节或字符？
一个字节，但是你可以选择任何所需的代码页。

Q是否可以使用常量函数和预设变量（例如J's 9:，9Actuals's和Pretzel's）9？
A是，如果词汇量有限（J的词汇量为19，Actual and Pretzel的词汇量为10）。

六边形，13字节

1个
2
3
4
5
6
7
8
9
10
42

在线尝试！

在Hexagony，0通过9是功能即乘以10的当前存储器，然后添加由函数名表示的数目。因此，第一个代码段是空的，因为记忆开始于0。

例如，如果当前内存为65，则执行功能3将成为当前内存653。

（对拒绝投票的人：拒绝所有您想要的票；我准备好了。）

功能，1222字节

除了数字文字外，我还可以通过两种方法在Funciton中产生值（任何值）：stdin和lambda表达式。Stdin是一个单独的框，而完整的lambda表达式则需要更多的语法，因此我将使用stdin。但是，尽管stdin可以是任何东西，但无论提供什么输入，以下所有工作都可以进行。

在发布质询之前，此处使用的所有库函数都已存在。

0（UTF-16中为40个字节）

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

这将原始语法用于小于。值永远不会小于其自身，因此其结果为0。

1（UTF-16中为52个字节）

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

⌑返回包含一个元素的惰性序列并ɕ计算元素的数量。（惰性序列足够惰性，以至于该片段实际上根本没有评估标准输入！）

2（UTF-16中为70个字节）

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

=2¹。ʂ生成一个序列的所有子序列，从而将n个元素的序列转换为2 个元素。

3（UTF-16中为88字节）

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 +1。♯将值加1。

4（UTF-16中为88字节）

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

=2²。

5（UTF-16中为106字节）

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1。

6（UTF-16中为106字节）

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3阶乘。

7（UTF-16中为110字节）

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A（2，2）（阿克曼函数）。

8（UTF-16中为118字节）

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2（向左移动）。

9（UTF-16中为128字节）

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3×3。

10（UTF-16中为146字节）

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5。

42（UTF-16中为170字节）

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6×（6 +1）。

JavaScript中，144个 141 140 138 132 125 123字节

从帮助@ edc65，@Sjoerd工作Postmus，@DocMax，@usandfriends，@Charlie永利和@ Mwr247！

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

鼠标2002，27个 26 17 14字节

第一片段推0-10，和ZR+推25然后17和25 17 + 42 =是1。

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam，27个 24字节

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

感谢@MartinBüttner-1个字节！

在线尝试！

Brainfuck，70个字节

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

每行必须单独运行。

前10个是不言自明的：我们通过每个加号来增加单元的值。

42要复杂得多。它依赖于最笨蛋的解释器使用8位单元的事实，这意味着对它的所有操作都以256为模进行。--将单元＃0设置为254。然后我们进入一个循环，直到单元＃0为0为止。每次迭代将1加到1号单元格并将6加到0号单元格。该循环运行43次，因此单元格＃1为43。最后，我们从单元格＃1减去1使其变为42。

我从http://esolangs.org/wiki/Brainfuck_constants找到了有史以来效率最高的42

黑暗，339303字节

这就是黑暗真正闪耀的地方。得到它？：〜）！

不打印（\s在第一行中用空格替换，因为否则将不会显示）：

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

带有印刷：

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

在这种情况下，每行必须单独运行，因为程序在灯光（空格）处终止。但是，可以在同一程序中的一行或几行上编写此代码。

常规暗度（█）将寄存器增加1，而■指令（某种微暗度）将输出寄存器的内容。

Perl 5，86 75 71 66字节

所有^Fs都是文字控制字符（ASCII中为0x06），因此是一个字节。

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

感谢msh210节省了11个字节，Dom Hastings节省了9个字节！

MATL，30个字节

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H，I和K是2、3和4的预定义常数（如pi）。O并且l是返回零（O）或一个（l）矩阵的函数，默认大小为1x1。:生成一个向量并将其s求和，因此K:s使向量从1到4求和，得出10。Yq是第n个素数函数，KYq第4 个素数也就是7。

Prolog，113 99字节

片段：

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

将数学常数e和pi以不同方式组合为int。

编辑：通过使用浮点数0-2保存14个字节。

PHP，157个 145 91字节

第一次在Code Golf上发帖时，我想我会试一试。最终我会变得更好的：P如果您发现任何可以保存字符的明显（对您而言）的地方，请告诉我。

编辑：意识到我不需要分号，因为这些只是代码片段。

EDIT2：感谢黑洞的许多建议！

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

Python 2中，191个 159 158 157 156 149 146字节

我有史以来第一次提交，希望一切都对！根据我在此上花费的时间，我想其中肯定有一个更好的选择。

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

非常感谢FryAmTheEggman！

C＃，无使用，234个字节

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

这比我最初想的要无聊得多。我有各种各样的想法，例如new[]{true}.Lengthand true.GetHashCode()和typeof(int).Name.Lengthand uint.MinValue等，但是都new int()击败了他们。

PowerShell，147字节

这些用于+将事物隐式转换为整数。后面的数字使用PowerShell的.Net Framework底层版本中的枚举，碰巧具有正确的值。

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

• -~-~-~在JavaScript，C＃和PHP答案中使用的将- -bnot - -bnot - -bnot在PowerShell中。

• x^yPerl答案或x**yPython或JavaScript ES7中使用的幂运算将是[Math]::Pow($x,$y)

• 常数e和Pi是重字符，[Math]::E并且[Math]::PI

DC，35字节

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

要测试代码片段，请添加，f以打印堆栈并将该字符串传递给dc：

$ echo 'EdE++f' | dc
42

TI-BASIC，41个字节

0〜10：

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42：

int(π²/ecosh(π

在TI-BASIC中，所有未初始化的单字母变量都从0开始，Xmax（（图形屏幕的右窗口边界）从10开始。

数学常数π为1个字节，但e为2个字节。

Python 2中，306个 275 274字节

我用这样的事实：对于任何x（整数而不是0），表达式x/x等于1并进行一些按位运算。

我对代码片段进行了调整，使其仍然满足要求（感谢@nimi节省了24个字节），但是您必须手动对其进行测试。这是代码和单个字节数：

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

数学++，总共92个字节

0（1个字节）： a

1（2个字节）：!a

2（3个字节）：_$e

3（4个字节）： _$pi

4（7个字节）： _$e+_$e

5（8个字节）： _($e+$e)

6（9个字节）： _$pi+_$pi

7（8个字节）： _($e*$e)

8（9个字节）： _($e*$pi)

9（10个字节）： _($pi*$pi)

10（12个字节）： _$e*_($e+$e)

42（19个字节）： _($pi+$pi)*_($e*$e)

的Javascript（浏览器的Env），155个 136 130字节

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

感谢：
@Ismael Miguel：155-> 136-> 130字节

认真地，39 33字节

括号内是解释：

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

十六进制程序：

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

感谢quintopia提供了6个字节！

dc，42个字节

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

结果

0
1
2
3
4
5
6
7
8
9
10
42

用dc生成新数字的方法并不多。我使用O：输出基数，最初是10；K：精度，最初为0；z堆栈深度，最初为0；Z操作数的有效位数。我们将它们与常规算术运算符结合在一起。

测试程序

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

Mathematica，101个字节

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

我敢肯定，其中一些是次优的。这些圆括号确实很昂贵。

为了保持一致，前两个当然也可以是E-E和E/E，但是我认为从带有未定义变量的计算中获取0和1从中获取信息是很不错的。

Japt，34 33 30字节

@ThomasKwa节省了1个字节

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

这是每个不同字符的含义：

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Marbelous，98位元组

并非十分令人兴奋，它依赖于将?n大理石转换为0..n（含）范围内的随机值的设备，其副作用是，?0无论输入如何，大理石均可转换为0。我认为允许使用文字，因为该值不会影响结果，并且在Marbelous中没有其他方法可以一次调用函数。

0：

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1：

00
?0
+1  # increment by one

...

9：

00
?0
+9

10：

00
?0
+A  # increment by 10

42：

00
?0
+L  # increment by 21
+L

> <>，86字节

• 0： ln;
• 1： lln;
• 2： llln;
• 3： lll+n;
• 4： lll:+n;
• 5： llll+n;
• 6：llll++n;或llll:+n;
• 7： lllll+n;
• 8： lllll:+n;
• 9：lllll++n;或llllll+n;
• 10：llll+:+n;或lll:l+*n;
• 42： llll*ll+*n;

依靠堆栈大小来获取其文字。

MS Excel公式，163个 151 150 143字节

并非完全是一种编程语言，但是在这里...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()在大多数情况下使用，因为（我知道）这是在不使用数字或字符串文字的情况下引入数字值的较短方法。N将各种事物（包括布尔值）T转换为数字，并将各种事物转换为文本。TYPE对于文本参数返回2，对于布尔参数返回4。TRUNC舍弃小数部分（即，将正数向下舍入），EVEN向上舍入到下一个偶数，然后ODD舍入到下一个奇数。CODE(-PI())是转换为-π的文本的第一个字符的ASCII码，即45（对于“-”）。

编辑：从字节数（-12！）中删除了等号-正如Nᴮᶻ在评论中指出的那样，不应将它们包括在内。

编辑2：假设工作表的其余部分为空，只要我们包含减号（或在其他数字表达式中使用）来解析，就有可能使用对空单元格的引用为零（再次由Nᴮᶻ建议）。类型不明确。

DUP，68字节

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

有很多方法可以做到这一点，但是我正在滥用返回堆栈。

说明

为了完全弄清这一点，您需要了解DUP关于lambda的行为。当检测到lambda时，它实际上将当前IP推入堆栈，而不是将lambda推入堆栈。这可以解释涉及lambda的前3个片段。

接下来的代码片段使用返回堆栈。当!执行时，当前IP被推入返回堆栈，并且堆栈顶部被设置为新IP，以开始执行lambda。)将一个数字从返回堆栈弹出到数据堆栈上。

这足以解释其余的片段。如果您仍然不明白，请记住该Step按钮非常方便！

05AB1E，40 38 24字节

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• 推送counter_variable
• 推1
• 推2
• 按1 + 2
• 推2 * 2
• 推10/2
• 推（10/2）+1
• 推（10/2）+2
• 推10-2
• 推10-1
• 推10
• 按32，10，添加

D1ffe7e45e，112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

每行都是不同的代码段。

程序中的数字不算作数字文字，因为它们仅用作命令。

最后一个肯定可以打更多的球。

编辑：我让口译员工作了，所有代码片段都工作了。如果您想测试自己，请添加0f0f到代码段的末尾以使程序终止。

Pyth，35 34 33字节

-1字节@Mimarik

一些程序有很多可能性。

0，1个字节

Z

1，2字节

hZ
!Z

2，3字节

hhZ
eCG
eCd
lyd
lyb
lyN

3、3个字节

l`d

4，3字节

l`b
eCN

5、4个字节

hl`b
telG

6、3个字节

elG

7、4个字节

tttT
helG

8、3个字节

ttT

9，2个字节

tT

10，1个字节

T

42，4字节

yhyT

所有这些都涉及基本double（y），+ 1（h）和-1（t）命令或l（字符串的长度）。Z变量初始化为零。

对于5，b初始化为换行符。Backtick给出"\n"（包括引号，并且该字符串的长度为4。

在这里尝试！