挑战：

您的任务是编写尽可能多的程序/函数/代码片段，其中每个输出/打印/返回一个整数。第一个程序必须输出integer 1，第二个程序2以此类推。

您不能在程序之间重复使用任何字符。因此，如果第一个程序是：x==x，则您可能不能再使用这些字符x，而不能=在其他任何程序中使用这些字符。注意：允许在一个程序中多次使用同一字符。

得分：

获胜者将是得分最高的作品。如果出现平局，则获胜者将是使用总数最少的字节的提交。

规则：

• 所有整数只能使用一种语言
• 片段是允许的！
• 为了公平起见，所有字符必须使用您选择的语言使用单个字节编码。
• 输出必须为十进制。您可能无法以科学计数法或其他替代格式输出它。只要小数点后面显示的所有数字均为，就可以输出浮点数0。因此，4.000被接受。只要未在输出中显示，就可以接受由于FPA导致的不正确之处。
• ans =，开头和结尾的空格以及换行符等。
• 您可以忽略STDERR，只要将正确的输出返回到STDOUT
• 您可以选择将整数输出到STDERR，但前提是STDOUT为空。
• 禁止使用与符号无关的语言（例如Lenguage）
• 字母区分大小写a != A。
• 程序必须是独立的
• 空格不能重复使用
• 您必须在输出中使用ASCII数字

鼓励解释！

JavaScript（ES7），得分17，176字节

他们说无法完成，所以我做到了：D（感谢@FullDecent的大量帮助）

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

未使用的字符：

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

我认为18不可能，但我对17说了同样的话...

说明

JavaScript是一种非常弱类型的语言。如果您尝试对非数字值执行数学运算，则JS会尽最大努力首先将其转换为数字。这提供了许多有趣的解决方案。我试图避免尽可能多地使用数字，以便以后使用。

1. **是ES7中的幂运算符。强制为数字的空字符串变为0，因此这0 ** 0将1根据JavaScript 计算。
2. 有点荒谬，但是可以。/~/是正则表达式文字，并~/~/返回-1，所以这是~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2。（该想法的积分为@ GOTO0）
3. 简单地说3。
4. 现在简单4。
5. NaN是falsy，所以!NaN就是true，这相当于1。因此，表达式变为1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5。
6. 简单地说6。
7. 简单地说7。
8. 简单地说8。
9. 简单地说9。
10. 这使用了一点JSF ***魔术。+[]是0，所以[[]][+[]]返回的第一个元素[[]]（即，[]），和++增量这对1。然后+[+[]]添加数组[0]，将其强制转换为字符串并制作"10"。
11. 简单地说11。我本来用过11&11113和33/311，直到我再次意识到自己是多么愚蠢...
12. 此策略适用于任何数字：创建一个长度字符串12并使用.length。
13. 我只是把2s和>s 弄乱了一段时间才得到这个。我又很幸运：222 >> 2is 55和55 >> 2is 13。
14. 这相当棘手。基本思想是使用14十六进制（0xE）创建，但我们需要在0其他位置使用数字。因此，我们将结果``^``放在字符串的前面xE；强制为数字的空字符串为0，因此返回0 ^ 0= 0。然后，将结果与空字符串进行XOR运算，然后将两个值都转换为数字。"0xE" ^ ""是14。
15. 现在，这非常简单：0XF是值为的十六进制文字15。
16. 最棘手的吗？首先，我们将变量设置C为CSS == CSS（即true）。然后我们把结果和进行<< C四次，基本上乘以1通过2 ** 4。
17. JavaScript在2 ⁵³开始失去整数精度，该精度允许555...555%55返回不是0or的数字5。我在这里玩耍时碰巧很幸运。

适用于许多数字的策略：

• -!NaN可以处理任何数字（当前为5），尽管它很快变大。
• ~/~/将工作在任意数量（目前2），虽然它得到非常大的非常快。
• +[]可以在任何数字上（当前10）运行，尽管到目前为止在10或上最简单11。
• .length 适用于任何数量。
• `${-``}xE`-`` 如果操作正确，几乎可以处理任何数字。
• C<<C可以用任何2的幂（当前16）或任何int（如果包括）来工作|。

果冻，47个整数，519字节

e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

每行都是一个单独的完整程序。

在线尝试！（包括测试套件和交集检查器）

这个怎么运作

每个不带命令行参数的完整程序都将以恶意方式（即，无需输入）执行其主链接（在最后一行定义）。如果链中的第一个链接是nilad，则将其消耗，调用，并将主链接的参数和返回值都设置为结果；如果链中的第一个链接是monad或dyad，则不使用它，而是使用隐式参数和返回值0。在这两种情况下，链的其余部分均单价执行。

果冻在几种情况下会破坏其输出。值得注意的是，单例数组的打印没有括号，因此42和[42]在打印后无法区分。我们将在多种场合使用它。

1 – 10

e

的存在，如果返回值原子试验0属于参数0。确实如此，因此e返回1。

BI$⁼#

BI$是一个快速链接，特别是通过$对二进制原子B和增量原子进行快速分组而形成的单子链I。结合起来，它们将整数转换为以2为底的数字数组，然后计算所得数字的正向差。如果数组只有一个元素，则没有前向差异，并I返回一个空数组（falsy）；如果至少有两位数字，则I返回一个非空数组（真）。

快速#消耗之前的快速链接，并将其应用于0，1，2，...，直到有足够找到匹配的回报相匹配的阵列。所需的金额由计算⁼，将返回值/参数0与自身进行比较，得出1。因此，整个程序返回[2]，即以2为底的两位非整数。

⁾⁾⁾Ụ^/

⁾⁾⁾是字符串文字，特别是字符串⁾⁾。该等级可原子Ụ可以通过相应的值排序其指数; 由于两个字符相等，因此得出[1，2]。结果数组将按位XOR进行缩减^/，因此整个程序返回3。

ı***ıḞḞ

ı初始化参数，并将值返回到虚数单位i。*是幂二乘，其正确参数默认为主链接的参数。因此，***ı单位计算（第（i ^我）^我）^我 ≈4.81 + 0I中，Ḟ原子（地板对真实参数，实部为复杂的）计算实部（4.81），则Ḟ地板，得到4。

5
6
7

这三个程序由单个文字组成，并且完全满足您的期望。

.::::

文字.是0.5的简写，并初始化参数和返回值。该整数除法成对的（:）右参数默认到主链接参数，所以::::计算0.5 / 0.5 / 0.5 / 0.5 / 0.5，得到8。

9

另一个字面意思。

EȮ<

的所有等于原子E返回1，如果在它的参数的所有元素是相等的，和0如果不是。整数参数z被提升为[z]，因此隐式参数0E将返回1。

现在，输出原子将1Ȯ打印到STDOUT。然后，我们使用小于原子将1与隐式参数0进行比较。结果是（1 <0）= 0，并且在程序完成时隐式打印。<

11 – 20

⁻GṘ

该网格原子G试图从它的参数使视觉上令人愉悦的表。对于纯整数参数（此处为0），它只是将其包装在数组中。该扁平不等于原子⁻的隐含参数进行比较0，其结果，以（右侧[0] ），得到1因为它的参数是不相等的。的表示原子Ṙ打印1至STDOUT并返回其结果。在程序结束时，最终的返回值是隐式打印的，因此最终输出为11。

=`p`VV×`DQV

该自快`用相同的左边和右边的参数调用它变成一个对子成单子。首先，=`将隐式参数0与自身进行比较，得出1。

的笛卡尔乘积原子p期望列表作为其参数，所以它促进整数1到范围[1，...，1] = [1] 。p`取[1]及其本身的笛卡尔积，得出[[1，1]]。

该EVAL原子V接通所有平面阵列（仅包含数字和字符）转换成字符串，然后计算所得到的字符串作为译注果冻程序。首先将[[1，1]]转换为[“ 11”]，然后V评估字符串，产生[11]。再一次，V将此数组转换为“ 11”，然后求和以得出11。

现在，×`将11与其自身相乘，得出121。所述的十进制原子变为121到[1，2,1] ，所述独特原子Q丢弃第二1，并V再次接通的数字的列表转换成从串联它们，返回所得到的整数12。

~A~A~A~A~A~A~A~A~A~A~A~A~A

~是按位非原子。使用二进制补码算法，它将参数z映射到〜z =-（z + 1）。A是绝对值原子，因此它映射-（z + 1）= z + 1。初始返回值为0时，~A返回13的十三份副本。

⁷ṾṾṾw

该常量⁷保存换行符'\ n'并初始化参数和返回值。

所述uneval原子Ṿ尝试创建它的参数的字符串表示ž使得由这个码的果冻程序将返回ž。

第一个调用忠实地返回字符串“” \ n”，这是一个字符文字。下一个调用返回“””，“ \ n” –一对字符文字。第三次也是最后一次调用返回“”，“”，“，”，“ \ n” –字符字面量的五联体。

最后，窗口索引原子w将其正确的参数'\ n'提升为字符串“ \ n”并找到以“ \ n”开头的子字符串的第一个索引。返回14。

⁴ḟ€⁴Ṁ

⁴是常数16。的快速链接filterfalse各（ḟ€）促进其左边的参数16到范围[1，...，16] ，然后用其元素迭代。

对于每个元素z，都将ḟ⁴被执行，首先将z提升为[z]，然后删除所有（如果有的话）出现的16。这将产生数组[[1]，[2]，…，[14]，[15]，[]]，其中最后一个数组为空，因为它包含16。

最后，最大原子Ṁ选择[15]。

mmmmċ

用参数x（数组）和y（整数）调用的模块化原子通常采用每个| y |。^个的元素X，从第一个开始，如果Y> 0，和最后如果ý<0 。但是，当y = 0时，它将返回x及其反向。m

左整数参数0首先被提升为[0]。m连接的第一个副本与自身连接[0]，产生[0，0]。其余的副本将此结果转换为[0，0，0，0]，然后转换为[0，0，0，0，0，0，0，0]，最后是[0，0，0，0，0，0 ，0，0，0，0，0，0，0，0，0，0]。

最后，count原子ċ计算隐式参数0在结果数组中出现的次数，返回16。

ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ

ṭ是粘性原子，并将其左参数附加到其右参数。由于ṭ和以下ḍ都是二进位的，因此所有ṭ将隐式参数0作为正确参数传递给的调用ṭ。第一个调用返回[0，0]，第二个返回[0，[0，0]，第八个和最后一个[0，[0，[0，[0，[0，[0，[0，[0，[0， 0]]]]]]]]]。

ḍ是可整除原子；为参数X和ÿ，它返回1是X是整除ÿ，0如果不是。Ḅ是整数的no-op，因此对于构造的数组中的每个整数，将0的可除性ḍḄ测试为0。0本身可以被整除，因此我们得到[1，[1，[1，[1，[1，[1，[1，[1，1]]]]]]]]]]]]。

现在，二元原子Ḅ在平面阵列上运行。对于一对[a，b]，它仅返回2a + b。正如前面提到的，Ḅ是一个空操作为整数：一个整数参数Ç被提升为并[c]和[C]中的任何碱是简单地Ç。

第一次调用Ḅ将[1，1]减少为3，从而产生[1，[1，[1，[1，[1，[1，[1，3]]]]]]]]]]。下一个调用将[1，3]减少到5，将下一个[1，5]减少到7，依此类推，直到第九个Ḅ返回17为止。

+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ

Ṇ是平面逻辑NOT原子，并将隐式参数0映射到1。+是加法原子，因此+Ṇ递增的十八个副本中的每个副本都返回先前的返回值（最初为0）。整个程序因此返回18。

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

C是补原子，并将其参数z映射到1-z。N是取反原子，并将其参数z映射到-z。一起CN将z映射到-（1-z）= z-1，因此18个副本将隐式参数0转换为-18。C收益率的最终应用1 - (-18) = 19。

ĖḌĖḌ

该枚举原子Ė枚举在阵列的项，创建索引值对。隐式参数0提升为[0]，然后Ė产生[[1，0]]。所述undecimal原子将从基座10的平坦阵列为整数，得到[10]在这种特殊情况下。

第二个调用Ė将[10]转换为[[1，10]]，第二个Ḍ最终将其转换为[20]。

21 – 30

ṫṣȦJṫȦ⁸ȦJ

所述尾原子ṫ（成对层）选择它的左论点，即开始索引处的后缀（1型和模块化）在其右参数指定的，推动左整数参数X到[X] 。在两个参数都设置为0的情况下调用时，ṫ返回[0]。

如果any和all原子的自变量为真，并且在任何深度都不包含零，则Ȧ返回1，否则返回0。在这里，我们仅将其用作标识函数以返回隐式参数0。原子处的拆分在其右参数0出现时ṣ将其左参数[0]划分开，因此在此处返回[[]，[]]。

的索引原子J丢弃该返回值的元素，并用它们的索引替换它们，得到的范围[1，2]在该特定情况下。Ȧ并且ṫ两者都像以前一样工作，因此它们将[1，2]减少到从最后一个索引开始的后缀，从而产生[2]。

在niladic链接中，常量⁸保持[]。这是一个无法解析的缺点，也就是说，它无论如何都无法融入链中。结果，先前的返回值（[2]）被打印到STDOUT，然后替换为nilad的值（[]）。

由于[]虚假，Ȧ将其转换为0。的J原子促进0到[0] ，然后返回其索引（列表[1] ），它是隐式地打印程序完成时。

22

另一个字面意思。Repdigits似乎是使用它们的最佳地方。

“@ṃ»

这使用了Jelly的内置字符串压缩。在Jelly的代码页中，@和are的索引分别为64和220，字符串文字可以包含250个不同的字符，因此首先计算整数250×65 + 220 = 16470。

16470可被3整除，因此商16470/3 = 5490编码可打印的ASCII字符或换行符。有这些96和5490 = 96×57 + 18，也就是说，我们已经解码的可打印的ASCII字符的基于0的索引在18，这是“2”。

我们剩下57，也可以被3整除，因此，商57/3 = 19 = 96×0 + 19在从0开始的索引18处对可打印的ASCII字符进行编码，即'3'。

剩下0 ; 解码过程停止。生成的字符连接起来形成“ 23”

!ḤḤ!

的阶乘原子!接通隐含参数0到1。对未平分原子的两次调用Ḥ将1变成2，然后将2变成4。最后，!计算4！= 24。

³HH

在不存在的命令行参数，常数³保持100。两个调用所述的H匝100到50，然后50到25。

ØaM

该常数Øa保存小写字母。的最大原子M产生最大项的所有指数，并且由于Ž是最大的小写字母，则结果为[26] 。

;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬

串联原子的26个副本;将初始返回值0和默认参数0的 26个实例串联在一起，从而构建了一个由27个零组成的数组。

¬是逻辑NOT原子，因此;¬将1附加到零数组中。下一个¬取反数组中的所有元素，剩下27个1和1个零的数组。

ḅ是unbase原子，并将其左参数中的数字数组从其右参数中指定的基数转换为整数。ḅ¬从一元转换为整数，因此只执行求和。对于27个数组，将返回27。

irið8c

原子的索引i将其左参数0提升为[0]，然后在该数组中找到其右参数0的索引，得出1。

的范围原子r构造从它的升序或降序范围剩下的参数到它的正确的。正确的参数是隐式参数0，因此得出[1，0]。的第二次调用i查找的索引0在[1,0] ，得到2。

ð开始一条新的二元链。由于前一条链是尼拉第式的，因此该链的左参数和右参数都将等于第一条链的返回值（2）。c在组合原子中。对于左参数8和右参数2，它计算8个元素的集合的所有唯一，无序2组合，返回8C2 = 8！/（6！2！）= 28。

⁶ḲĠṂ°İṂĊ

该常数⁶包含一个空格字符，并将参数和返回值设置为''。的话原子Ḳ促进了字符“”到单串“”和分裂它在空间，得到[[]，[]] 。

该组原子Ġ团等于元件的所有索引。由于最后一个返回值的两个元素相等，因此此处返回[[1，2]]。的最小原子提取最小（唯一的）这个数组的元素，得到[1,2] 。

的程度原子°从六十进制度均为整数转换为弧度，得到1°×2π/ 360°=π/ 180和2°×2π/ 360°=π/ 90。的逆原子取乘法逆，得到180 /π≈57.3和90 /π≈28.6。

然后，Ṃ再次取最小值，得出28.6。最后，细胞原子Ċ将28.6转换为29。

œṡ¹ẆẆTUṖṖṖṖP

的身份原子¹返回0的隐含参数0。的周围分割原子œṡ促进两者的其参数（两个0）至[0] ，然后分裂[0]周围等于邻接子阵列[0] 。这产生[[]，[]]。

该滑动窗口原子Ẇ构建其自变量的所有连续的子阵列。第一个实例将[[]，[]]转换为[[[]]，[[]]，[[]，[]]]，第二个实例将[[[]]，[[]]，[[] ，[]]]转换为
[[[[]]，[[[]]]，[[[]，[]]]，[[[]]，[[]]]，[[[]]，[ []，[]]]，[[[]]，[[]]，[[]，[]]]]。

该事实原子T列出truthy元素的所有指标。第一层的数组都不为空，因此得出[1，2，3，4，5，6]。在倒放原子U反转这个数组，得到[6,5，4，3，2，1] 。

pop原子的四个副本Ṗ删除了最后四个元素，剩下[6，5]。最后，乘积原子P将这个数组转换为30。

31 – 40

ȷ½RṪ

ȷ是1×10 ³ = 1000的简写。的平方根原子½得到31.6，其范围原子R转变成[1，...，31] 。最后，尾原子Ṫ提取最后一个元素，返回31。

LµdddddµFL

的长度原子L促进了隐含参数0至[0] ，然后取长度，得到1。µ启动一条新的单子链，结果1成为其参数。

对于参数x和y，divmod原子d产生[x / y，x％y]。每个调用的y = 1，因此结果将始终为[x，0]。

第一次调用从x = 1开始，产生[1，0]。d仅对整数进行运算，因此它会在后续调用中向量化。第二个调用产生[[1，0]，[0，0]]，第三个调用产生[[ [1，0]，[0，0]]，[[0，0]，[0，0]]]，第五个也是最后一个深度为5的数组，其中包含一个1和31个零。

µ再一次启动一条新的单子链，并且之前的数组成为其参数。所述平坦原子Funnests该阵列中，产生一个单一的一个和31个零的平面阵列。最后，L取结果的长度，返回32。

33

另一个字母数字，另一个文字。

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

包装原子的每个实例将其参数z转换为[z]。在初始返回值为0的情况下，所有34个实例的总和为[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] 。最后，深度原子ŒḊ计算所得数组的最大深度，返回34。

ẇɓæ«æ«æ«æ«æ«|æ«|

的窗口存在原子ẇ促进两者的其参数（包括默认至0），以[0] ，然后如果** [0] **作为发生的连续子阵列测试[0] 。确实如此，因此ẇ返回1。

ɓ开始一条新的二元链。由于前一条链是尼拉第式的，因此该链的左参数和右参数都将等于第一条链的返回值（1）。该链使用两个不同的二进位原子：左移（æ«）和按位OR（|）。

以三个或更多个二元组开头的二元链最初会用该链的参数调用第一个二元组。在此，得出1 << 1 = 2。随后的六个dyad被成对地分组（所谓的forks），其中最右边的dyad首先通过链的参数被调用，然后最左边的dyad被调用，并且先前的返回值返回到双方。

对于æ«æ«，我们得到2 <<（1 << 1）= 2 << 2 = 8。然后，æ«æ«计算8 <<（1 << 1）= 8 << 2 = 32。现在，|æ«让我们32 | （1 << 1）= 32 | 2 = 34。

最后，尾随的|行为就像一个钩子，并以前一个返回值作为左引数，并以链的右引数作为右引数来调用。返回34 | 1 = 35。

⁹ṚḢ²

在不存在第二个参数的，恒定⁹保持256。的反向原子促进256到阵列[2，5,6]并且逆转它，得到[6,5，2] 。然后，头部原子Ḣ提取第一个元素，而方形原子²返回**6²= 36 *。

‘‘‘0‘‘‘‘‘‘‘

的增量原子‘通过增加它的自变量1，所以‘‘‘转动的初始返回值0到3。下一个0是无法解析的nilad，也就是说，它无论如何都不适合链。结果，先前的返回值（3）被打印到STDOUT，然后替换为nilad的值（0）。

以下7个的拷贝‘转这个0到7，其被隐式地打印程序完成时。

’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ

的减量原子’通过递减它的参数1，所以38拷贝转初始返回值0到-38。的绝对差原子ạ计算之间的无符号差-38和隐含参数0，返回38。

-____---__________

-是-1的简写，并将链接的参数和返回值设置为-1。每个_都是二元减法原子的实例，如果缺少，其right参数将默认为-1。

首先，-____-计算（-1）-（-1）-（-1）-（-1）-（-1）= 3。以下的-1是不可解析的nilad，因此将先前的返回值（3）打印到STDOUT，然后替换为nilad的值（-1）。

接下来，-_计算（-1）-（-1）= 0，其中文字-设置的左参数，_并将返回值用作右参数。接下来的九个副本从返回值中_减去默认参数-1，得出9，在程序完成时隐式打印。

”(O

”(是字符文字，并且序数原子O查找其Unicode代码点，得出40。

41 – 47

⁵ḶxḶ⁵ị⁵ḶxḶḣṢ

在不存在第三个命令行参数的，恒定⁵保持10。所述unlength原子Ḷ创建一个基于0的范围内，特别是[0，...，9]为参数10，对两侧重复到位原子x。后者将其左自变量的元素与右自变量的重复进行匹配，并将每个元素重复相应的次数。使用[0，…，9]作为左参数和右参数，因此我们得到零个零，一个一，两个二等，等等。

的索引原子ị取其右参数的元件在它的左边的一个指定的索引处。使用左参数10（⁵在其左侧）和右参数[1、2、2、3、3、3、4、4、4、4，…，9]（先前的结果），得出4。

到此为止的链之后是不可解析的nilad ⁵，因此将先前的返回值（4）打印到STDOUT，将返回值设置为10，然后像往常一样解析链的其余部分。

如前所述，⁵ḶxḶ将产生数组[1,2,2,3,3,3,4,4,4,4,4，...，9]。此时，我们称为排序原子Ṣ上的参数10，这促进了10至[1,0] ，则排序，以产生[0,1] 。现在，二元头原子从结果左侧获取长度为0和1的前缀，剩下[[]，[1]]。打印时，除了1之外什么都看不见。

⁽{ʂ%⁽{}

⁽及其后两个字符构成数字文字。如果j和k是Jelly代码页中的代码点，并且（j，k）<（124，250 ），我们得到整数1001 + 250j + k。的码点'{' ，'}' ，和'ʂ'是123，125，和167，因此，左字面的计算结果为1001 + 250×123 + 167（= 31918） ，当右边的计算结果为1001 + 250×123 + 125（= 31876）。

由于左整数小于右整数的两倍，因此结果为（…+ 167）％（…+ 125）=（…+ 167）-（…+ 125）= 167- 125 = 42。

ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®

所述洗牌原子Ẋ随机化其自变量的元素的顺序; 预先将数值参数z提升为[1，…，z]范围。对于隐式参数0，此范围为空，并Ẋ产生[]。的所有原子Ạ返回1，如果所有其自变量的元素为truthy，0如果不是。由于空数组不包含虚假元素，因此在此处Ạ返回1。

带有原子的zipż（二元组）接受参数x和y并转置对[x，y]。对于整数x和y，这简单地产生[[x，y]]，因此ż使用参数1和0（隐式参数）调用的特定对象返回[[1，0]]。的二进EVAL原子v接通所有平面阵列（仅包含数字和字符）i中的左边参数成字符串，然后计算所得到的字符串作为与它的合适的参数作为程序的论点单子果冻程序。自[“ 10”]仅由文字组成，这会忽略的正确论点，v而只会导致[10]。

该副本快速©重视v并复制其结果到寄存器。后来出现的召回原子®（一个nilad）将从寄存器中获取[10]。

接下来的三个żv工作副本与以前相同，将[10]映射到[[10，0]到[100]映射到…到[10000]。的顺序原子ọ测试其左侧参数多少次是由它的正确的整除，所以在这里，它计算的顺序10（取出与®在）10000 = 10 ⁴，得到[4] 。

以下®是无法解析的nilad，因此将先前的返回值（[4]）打印到STDOUT，然后替换为nilad的值（10）。Ạ接下来应用，得到1。（这是必需的，因为此时可以先分析nilad，然后是二元组。）

如前所述，żvżvżv在当前返回值后附加三个零，将1变成[1000]。最后，以1000 = 10 ³ọ®的顺序计算10的顺序，并在程序完成时将3打印到STDOUT。

44

另一个字母，另一个文字。

111111l11&K1111111Kl11&

首先，文字111111将参数和初始返回值设置为111111。的其他运行1也是文字。

l是对数原子，计算其左参数与右参数中指定的底数的对数。当使用正确的参数11调用111111时，我们得到log ₁₁ 111111≈4.85。

的话原子K连接在空格的list参数，促进数字/字符之后Ž到[Z] 。在这里，我们仅使用它即可将链接的参数111111转换为[111111]。（这里我们不需要数组，但是我们用完了身份原子。）按位AND原子&将返回值带到双方，如果需要，将其强制转换为整数，然后计算其按位AND。在此特定情况下，它返回[4.85＆111111] = [4＆111111] = [4]。

以下1111111是无法解析的nilad，因此将先前的返回值（[4]）打印到STDOUT，然后替换为nilad的值（1111111）。K然后将此整数转换为[1111111]。（这再次不是真正需要的，但是此时可以先分析一个尼拉德然后是一个二元组。）

如前所述，l11计算log ₁₁ 1111111≈5.81，然后&返回[5.81＆111111] = [5＆111111] = [5]。

,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ

这是唯一包含多个用户定义的链接的程序。最后一个链接是主链接，在程序启动时执行，其余的是帮助程序链接。快速Ç链接始终引用当前链接上方的链接，并单执行该链接。同样，快速Ñ链接始终引用当前链接下方的链接（环绕），并且还单执行该链接。

顶部链接由一对原子,（一个将参数x和y转换为[x，y]的二元组）和和原子S（一个原子，其将整数参数z提升为[z]并通过加法减少数组参数）组成。当,SS使用整数参数n调用链接时，它将计算Σ[n，Σn] =Σ[n，n] = 2n。

中间链路由在上述原子，上述快速的Ç，并且不显着原子Ị-即产生一个单子1为数值参数Ž与-1≤Z≤1 ，但0对于所有其他。对Ị整数参数n应用两次实际上将其替换为1，因为第一个参数的输出Ị（第二个参数的输入）始终无关紧要。然后将此结果与返回值Ç（用参数n调用）配对，并将结果对减少S。总计，我们计算Σ[（| n |≤1）≤1，2n] =Σ[1，2n] = 2n +1。

有了这两个辅助链接后，主链接现在可以通过查看其二进制数字来构造任何非负整数。初始返回值为0时，链ÇÑÇÇÇÑ计算最终结果（（（（（（0×2 +1）×2）×2 +1）×2 +1）×2 +1）×2 =（（（5× 2 +1）×2 +1）×2 = 46。

ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

在下一任原子找到的最小正素数严格大于它的参数值。在初始返回值为0的情况下，十五次调用将Æn计算第十五个质数，即47。

brainfuck，2分，255起 144 10字节

是的，这不是最好的主意，因为我只能使用8个字符（tarpits和tarpit），但让我们看看有多少可能。我认为这是所有可能的。：P此答案演示了Brainfuck使用的八个字符中的六个，另外两个是,，分别是input和.，分别是output和。

+
>--[<->-]

在线可视化！

说明

每个数字都会创建并存储在磁带的起始单元上。很大程度上依赖于包装单元，在一些解释器中未实现。

1：

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2：

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

Neim，得分38，327字节

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

说明：

• 对于1，我们使用“检查是否相等”令牌，此处利用的是当Neim尝试在空输入上弹出时，它变为0。由于0和0是等效的，因此将隐式打印1
• 从2到9，我们只使用数字文字。
• 从10到32，Neim实际上对所有它们都有一个字节常量（是的，这很疯狂）。
• 对于33，我们仅使用递增命令。在第一个字节上，Neim尝试弹出一些东西以便可以递增它，但是由于输入为空，因此默认为popping 0。
• 对于34，我们使用相同的方法，但递减并取绝对值。
• 对于35，我们正在利用零阶乘为1的事实，并通过复制1并反复加
• 对于36，我们用于ℂ检查0和0的共素性。这将推1。然后使用来获得第一个素数𝐋，这将导致仅包含2的单例列表。然后，我们将得到最大的元素（𝐠），将2推为一个数字。然后我们重复此过程，直到获得列表[2 3 5 7 11]。之后，我们使用𝐝计算增量，得到list [1 2 2 4]。接下来，我们使用𝐬求和-为9-然后计算从0到9的互斥范围，得出[0 1 2 3 4 5 6 7 8]。最后，𝐬再次用于获得37。
• 对于37，它α是一个代表负数的常数，我们反复按下它并减去（再次利用当我们尝试在空输入上弹出时按下0的事实）。
• 对于38，再次使用默认0作为空输入，我们继续将0附加到其自身，创建一个长列表，然后计算长度。

可以在这里尝试

Python 2、15

这是一个开始，寻找更多

感谢leo的提示帮助我达到了15岁

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

2

import math
print'%i'%math.pi

((()<())<())<<((()<())<())<<((()<())<())

5

6

7

8

9

11^1 

33/3

4--4--4

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

0xF

Japt，448字节，得分42

Shaggy，ETHproductions和Oliver之间的大型合作。

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

剩下这些（有用的）字符：

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

说明

在我们开始之前，有两点关于Japt的知识，我经常使用它。首先，Japt有6个变量供输入保留，即大写字母U-Z。如果没有输入通过这些变量，则它们都默认为0。本技巧介绍了第二件事。

单击任何片段以在在线解释器中尝试。

v

当施加到数字，则v方法将一个整数Ñ作为参数，并返回1，如果数字是整除Ñ，0如果不是。如果未提供n，则默认为2。0（默认值U）是整除2，所以这给了我们我们1。

y

与第一个非常相似。当应用于数字时，该y方法将整数n作为参数，并返回两个数字的GCD。如果未提供n，则默认为2。由于0可被2整除，因此GCD（0，2）给我们2。

Íà

à传回的组合数[1...this]，传回3

Qiiii)iiii)âQ

Q默认为单引号。i在一个字符串的开头插入另一个字符串；如＃3所述，每个iiii)都等效.i("i".i("i"))于JS，因此i在字符串的开头插入的两个副本。这样做两次，您将获得字符串iiii"。âQ然后进行模拟.search(Q)，给出"字符串中第一个的索引，即4。

ÂHq

LÁL

´Vn´VnVnVn

如前所述，V默认为0。´是--操作员的快捷方式，因此代码等效于以下JS：

(--V).n((--V).n(V.n(V.n())))

X.n(Y)等价于Y-X或-X + Y ; 第一个--V返回-1，第二个返回-2，所以这大约等于-（-1）+（-（-2）+（-（-2）+-（-2）））。简化后，我们得到1 + 2 + 2 + 2 = 7。

8
9

从字面上看，是8和9。

A
B
C
D
E
F
G

这些都为常数，10 - 16，包容性。

J-----J---J---J---J

J预设为-1。Japt解释器以某种方式设法正确地对此进行了解析，如(J--) - (--J) - (--J) - (--J) - (--J)。再做一些数学运算，我们发现这等效于（-1）-（-3）-（-4）-（-5）-（-6），或者-1 + 3 + 4 + 5 + 6 = 17。

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾您可能会猜到它是的快捷方式.75。我们将0.75的 24个副本放在一个数组中，然后求和x，得到0.75 * 24 = 18。

;Iìw

我认为这是我最喜欢的。;在程序开始时，更改一些Japt常量的值；没有它的I是64，但是有它的I是91。ìw将其转换为数字列表并w在该列表上运行，反转数组，然后转换回数字以得到19。

~~½e½e½e½e~½e½

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

最后的结果~~将其底限为整数，得出20的结果。

++T+++T+++T+++T+++T+++T

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

结果是1 + 2 + 3 + 4 + 5 + 6，总计21。

22

文字22。

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Ä是的快捷方式+1，因此总计23 1 s。

4á

这将找到的排列数[1, 2, 3, 4]，即4！= 24。

5²

²是的快捷方式p2，将数字提高为2的幂。5 ** 2是25。

°UU°°°U°°U°°U°°U°°U

°是++操作员的快捷方式，或者如果不能这样解析，则为+ +。如前所述，当没有输入时，U默认为0。因此，代码等效于(++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U)，与＃17非常相似：U先递增到1，然后重复递增并添加，使得最终结果为1 + 3 + 4 + 5 + 6 + 7 = 26。

»³³

³是p参数为3的方法的快捷方式。但是，如果小写字母直接出现在左括号之后（»是的快捷方式((），它将变成字符串。这样就可以将其传递给方法并称为函数（即m³通过进行映射.p(3)）。但是，在这种情况下，("p",3)返回我们的3，然后将其提高到3（p应用于数字时是幂方法）的幂，从而得出27。

7/¼

¼您可能已经知道了，它是的快捷方式.25，因此计算得出7 / 0.25 = 28。

$'_____________________________b'$bb

包裹在$符号中的任何内容都被视为纯JavaScript，因此我们得到了29个下划线的字符串，后跟一个b。（没有$，'将是一个单字符字符串。）该b方法应用于字符串时，将返回该参数在该字符串中的第一个索引。正如上文＃3，最后b被转换为字符串，所以我们抓住的第一个索引b在我们的字符串，这是29。

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µ是一个快捷方式-=，并É为-1。效果是从0中减去-1的 30个副本，得出30。

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

非常像＃29。该a方法应用于字符串时，将返回该参数在该字符串中的最后一个索引。使用0索引，a32 as 字符串中的最后一个索引为31。

Sc

S被预定义为单个空格，并且c在单个字符字符串上返回其字符代码，为32。

33

文字33。

Mg011

MgN返回第N个斐波那契数。八进制011是9；第9个斐波那契数是34。

##

#返回下一个字符的字符代码。#本身的字符代码恰好是35，这使得我们在这里的工作特别容易。

6p

p是取幂，没有第二个参数，默认为2；因此，这将打印6 ** 2 = 36。

Rí í í í í è.

这相当棘手。R默认为单个换行符（这是换行符，稍后变得很重要）。í没有任何参数的字符串上的每个字符并附加其索引：一个相当无用的转换，但是经过5次迭代的结果是这样的：（使用R而不是文字换行符）

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

有趣的是，每个条目只是下一个条目的前缀...但是，无论如何，最后一部分è.计数/./g在结果中找到多少个匹配项。字符串中有38个字符。但是，由于/./g仅匹配非换行符，因此结果为37。

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

反引号标记一个压缩的字符串，然后¥解压缩为ll。l字符串上的length，因此在减压后得出38。

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

噢，男孩，这真是个傻瓜。首先，我们生成truewith ¨N（¨代表>=，N没有输入的是空数组），然后将其转换为1with |N。从那里开始，它变得非常疯狂：

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

（¹s只是闭合括号的替代，已被省略。）final最终o弹出并返回数组中的final项，得到39。

º¤¤*º¤

与＃3大致相同。¤是s参数为2的方法的快捷方式。但是，在这种情况下，转码的代码为(("s", 2).s(2) * (("s", 2) * (("s", 2))))或简化(2).s(2) * (2 * 2)。.s(2)以2为底的字符串返回数字，给出"10"; * (2 * 2)将其隐式转换为数字并乘以4，得到40。

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

与上一个相似。Å是s参数为1的方法的快捷方式。但是，在这种情况下，每个将(Å转换为("s", 1)，仅返回1。1<<1<<1<<1<<1<<1是32，1<<1<<1<<1是8 ; 这些与XOR在一起1得到41。

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±是一个快捷方式+=，并¶为===。这意味着代码实际上是

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y 永远是对的，因此我们可以简化一下：

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 +1 = 1 ; 1 +1 = 2 ; 2 +（2 + 1）= 5 ; 5 + 5 = 10 ; 10 +（10 + 1）= 21 ; 21 + 21 = 42。

PHP，得分17，130字节

使用的字符 ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1个布尔常数Z（未设置）等于常数Z

2 FTP_MOREDATA是PHP中的常量，值为2

3位和字符; 和w

4按位左移，逻辑不将空数组强制转换为布尔值true，通过左移运算符强制转换为整数1

7位或字符＃和$和1

9 SIGKILL是PHP中的常数，值为9

每步右移10位是8的整数除法，因此我们有步骤333333、41666、5208、651、81、10

从一开始就在字符串X中计数13个char X ...

15十六进制值f = 15

17与位ha和YV的按位Xor

所有代码段都是数组中的项目

在线尝试！

PHP，得分16，94字节

使用的字符 AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1个布尔常数Z（未设置）等于常数Z

2按位和chars：和w

3 Pi通过将空数组强制转换为零而强制转换为整数

7按位异或A和v

未设置10个变量$ s！$ s =一个字符串长度为$ s的concat

13111/2 = 55/2 = 27/2 = 13整数除法

15十六进制值f = 15

所有代码段都是数组中的项目

在线尝试！

PHP，得分14，84字节

使用的字符 $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1个布尔常数Z（未设置）等于常数Z

3 Pi通过将空数组强制转换为零而强制转换为整数

7 ERA为常数131116 mod 11 = 7

未设置10个变量$ s！$ s =一个字符串长度为$ s的concat为零

13十六进制值d = 13 14按位非和减号将NULL升高到14

所有代码段都是数组中的项目

在线尝试！

R，得分13 14

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

多亏了user2390246，多了一个。

使用的字符：

0123456789acemqrstuvxDFT^=";-/+()$

MATL，得分21 22 23数字（273字节）

感谢J Doe将数字从22扩展到23！

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

在线尝试！链接中的每个代码段都以D（显示）或]D（显式关闭循环并显示）结束，以清除堆栈，从而与下一个代码段隔离。

说明

0~

推0。否定。给出true，显示为1。

'bd'd

推弦'bd'。字符代码点之间的连续差异。

{P}gk

推入包含number的单元格数组pi。转换为数字数组（即转换为单个数字）。四舍五入。

HH^

推2两次。功率。

5

数字文字。

6

数字文字。

7

数字文字。

8

数字文字。

9

数字文字。

3 3.333333333333333*

推3。推3.333333333333333。乘。由于浮点精度，这给出10。

11

数字文字。

IEE

推3。乘以2两倍。

[B]Yq

推送[6]（与相同6）。计算第n个素数。

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

推114次。堆栈中的元素数。清除其余的堆栈。

KUKUa-

推4。广场。照着做。任何：给1。减去。

4W

推4。2提出来。

FFFFFFFFFFFFFFFFFn

推入阵列[false false ... false]（17次）。数组中的元素数。

TTTTTTTTTTTTTTTTTTs

推入阵列[true true ... true]（18次）。数组的总和。

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

推入从间隔（0,1）中获取的19个随机数。水平连接18次。数组中非零元素的数量。

OOOOOOOOOOOOOOOOOOOOvZyX>

推020次。垂直连接堆栈内容（给出列向量）。大小：给出数组[20 1]。数组的最大值。

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

推动1j（假想单位）21次。加20次。除以1j。

22

数值文字

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Do ... while循环（`）具有隐式结束。在第一次迭代中，它会推入迭代索引（@）并将其递增（Q）22次，从而得出23。循环条件（@@<）为假，因此退出循环。

一些需要进一步改进的想法

• 代码段10中的（空格）可以替换为 |
• X>摘要20中的可以替换为p，从而释放前缀X。
• 目前未使用的和潜在的有用：:，A

Windows上的Vim 8，得分13,104字节

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}表示<C-{keystroke}>，所以^X就是<C-x>，除了^@其是<C-j>。我仍在尝试向此列表添加更多数字，并<CR>表示一个换行符。

注意：要运行这些命令，请使用来启动vim -u NONE -U NONE。这是为了确保您的配置不会干扰代码。

片段1到10在插入模式下开始。片段12和13在正常模式下启动。

说明

片段8是:^R=&ts^@。我必须感谢@ L3viathan提出这个建议^@，并感谢@ nmjcman101建议替代换行，以及@ØrjanJohansen缩短&tabstop为&ts。&ts然后计算选项卡的大小，默认情况下为8，然后将此值插入编辑器。

片段10是8^O^A^O^A。我们插入8，然后增加两次以得到10。

片段11是0^[^X^X^X^X^X^X^X^X^X^X^X0x。我们记下0，然后递减11以获得-11。然后我们减去负数得到11。

片段12是:h<CR>wwwwwwwwwwwy$:q<CR>p。这将打开Vim 8的帮助菜单，其中包含以下信息：

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

并且ws 的序列移至12，在该点y$复制数字。然后使用将其粘贴到编辑器中p。

片段13 grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD感谢@DJMcMayhem提出了它。仅在Windows上有效。该代码段在帮助菜单中搜索以开头的命令g。然后使用j移至以下行：

|g?|        g?      2  Rot13 encoding operator

之后将其复制并粘贴到缓冲区中。之后，除了13之外的所有内容都将从缓冲区中删除。

Mathematica，得分13

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

05AB1E，得分18，67字节

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

在线尝试！

乒乓球，得分127

在PingPong中，每个字符都有其自己独特的数字值，使得一直计数到127都是一件微不足道的任务。该语言通过读取每个字符的值并将其推入执行所有操作的堆栈顶部来工作。从理论上讲，PingPong可以超过127，但是它需要传递一个字符块，这些字符在文本编辑器中只是显示为空格，因此我将其排除在解决方案之外。

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

八度，得分14,74字节

可以肯定的是，我现在已经接近极限了。

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

不得不删除strchr，因为我已经c在10号我仍然有j，^，=，!，空间和离开，所以有可能挤进去一个更水平制表符（ASCII-9）。

水平制表符可以用作空格，因此strchr和nnz一起使用的技巧可以再使用一次。剩下的唯一小写字母是abdfgjkmoquvwxy。利用这些功能可以实现的功能并不多。mod可以，但是不能接受字符串输入。

使用其余字符很容易获得1，但是我不知道如何获得其他任何东西。

测试全部。

可能有用的：fun a是一样的fun('a')，fun a b是一样的fun('a','b')等等。这可以在几个地方使用：

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1. 

使用此功能将使它0可用，但是我还看不到如何使它有用。

e (2.71828...)并且j仍然使用。不过必须删除ceil才能使用e。

替代方案（灵感）：

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

的JavaScript（ES7），16个整数，137个 130 128字节

我接受了@ETHproductions的回答，并运行了一段时间。它发生了很大的变化，以至于我将其单独发布。欢迎提出想法。:)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

剩余的：
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

或者，如果将1的代码段替换为!!/!//!!/!/：
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

JavaScript（ES7），16个整数，127个字节

短一个字节。：P

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

剩余的： $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Dyalog APL，得分15，89字节

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{之前的换行符l:l是12的一部分。}

_{14中的空格代表制表符。}

> <>，得分20，93 90 74 65字节

（Teal Pelican保存了3个字节，Jo King保存了很多字节！）

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

在鱼游乐场尝试一下！您可以通过将摘要添加n;到每个摘要的末尾来使其打印结果。请注意，第9个代码段包含一个选项卡，该选项卡被堆栈交换吃掉。

说明：

• 在中iii((，每个都i尝试获取输入，但是由于没有输入，因此他们推EOF = -1。然后(是小于指令，并且由于-1不小于-1，它会推假0。但是第二个(询问是否-1小于0，因此它推导了一个事实1。
• 2并且3很明显。
• 因为ll{lll{[，第一个l按堆栈的长度，即0第二个，按第二个，按新长度，将堆栈移到0, 1。该{旋转堆栈离开，调换1和0。再加3个l筹码就可以了1, 0, 2, 3, 4。然后将{旋转1到最前面，然后[虹吸掉1堆栈上的第一件东西4。
• 5，6，7和8是显而易见的了。
• 在中!\t00=0g（其中\t代表一个制表符）中，!跳过该制表符，然后00=推入两个零并检查它们是否相等（它们相等），因此我们得到了真相1。按下另一个键后0，g会在1,0代码位置找到字符，该字符是带有字符代码的标签9。
• a通过对f各推10到15分别（大概是为了使十六进制不错）。
• 44*推两个4s并将它们相乘，为16。
• 'RA'推的字符代码R和A（82和65分别地）到堆栈，然后%计算82 mod 65 = 17。
• 999-9--评估为9 - ((9 - 9) - 9) = 18。
• "&F#"推的字符代码&，F和#，它们是38，70和35分别。然后,是除法，所以我们得到38 / (70 / 35) = 19。
• 最后，1::推入a 1并将其复制两次，+将其中的两个加在一起得到2；:+复制2并将其添加到自己4; +添加剩下1的得到5; 然后:+:+重复并添加两次，得到20。

这是> <>可能获得的最高分数。任何代码段都必须在某个地方包含将空堆栈变成非空堆栈的指令，并且只有18条> <>指令可以做到这一点（即i，，l数字0–9和a–f）以及字符串模式。（每条其他指令要么对空堆栈不执行任何操作，要么><v^/\|_#x!{}r尝试弹出某些错误?.+-*,%=():~$@[]on&gp。）进入字符串模式使用"或'，因此最多18 + 2 = 20可能有摘要。

如果你更舒服unprintables比我，这是53个字节可能，这要归功于乔金：00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"，其中X，Y并且Z通过字符被替换成代码17，19并20分别。

MathGolf，48 51 53整数，324 字节

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

40多亏@maxb，得分+2（和-2个不同的字节）。

每行是一个单独的程序。

已使用的字节（92个不同的字节）： îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

说明和TIO链接：

MathGolf是一种新的高尔夫语言，专门用于数学高尔夫挑战。它具有大量的单字节数字内置函数，这使其成为一个完美的挑战。

1）î：推送循环的1索引值，默认值为1：在线尝试。
2）ª∞~：按[1]；加倍（[2]）；弹出列表并将其内容推入堆栈：在线尝试。
3）c±b±+：按下-2; 然后弹出并推送其绝对值；推-1; 然后弹出并推送其绝对值；并将它们添加在一起在线尝试。
4）φⁿ_¥-：推黄金分割率（1.618033988749895）; 立方体（4.23606797749979）; 复制堆栈的顶部；取模2（0.23606797749979）; 彼此相减：在线尝试。
5,6,7）数字本身：在线试用。
8）○¢i♀/：按2048; 转换为十六进制字符串（800）; 转换为整数；推100; 划分：在线尝试。
9）d²：按下-3; squared：在线尝试。 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34， 35,36,37,38）为数字本身（）推送内置函数♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ：在线尝试。
39）♫¼¼¼¼：按10000；整数除以4的四倍：在线尝试。
40）88888]Σ：按8次5次；将它们包装成列表；汇总该列表：在线尝试。
41）数字本身：在线尝试。
42）╔½½½½½½½½½½½：按86400；整数除以2十一次：在线尝试。
43）π░3§3：推送PI（3.141592653589793）; 转换为字符串 弹出并推入其第三个0索引字符（4）; 推3; 输出隐式连接在一起的整个堆栈：在线尝试。
44）22#22#：两次按2 取两者的力量（4）; 再来一遍; 输出隐式连接在一起的整个堆栈：在线尝试。
45）τ╥└：推送2 * PI（6.283185307179586）; 弹出并在最接近的（2）下方推2的幂; 推栈顶+ 1而不弹出（5）; 输出隐式连接在一起的整个堆栈：在线尝试。
46）♦⌡⌡⌡⌡⌡⌡⌡⌡⌡：按64; 减少2九次：在线尝试。
47）!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠：推送gamma（n + 1）（默认为1）; 增加2到23次：在线尝试。
48）'0$：推送字符“ 0”的序数值：在线尝试。
49） ÿ@@@@£9：推串"@@@@"; 弹出并推动其长度（4）；推9; 输出隐式连接在一起的整个堆栈：在线尝试。
50）))))))))))))))))))))))))))))))))))))))))))))))))))：增加1五十倍：在线尝试。
51）►◄╠•╠：推1,000,000; 推10,000,000; 两者都弹出并彼此整数除（10）; 推512; 同时弹出并相互整数除法：在线尝试。
52）"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h ：推弦"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"；推动其长度（不弹出字符串）；从堆栈中删除所有内容（最后一项除外）：在线尝试。
53）♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((：按128；减少1七十五次：在线尝试。

稍后将尝试添加更多内容。我还有一些有用的东西，包括取模%和乘法*。

Java 8，11 12 13，39字节

Java只有10个数字符号（0-9），并且所有方法调用和常量都需要一个句点，因此我不确定我能否获得11个以上的输出

显然，在应用操作时，默认情况下chars强制转换为整数

在@OlivierGrégoire的帮助下+1

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

说明：

i->-~i

不接受任何输入并返回1的整数lambda 。当参数不接受任何输入时，默认值将根据上述meta post使用，对于整数，该值为0

2
3
4
5
6
7
8
9

文字整数

'P'^'Z'

两个字符的XOR返回10

11

文字整数

":::::::::::"::length

lambda表达式，它返回12个字符串的长度

0xD

十六进制13

TIO链接（如果要验证）。

盖亚（Gaia），得分25，203字节

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

我认为这是一个完美的成绩，因为鉴于角色的限制，无法再使用Nilads了。

说明

1。 §‼

§是一个空格字符，‼强制转换为布尔值，因此结果为1。

2。 ..⌉+⌉

.是的快捷方式0.5，所以是ceil(0.5+ceil(0.5))。

3。 ₵P~~

₵P是pi，~是按位取反。双重按位取反就是截断。

4。 4

5， 5

6。 6

7。 ∂Ql

∂Q是包含星期几名称的列表，l是长度。

8。 8

9。 9

10。 ¶c

c换行的代码点¶。

11。 11

12 '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13 --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-是的简写-1，⁻是减。因此，这-1 - -1 - -1...足以完成13次。

14。 7:,Σ

推送7，复制:，,将两个7 配对成一个列表，然后求和Σ。

15 Ø!))))))))))))))

Ø是一个空字符串，因此Ø!也是1。递增)1 14次。

16。 øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17。 ⟩‘

关闭一个字符串‘会使它成为一个基数为250的数字文字。⟩在Gaia的代码页中为字节值17。

18岁 ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19 ]]]]]]]]]]]]]]]]]]]n

每个都]将堆栈包装在列表中。这样做19次，即可获得n列表的深度。

20 ⇑’e

使用结束字符串，’它成为代码页代码点的列表。e将列表转储到堆栈中。⇑在代码页中的代码点为20。

21 0(((((((((((((((((((((_

递减(0 21次，然后取反_。

22 22

23。 “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

“B”从base-24 转换字符串，其中0-23的数字为↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B。结果是23。

24 3₈×

3×8。

25 ℍḥḥ

100 ℍ减半ḥ，然后再减半。

C，得分13

这些只是一堆整数常量。

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

1. 0==0评估为1
2. 假设代码在第2行。__LINE__= 2
3. 整数常数
4. 整数常数
5. 整数常数
6. 整数常数
7. 整数常数
8. 整数常数
9. 整数常数
10. 1+1+1...= 1*10= 10
11. 'o'是111，'.'表示不可打印的ASCII 0x10。111/10 = 11
12. (2<<2)= 8，8*2= 16，16-2-2= 12
13. 字符串长度"strlenstrlens"= 13

欧姆，得分21 22，160总字节

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

在线尝试！

说明

1。 ╓S@Ri

按当前日期/时间的秒数（╓S）。获取从1到秒的包含范围（@），将其R取反（），获取最后一个元素（i），始终为1。

2。 ΓΓ-Γ-Γ-

Γ 是-1，所以这是（-1）-（-1）-（-1）-（-1），即2。

3。 αê⌠

αê是欧拉数（2.71828 ...），⌠是上限。结果是3。

4。 ¡¡¡¡¼

¡递增计数器，¼推动计数器。

5， 5

只是一个字面意思。

6。 ▀lll▀l

▀lll▀是一个压缩字符串文字，它等效于"of >ic"。l取长度，所以结果是6。

7。 ÑÑÑÑÑÑÑÿWÿk

首先，我们按7个换行符（Ñ），然后按一个空字符串（ÿ）。堆栈被包装在一个数组（W）中，然后找到该数组中空字符串的索引。

8。 ü`½½

ü是空格字符。`推送其ASCII值（32），然后减半（½½）。

9。 9

只是一个字面意思。

10。 ..≥°

..是文字.字符。它得到增量（≥），它将字符串解析为一个数字，由于它不是有效数字，默认为0，然后将其增量为1。然后我们计算10 ¹（°）。

11。 $$J

$ 首先将寄存器的当前值压入1。因此，两次压入1，将堆栈连接在一起并打印。

12 3dd

按3并将其翻倍两次。

13 7ƒ

按下第7个斐波那契数。

14。 2≡≡≡Σ

将2推入三次，重复三次，将7 2留在堆栈中。然后取堆栈的总和（Σ）。

15 ║F

║是base-220数字文字的分隔符。由于这是在一行的末尾，因此不需要终止。

16。 4º

计算2 ⁴。

17。 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

ò是按位取反，~是算术取反。结合这些运算符，我们可以将0增加17倍。

18岁 6DD++

按6，将其复制两次，然后计算6 + 6 + 6。

19 8π

按第8个质数。

20 τ╛hτ*

按10（τ），得到h其主要因子（╛）的第一个元素（），再乘以10。

21 "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

与以前的代码段类似，该字符串"≤"被解析为0。我们将其递减21次，然后取绝对值。

22 1111 11v11%L1111 11v11%L

在这里，我们计算1111 div 11 mod 11，它是2，然后打印2。然后再次执行。

PowerShell，得分12，91字节。14、176字节

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

编辑：

• 感谢ØrjanJohansen建议使用十六进制字面量0xd表示13，并重新排列5以释放1 + 1 + 1 + 1 ..作为选择。
• 将数组长度更改为字符串长度，将[int]更改为[byte]，并将hashtable更改为将哈希表用作值，从而将(),""Pondering 15 释放为类似的内容，"ZZZZZZZZZZZZZZZA".InDeXof("A")但不能重用点或'e'。

如果没有$，PowerShell将无法执行变量，无法使用基本符号来进行幂运算，位移位，Pi，ceil（）等，并且大多数情况下会在bool和数字字符串之间键入强制转换，因此低语法数字生成的范围相对较小。

TI-Basic（83系列），得分21 22 23 24 25（1003字节）

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

请参阅http://tibasicdev.wikidot.com/one-byte-tokens，以获取挑战在此处允许和不允许执行的操作的列表。

所有这些都可以是完整的程序，因为程序的最后一行是自动打印的。但是（除了17，这是多行长），它们也可以是主屏幕上的摘要。

在这一点上，我认为没有其他方法可以从剩余的可用令牌中获取任何非零值。如果要进行任何改进，则必须首先使上述解决方案更加保守。

说明

• A=A是布尔值1，因为变量A等于自身。
• B默认为0， tan(tan(cos(cos(cos(B约为2.21，然后我们发言。
• C!°弧度为1度，约为0.017。tanh（2）大约为0.964，这是它的一些正能量。我们使用隐式乘法和将其幂编码为二进制√(，然后取tanh⁻¹(。
• 4很简单
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9很简单
• ₁₀^( 是一个1字节的内置10的幂，10 ^ 10 ^ 0 = 10 ^ 1 = 10。
• 11是11
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤G为[[G≤G]...[G≤G]]1，13x1列向量也是如此。取其转置乘积与其自身的乘积即可得出矩阵[[13]]，行列式为13。
• not(H)是1. tanh(not(H))是一个不等于0或1的数字，并且ln(XXX....X)ln(X)^⁻1将简化为X第一个日志中的s 的数目，条件X是该数字不为0（因此该日志存在）而不是1（因此我们不进行除法运算）减0）。
• e^(e^(e^(F 计算结果约为15.15，然后我们开始发言。
• J≥J是1. identity(构造一个1x1单位矩阵，dim(找到其行和列尺寸，并将其sum(相加得到2。然后再次执行此操作，将2x2矩阵的尺寸相加得到4，再一次，将4x4矩阵的尺寸相加得到8，再加上一个8x8矩阵的尺寸得到16。
• K nCr K 是二项式系数0选择0或1。将17 1加在一起得出17。
• i-i-...-i简化为i18i，取abs(18。
• rand→L将随机实数存储到L，但我们不在乎它是什么。我们正在计算log(L)⁻¹log(L^19)，简化为19。
• sinh(sinh(cos⁻¹(I比4多一点，因此seq(III,I,I,sinh(sinh(cos⁻¹(I给出{0 1 8 27 64}算术平均值为20 的列表。
• 用来获得3的把戏的另一个实例。在这里，of的一些力量π应该给21。我们使用隐乘和对幂进行三进制编码³√(。
• 22是22
• 技巧的另一个实例用来获得3和21。我们将3的幂编码为三进制，等于23，3×√(用作立方根并(用于乘法。
• Fix 0是用于在小数点后显示0位数字并将所有值四舍五入为整数的设置。sin⁻¹(ᴇ0求和为π/ 2，并且π/ 2乘以7本身得到的值约为23.59，四舍五入为24。
• 5*5是25。（使用55得到更保守的结果，并将那里使用的解决方案改编为25。但是这种方式节省了大量空间，并且*不是一个非常有用的字符，因为存在隐式乘法。）

SOGL，得分16 18 20，109字节，47个字符

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

Brachylog，16个整数，86字节

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

在线尝试！（输入控制要运行的程序，从1到N）

说明

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

果冻，得分22，177字节

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

一次全部尝试或一次尝试一次（参数是您想要的输出）。

未使用的字符：

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

Reng，得分40，149字节

在这里尝试！

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇǹ
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

所有大写字母都是数字，所以很好。除了两个以外，所有都是摘要。这两个是程序：

13. [[[[[[[[[[[[[mn~
38. &fæ¦

提供的链接使人们可以在运行时查看堆栈。稍后再写解释。

CJam，得分27，168字节

1-3： ， ，XYZ

变量X，Y和Z分别初始化为1、2和3。

4： ",,,,",

推弦,,,,，取长度。

5-9： ， 5，6，，789

数字文字。

10-20：A-K

预初始化变量。

21： U)))))))))))))))))))))

变量U被初始化为0。推动U并递增22次。

22： 22

数字文字。

23： ';(((((((((';((((((((

推动字符;并使其减小9倍2，然后;再次推动字符并使其减小8倍3。

24： 4m!

取4的阶乘。

25： TT=TT=+TT=TT=TT=TT=TT=++++

TT=推1。此代码等效于1 1+1 1 1 1 1++++。

26： N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

N推送包含换行符的字符串。:i将其转换为字符代码列表，产生[10]。~打开包装，给10。W-等于加一个。递增10十六倍得到26。

27： LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

在列表的第27个索引中找到0的索引。

仍然可用的字符： $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

潜在扩展的一些注意事项：

• 我可能必须更改10-20才能将变量用于其他用途。如果我得到的数字大于1，则可以使用*（可能还有按位运算符，但我认为它们不会有太大帮助）。

• 我仍然有S，无论对我有什么好处。

• 如果将26更改为N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-，则:可以使用。

• 我可以推送一些空列表，并使用现有变量获取更多零。我也可以得到π，但这似乎不是很有用，除非我可以以某种方式将其转换为整数，并且m（for m[）和i已经被使用。

• 在数组操作方面，我可以：

  • 通过%或使用地图f
  • 与折叠 *
  • 做一些设定操作
  • 基本转换（这似乎很有希望，但是我不知道如何获得基本数字）
  • 使用|以下命令构造数组：M1|2|3|

Haskell, score 13, 86 bytes

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

Try it online!

Thanks to Ørjan Johansen for finding a way to fix my letter overlap while preserving the score of thirteen. (Also for going out of their way to notify me about this while this answer was deleted.)

pi/pi is 1.0.
sum[] evaluates to 0, 0^0 to 1 and sum[1,1] to 2. 3 to 9 just decode themselves.
length"eeeeeeeeee" yields the length of the string, which is 10.
2+2+2+2+2+2 is 12.
0xD is hexadecimal for 13.