你的挑战是写ň的代码片段，使得当你连接第一ķ ≥1在一起，他们生产的数量ķ。高N，越好。要注意的是：您在代码段中最多只能使用一个字符。

规则

• 您可以在一个（和一个）片段中多次使用同一字符。
• 这些代码段必须按照它们显示的顺序连接在一起，而不会跳过任何代码段。
• 您必须至少写两个片段。
• 所有摘录必须使用相同的语言。
• 请记住：代码片段不必是完整的程序或功能，也不必自己运行。-1是Java中的有效代码段，例如
• 所有产生的串联必须输出各自的K值。
• 获胜者是N值最高的人。决胜局是最短的整体节目长度，以字节为单位。

例

假设你的片段是AD，xc，123，和;l。然后：

• AD 应该产生 1
• ADxc 应该产生 2
• ADxc123 应该产生 3
• 并且ADxc123;l应该产生4。

该课程的分数为4。

Python 3，1121056片段，4383854字节

这与@WheatWizard的Python 2答案非常相似。我在发布它之前不久就开始研究它，但是整理Python关于非ASCII字符和长行的怪癖需要一些时间。我发现Python一次读取了8191字节的行，并且当这8191字节仅包含多字节字符的一部分时，Python会引发SyntaxError。

第一个代码段使用来自Fewest（不同）字符的编码来实现Turing Completeness。

exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))

这种怪异只是构建并执行以下字符串。

print(len(open(__file__).read())-1260)

以下代码段全为一个字符长。接下来的三个字符\n，\r和#。所有其余的Unicode字符（替代字符除外）均按特定顺序排列，因此它们与8191字节的边界对齐。

以下脚本为1到1112056之间的输入k生成适当的程序。

j = 4
s = "exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))"
l = 1
c = \
        [
                None,
                [n for n in range(0x80) if chr(n) not in "\n\r#%'()+1cex"],
                [*range(0x80, 0x800)],
                [*range(0x800, 0xd800), *range(0xe000, 0x10000)],
                [*range(0x10000, 0x110000)]
        ]

k = int(input())
assert k in range(1, 1112057)
s += '\n\r#'[:k - 1]
k -= 4

while j:
                while k > 0 and c[j] and l + j < 8191:
                        s += chr(c[j].pop())
                        l += j
                        k -= 1
                if k < 1:
                        print(end = s)
                        break
                elif c[j] == []:
                        j -= 1
                else:
                        s += chr(c[8191 - l].pop())
                        print(end = s)
                        k -= 1
                        s = ''
                        l = 0

Perl 5，50,091 151片段

第一个片段：

use utf8; print length A

第二，通过第26段：B通过Z

第27至第46个摘要：a至z，不包括“长度”中的字符

第47至第56段：0通过9

第57个摘要： _

其余的片段是50105个单独的Unicode字符，Perl将其视为“单词”字符，不包括初始片段中按任何顺序排列的14个不同的单词字符。

好吧，这是个不错的主意，但事实证明，经过一定长度后，Perl会给您一个“标识符过长”的错误。这是我能够让Perl消化的最长的组合程序：

use utf8; print length A012345679BCDEFGHIJKLMNOPQRSTUVWXYZ_abcdjkmoqsvwxyzĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ

perldiag手册页上说：“ Perl的未来版本可能会消除这些任意限制”，但是我的Perl 5.18却没有这样做。

说明：

在非严格模式下，Perl 5将未引用的单词字符字符串解释为“裸词”，实际上是自动为您引用它们。通常最好避免使用它们，但是在这里一定会有所帮助！

Python 2得分32

for r in range(32):locals()[''.join(map(chr,range(65,66+r)[:26]+range(117,92+r)))]=r+1
print A

随后的片段B，C，D，... Y，Z，u，v，w，x，y，z。

具有讽刺意味的是，Python 3支持Unicode标识符，这使我们对这个技巧很傻-但它不能print没有括号。我也可以将数字填充到标识符中，但是我认为这种方法并不是很有趣。

在线尝试！

Python 2得分18，少作弊

print 0x10-1&0x1
print 0x10-1&0x12
print 0x10-1&0x123
print 0x10-1&0x1234
print 0x10-1&0x12345
print 0x10-1&0x123456
print 0x10-1&0x1234567
print 0x10-1&0x12345678
print 0x10-1&0x123456789
print 0x10-1&0x123456789A
print 0x10-1&0x123456789Ab
print 0x10-1&0x123456789Abc
print 0x10-1&0x123456789Abcd
print 0x10-1&0x123456789AbcdE
print 0x10-1&0x123456789AbcdEf
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]<<False**False

在线尝试！

JavaScript（ES6，V8 6.x），52 50298 119526 119638 119683 128781代码段，88 149147 575179 575631 576121 612789字节

下面的堆栈代码片段将生成完整程序，对其进行评估，然后为该文件创建下载链接。该代码段将继续产生更好的答案，因为新版本的JavaScript支持更高版本的Unicode，这为该语言添加了新的有效标识符。

仅使用ASCII

console.log(new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn$$00112233445566778899AABBCCDDEEFFGGHHIIJJKKLLMMNNOOQQRRSSTTUUVVWWXXYYZZ__aabbccddffiijjkkmmppqqssuuvvzz)

说明

这使用元编程技术Proxy来启用对象上的get handler陷阱并以字符串形式访问属性名称，并返回标识符的length / 2值。

在第一个代码段以开头的情况下new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn，添加的每个其他代码段都length可以通过2确保执行以下操作来增加标识符的字符串：.repeat()两次分别针对2字节utf-16字符的代码点和一次针对4字节utf-16字符的代码点而。

JavaScript中的标识符

在ECMAScript规范中，IdentifierName使用以下语法定义：

IdentifierName::
  IdentifierStart
  IdentifierName IdentifierPart

IdentifierStart::
  UnicodeIDStart
  $
  _
  \UnicodeEscapeSequence

IdentifierPart::
  UnicodeIDContinue
  $
  _
  \UnicodeEscapeSequence
  <ZWNJ>
  <ZWJ>

UnicodeIDStart::
  any Unicode code point with the Unicode property “ID_Start”

UnicodeIDContinue::
  any Unicode code point with the Unicode property “ID_Continue”

产生答案

最初使用“ ID_Continue” Unicode属性，我编写了一个Node.js脚本来生成完整答案。现在，它只是一个客户端脚本，它使用幼稚eval()来测试有效字符，而不是遍历所有unicode代码点：

// first snippet
let answer = 'new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn'

const used = Array.from(
  answer,
  c => c.codePointAt(0)
).sort(
  (a, b) => a - b
)

// create a O(1) lookup table for used characters in first snippet
const usedSet = Array.from(
  { length: Math.max(...used) + 1 }
)

for (const codePoint of used) {
  usedSet[codePoint] = true
}

// equal to 1 for first snippet
let snippets = eval(answer)
let identifier = ''

for (let codePoint = 0, length = 0x110000; codePoint < length; codePoint++) {
  const character = String.fromCodePoint(codePoint)

  // if unused
  if (usedSet[codePoint] === undefined) {
    // if valid `IdentifierPart`
    try {
      eval(`{let _${character}$}`)
    } catch (error) {
      // console.log(character)
      continue
    }

    // repeat so that `snippet.length === 2`
    identifier += character.repeat(2 / character.length)
    snippets++
  }
}

// number of snippets generated
console.log(`snippets: ${snippets}`)

const program = `console.log(${answer + identifier})`

// output of program to validate with
eval(program)

// download link to check number of bytes used
dl.href = URL.createObjectURL(new Blob([program], { type: 'text/javascript' }))

<a id=dl download=answer.js>Click to Download</a>

运行stat -f%z answer.js产生的字节数为612802，但是我们为console.log(和减去13个字节)包装实际提交的内容。

编码方式

源存储为utf-8，这反映在答案的巨大字节数中。这样做是因为Node.js只能运行以utf-8编码的源文件。

JavaScript在内部存储使用utf-16编码的字符串，因此JavaScript中返回的字符串“字符长度”实际上只是utf-16编码的字符串的字节数的一半。

Python 2得分6 10

<sup>+3感谢披萨饼184
+ +1感谢WheatWizard</sup>

4/4
*2
-~0
+1
|5
^3
&776%6
and 8
if[]else[9][9>9]
.__xor__((""=="").__xor__((""=="")<<(""=="")))

在线尝试！

TI-Basic（83系列，操作系统版本1.15或更高版本），得分：17 18 19 24

（抢七局：53个字节。）

您可以像往常一样通过滥用字符串长度来获得非常高的分数：从头开始（如@Scrooble所指出的那样），并继续在末尾添加单令牌片段。TI-Basic有700多个，因此实际上效果很好。但是，这是另一种方法：length("A length("length(

int(log(11
2
3
4
5
6
7
8
9
0
Xmax
Ymax
nMax
abs(Xmin
Ymin
ππ
eee
³
²
₁₀^(₁₀^(X
+e^(⁻e^(Y))))
/√(sub(Z!
°
randrandrand

需要注意的是TI-基本标记化，所以（例如）的e^(命令不使用任何字符e，^，(。

依赖于该sub(命令的未记录功能：除了查找子字符串外，它还可用于将数字除以100。

这个作品，如果它在一个新的计算器，它可以让运行我们假设X，Y，Z均为零，该窗口变量设置为自己的标准值，该计算器在弧度模式，那rand第一个三路输出将在约0.943，0.908，0.146。

电源外壳，25字节，得分5

' '.count*2+!""-(-1)|%{5}

片段1：' '.count输出1。它通过取.count一个字符串的来做到这一点，因为只有一个字符串，所以它是一个。在线尝试！

片段2：*2输出，2因为我们采用1从上一个片段中提取并将其乘以2，然后在线尝试！

片段3：通过添加空字符串的Boolean-not +!""输出3。这会将空字符串隐式转换为$true，再次将其隐式转换为1，因此我们要添加一个在线尝试！

片段4：只需减去负数就可以-(-1)输出结果在线尝试！4

片段5：|%{5}输出5通过取前一个数字成回路，并且循环的每次迭代（只有一个，因为只有一个输入数字）输出5 网上试试吧！

感谢Jan提出了一种替代4的构想和巧妙的构想5。

C，10个摘要，45个字节

sizeof(char)              // sizeof(char) = 1
<<9/9                     // Multiply by two.
|1                        // 2 or 1 = 3
,4                        // Discard previous expression, return 4.
+!!8                      // Add one.
^3                        // 5 xor 3 = 6
&66                       // 3 and 66 = 2, 5 xor 2 = 7 (& has higher precedence)
??'0xF                    // Trigraph for '^'. 7 xor 15 = 8
-~-2                      // ~-2 = 1, 7 xor 14 = 9
*57%5                     // 1*57%5 = 2, 7 xor 13 = 10

在线尝试！

MATL，分数8 15 64个 123字节

rg             % 1 Random number, make boolean (1)
Q              % 2 Increment
Yq             % 3 Nth prime
a,E]           % 4 any (convert to boolean 1. Do twice: Multiply by 2
T+             % 5 Add True
F~_-           % 6 Subtract negative (not(false)) = 6-(-1)
:sI/           % 7 Range 1:6, sum (21), divide by 3
A8*            % 8 All elements (True). Multiply by 8
d9             % 9 Clear stack, push 9
x10            % 10 Clear stack, push 10
WBPf           % 11 Raise 2^10. Convert to binary [1 0 ... 0], flip [0 0 ... 1]. Find
23ZP           % 12 Push 23, and calculate the distance between 11 and 23
yyyyyyyyyyyyyyyyyyyyyyyyhhhhhhhhhhhhhhhhhhhhhhhhz  % 13. Duplicate and count elements
tttttttttttttvvvvvvvvvvvn  % 14 Duplicate and count elements
OOOOOOOOOOOOOON&           % 15 Add bunch of zeros, output size of stack

• 在路易斯·门多（Luis Mendo）的帮助下达到12岁！使用11,23ZP是他的想法，不断变化以及3与I用于片段7。
• 在路易斯提供的更多帮助下达到15。OO...N&是他的主意。

还有更多。我不了解MATL的功能，所以我不得不在文档中来回走动... :)

在线尝试！

V，得分10

é1
<C-a>
r3
DÉ4
ñóä/5ñ
ddá6
xÁ7
C8<esc>
R9<C-c>
ø.<cr>ÎA0

在线尝试！

果冻，253字节，得分250

L}“L

随后的1个字符的摘要：

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

注意：¶也可以替换为\n，它们与Jelly的代码页中的字节相同。

附加所有这些代码段后，即可添加2个字符的代码段”‘。

+1感谢 Dennis。

在线尝试！

语言，1 112 064片段

第n ^个代码段由^第2 ^个nn ^个非代理Unicode字符的^3n-1个重复组成，直到并包括第1 112 064 ^个当前Unicode标准的和最后一个非代理字符。

为简单起见，输出为一元（使用空字节作为数字）。十进制是可能的，但是它将使程序更长。使用一元制，我们可以测试第一个程序。

对于n = 1，我们得到4个重复的U + 0000。这等效于Brainfuck程序.，该打印一个空字节。

对于n = 2，我们得到U + 0001的32个重复，总共36个字符。这等效于Brainfuck程序，该程序打印两个空字节。..

对于n = 3，我们获得256次U + 0002重复，总共292个字符。这等效于Brainfuck程序...，该程序打印三个空字节。

依此类推，直到n = 1 112 064。

BASIC（ZX Spectrum）得分244（新得分247）[这是作弊吗？]

片段1：

2356 PRINT PEEK (PEEK 23635+256*PEEK 23636+2)+256*PEEK (PEEK 23635+256*PEEK 23636+3)-56-66

片段2： :

片段3： REM

片段4-244：单字符片段，使用不在片段1、2和3中的所有字符。

说明

性格

在Spectrum上，PRINT是一个字符（代码245）。该片段1只使用11个不同的角色：2，3，5，6，+，-，*，(，)，PRINT和PEEK你看到的是空间是字符的一部分PRINT和PEEK，因此空间本身并没有被使用。我决定给行号2356，因为这些是代码中出现的唯一数字。

不允许使用字符13和14。这意味着代码段2-244还剩243个字符，以开头:并REM避免了会产生错误或执行其他操作的代码。

怎么运行的

这就是为什么我不确定这个答案是否是本书所依据的原因。

23635是16位系统变量PROG的存储位置，存储为LH。（该值通常为23755。但是，如果不是这样的话，除了会导致错误的结果，直接使用该数字，即使它会缩短代码，也会花费我额外的数字字符。）PROG的值是内存位置程序本身存储的位置。前两个字节是存储为HL的行号，后两个字节是存储为LH的行的长度。这就是程序查找自己行长的方式，因此需要减去一些适当的值

保存字符

考虑到数字的存储方式，该行可能以-114结尾，因此代码段1会产生1。但是我不想使用多余的数字，所以我取走了两个2位数字，然后将它们加起来至122; 56和66表现不错。

该代码有点丑陋，所有嵌套和PEEK 23635+256*PEEK 23636两次计算PROG（）的值。但是，如果我存储它，然后使用存储的值，它将花费额外的字符/代码片段-该行可能会像

2356 LET p=PEEK 23635+256*PEEK 23636: PRINT PEEK (s+2)...

这将使用4个附加的字符：LET，p，=和:。

也许我会对此进行设计，以便所有数字都是从仅使用1位数字并获得3个摘要的数字计算得出的。

编辑：

这是新的代码段1（这是将长的单行换行显示在Spectrum上的方式，因此，如果您要测试代码，这将有助于您正确键入代码）：

1111 PRINT +PEEK (PEEK (11111+11
111+1111+(1+1+1)*(111-11)+1+1)+(
111+111+11+11+11+1)*PEEK (11111+
11111+1111+(1+1+1)*(111+1-11))+1
+1)+(111+111+11+11+11+1)*PEEK (P
EEK (11111+11111+1111+(1+1+1)*(1
11-11)+1+1)+(111+111+11+11+11+1)
*PEEK (11111+11111+1111+(1+1+1)*
(111+1-11))+1+1+1)-111-111-111-1
11-111-111

我可以避免使用+，从而获得另一个摘要-。我不会尝试，这是一个磨难。

Klein 011、9个摘要

片段1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

在线尝试！

片段2

2((2|bbb0b2bbbb4bbbbbbbb

在线尝试！

片段3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

在线尝试！

片段4

ddddddddddddddddddddddd>$d:d:++-$:+:+++$:?:-$-+++

在线尝试！

片段5

ee

在线尝试！

片段6

fff

在线尝试！

片段7

ggggg

在线尝试！

片段8

hh

在线尝试！

片段9

iiiii

在线尝试！

说明

对于克莱恩来说，这是一个非常有趣的挑战。克莱因（Klein）独特的拓扑结构可以完成很多有趣的事情。您可能会注意到答案5-9只是在代码中添加了填充符（字母在Klein中什么也不做，所以我将它们用作填充符）来扩展边界框。由于克莱因（Klein）独特的拓扑结构，这使得ip在代码的较早部分采用了不同的路径。

稍后我将进行完整的解释，但是现在这里是该程序更容易理解的版本，其中所有字母都用.s 代替。

!@1!...................../.2((2|...0.2....4........
.\*3.....................\.........3.6....9
.\.......................>$.:.:++-$:+:+++$:?:-$-+++.................

在线尝试！

> <>，得分：无限 1,112,064-6 = 1,112,058

片段1（6个字节）

"l4-n;

该代码段在;之后输出字符数；加一。可以将其扩展为无限大量的每个字符一个的片段。一个快速的谷歌告诉我，有1,112,064个可能的Unicode字符，减去我已经使用的6个。

尝试 它 在线

R，得分：79

归功于Sean的Perl答案；这滥用了R解释器的一些古怪之处。

第一个片段：

nchar(scan(,""))
a

后续片段是以下字符：

bdefgijklmopqtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@$%^&*_+|\[]{}:?><;

在线尝试！

该scan函数从""默认为的文件中读取数据stdin()。

的文档stdin()表明：

当R从文件中读取脚本时，该文件就是“控制台”：这是传统的用法，用于允许内联数据（例如，请参阅“ R简介”）。

因此，后续数据成为文件。这可以轻松扩展，并且可以使用多种不同的编码。

派克, 256 bytes, score 254

请注意，这些是实际字节的十六进制代码，用空格分隔，因为其中包含空字节（\x00）。

起始代码段：

6C 22 00

随后的1个字符的摘要：

01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

在这里尝试！

Java 8，7片段（19字节）

1
*2
-~0
>4?4:4
|5
^3
7%7

只是一个开始，将继续努力。

在这里尝试。

说明：

当添加括号时，执行优先级可能会变得更清晰：

((1*2)-~0)>4?4:4|(5^(37%7))

• a*b: Multiply a with b
• ~a: -a-1
• a>b?x:y: if(a>b){ x }else{ y }
• a|b: Bitwise-OR a with b
• a^b: Bitwise-XOR a with b
• a%b: a modulo-b

Python 2, 110 snippets

这是完整的代码段：

print((((len(open(__file__).read())-44.))))

#	 !"$%&'*+,/012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`bcghjkmqsuvwxyz{|}~

在线尝试！

第一个片段是

print((((len(open(__file__).read())-44.))))

接下来的109个摘要就是接下来的109个字节。

就像Lynn所说的那样，这很“疯狂”。第一个代码段打开文件并从其长度中减去44，然后每个其他代码段将文件长度加1，而不会改变程序的整体逻辑。因此输出结果增加了1。

dc，得分13，58字节

I3%                   #I is the default input radix, 10, mod 3 yields 1
1+                    #Add one
2^2^2^Z               #2^8=256, Z pushes the number of digits to the stack
6*v                   #Square root of 18 = ~4.24, at precision 0 we get 4
c5                    #Start getting lazy, clear the stack and push 5
_F-E-                 #Subtract negative 15, then subtract 14
ss7                   #Lazy, 'drop' the value by storing it, push 7
SS8                   #Lazy, 'drop' the value by storing it, push 8
d::9                  #Lazy, 'drop' the value by storing it, push 9
;;kA                  #Recall element 9 from nonexistant array ; which is zero, set precision, push A (10)
iB                    #Set input radix to 10, push B (11)
oD                    #Set output radix to 11, push D (13, or 12 in base 11)
 4CCCCCCr/4C/CC/4/    #We have division and the digits 4 and C left, this might not be the optimal way to get us to 13 but it does the job

在线尝试！（请注意，TIO版本f在每个代码段之后添加一个以打印整个堆栈，这表明每个代码段仅在堆栈上留下一个值；我也忘记了最后一个代码段上的前导空格，当它们在功能上无关紧要被换行符分开，但确实取决于我的角色使用情况）

Each additional snippet concatenation leaves the desired value and only the desired value on the stack. After hitting 12, I had kind of run out of ways to eat the stack. I tried to use math operations early on since they gobble up the stack and as we get into larger numbers it gets trickier to manage that way. When all is said and done, I have only the digit 0 left to play with and very little in the way of stack-popping, so I think 13 is pretty close to maxed out. I'm sure there are many similar (and likely shorter) ways of accomplishing this in dc, this just kind of fell into place. Note that cygwin handles A-F mixed in with 0-9 differently from most versions of dc, 44C4r/CC 4// works for the final snippet in cygwin.

Pyth, 124 snippets

l"x00x01x03x04x05x06x07x08
x0bx0c
x0ex0fx10x11x12x13x14x15x16x17x18x19x1ax1bx1cx1dx1ex1f !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkmnopqrstuvwxyz{|}~x7f

Try it online!

Unprintable characters where escaped using three printable characters (x..). The first snippet is three bytes long, every snippet after that grows in length by one.

Beatnik, 22 bytes, score 20

K A
E
I
L
N
O
R
S
T
U
a
e
i
l
n
o
r
s
t
u

Assuming the word "snippet" allows you to push the value on the stack.

Octave, Score 86

nnz n

Followed by:

!$&()*+./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxy{|}~

This exploits the fact that Octave treats everything after a function name as a string input. So nnz n returns the number of non-zero elements in the string 'n'. We get to 86 by adding the other printable ASCII-characters. ',"%# doesn't work.

APL (Dyalog), score 12

+1 score thanks to @dzaima

First to third snippets:

(~⍴⍬)
+≢'a'
,⍕1

Then each of 234567890.

Try it online!

Julia 0.6, 111217

The following script creates the full program:

A = "macro length(a);length(string(a))end;@length a"
B0 = join(([Char(x) for x in Iterators.flatten((0x000001:0x00d7ff, 0x00e000:0x10ffff)) if Base.isvalid(Char(x)) && Char(x) ∉ A && Base.isidentifier("a$(Char(x))") ]));
B = normalize_string(B0, stripmark=true, decompose=true);
B = join(unique(b for b in B))
while (n = search(B, '·')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end
while (n = search(B, '`')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end

open("concount.jl", "w") do f
    write(f, A)
    write(f, B)
end

Explanation

The macro

 macro length(a);length(string(a))
 end
 @length a

followed by all distinct unicode characters allowed in identifiers, computed with isidentifier. Some diacritial marks mess up counting so I removed them.

TeX，得分61（可能是190）

第一个片段：

\def\len#1{\expandafter\glen\string#1=}
\def\glen#1{\tlen}
\def\tlen#1{\if#1=\let\tlen\end\number\count1\else\advance\count1by1\fi\tlen}
\count1=-1
\catcode33=11
\catcode34=11
\catcode36=11
\catcode37=11
\catcode'46=11
\catcode40=11
\catcode41=11
\catcode42=11
\catcode43=11
\catcode44=11
\catcode45=11
\catcode46=11
\catcode47=11
\catcode56=11
\catcode57=11
\catcode'72=11
\catcode'73=11
\catcode60=11
\catcode62=11
\catcode63=11
\catcode64=11
\catcode'133=11
\catcode'135=11
\catcode'136=11
\catcode'137=11
\catcode'140=11
\catcode124=11
\catcode126=11
\len\t

其他60个摘要：按任意顺序，每个摘要中包含一个字符

!"$%&()*+,-./:;<>?@[]^_`|~89ABCDEFGHIJKLMNOPQRSTUVWXYZhjkqwz

说明：\len最后调用，将控制序列转换为字符串，每个字符（包括\）是该字符串的一个字符标记；然后\glen吞噬令牌\，然后\tlen计算剩余令牌。因此，它输出该控制序列的长度（不包括\).

来自其他片段的字符扩展了控制序列，该控制序列最初只是 \t。多字符控制序列必须仅由字母组成，但是它们都算作字母，因为它们都被分配了类别代码11（使用ASCII代码，因此字符本身不会出现在第一个代码段中）。

我决定将八进制代码用于某些花了我一个符号的字符，'但是为我节省了两个数字8和9，所以我得到了一个摘要。如果我不需要的话，也许还可以多得一分\expandafter。

输出量

可能的更改：包装\number\count1为，\message{}因此输出不会进入.dvi输出，而是控制台输出和.log。它不需要任何额外的字母。

190

不幸的是，TeX只能使用ASCII而不是Unicode（或者现在可以使用吗？），但是我的解决方案可能会扩展为包括更多129个单字符代码段，其中包含代码为127-255的字符。甚至32号之前的某些字符都不能使用。32号字符（空格）不起作用，否则我也将其放入一个代码段中-不需要在第一个代码段中使用它。当然，这些附加字符中的每个字符都必须\catcode在第一个代码段中输入字母。

点子，57字节，分数= 16

!u
2
RT9
#m
5
(EX3Y8)
7
y
A'<tab>
t
11
+o
-v
PI@`\...`@`..$`
"F"FB:4*4
Ok=k6

请注意，它<tab>代表文字的制表符（ASCII 9）。在线尝试！

每个代码段都是一个完整的程序，可以输出所需的数字。它们中的大多数都基于自动打印Pip程序中的最后一个表达式的原则：例如，在代码段5中，对前一个代码进行了评估，但是唯一重要的部分是5。例外情况是：

• 片段3可以单独作为RT9（9的平方根）很好地工作，但是在片段2之后，它实际上解析为2RT9（9的第二根）-当然，这是相同的。
• 代码段6获得e ^ 3的第8个字符（0索引），恰好是6。但是它也将数字8插入y变量中。然后，代码段8输出的值y。
• 片段12从上一个片段中获取11并添加 o (preinitialized to 1). Snippet 13 takes that result and subtracts v (preinitialized to -1).
• 片段16输出时1不带换行符（Ok=k其中k=k的真值默认值为1），然后自动打印6。

其他有趣的东西：

• 片段14使用正则表达式操作来提取 14 from the value of pi.
• 片段15将字符串"F"从十六进制转换。

Zsh, score >50 000 (1 112 046?), 16 + Σ(UTF-8 codepoint lengths) bytes

exec echo   $((${#:-$(<$0)}-33))
#

Zsh handles multibyte encodings by default. The base snippet has 18 unique characters, 34 total. Every other codepoint (save for the null byte) can be added onto this. As I write this, my script testing these is on codepoint ~50 000, total file size 150K, going at about 30 snippets/second. Run my full test script yourself here. You may want to adjust it to start at some later codepoints.

Try the first 2000 snippets online!

More snippets are possible by using this technique.