任何人都可以通过添加字符来使程序的输出变大，所以让我们做相反的事情。

使用您选择的语言满足以下条件，为REPL环境编写完整的程序，内部函数或代码段：

1. 您的代码必须至少包含1个字符。

2. 运行原始代码会生成x个字符输出到STDOUT（或最接近的替代字符），其中0≤x <+∞。

3. 从原始代码中删除任何任意单个字符都会再次产生有效代码，该代码至少会产生x + 1个字符输出到STDOUT。

4. 原始代码或修改都不会产生任何错误输出，无论输出到STDOUT，STDERR，syslog还是其他地方。该规则的唯一例外是编译器警告。

   您的程序可能不需要任何标志或设置来抑制错误输出。

   您的程序可能不会包含任何致命错误，即使它们不会产生任何输出。

5. 原始代码和修改都必须是确定性的，并最终完成（没有无限循环）。

6. 原始代码或修改都可能不需要任何形式的输入。

7. 函数或代码段在两次执行之间可能不会保持任何状态。

考虑到该任务对于某些语言而言是微不足道的，而对于另一些语言而言则是彻头彻尾的，所以这是一场流行竞赛。

投票时，请考虑代码的“相对简短”，即与相同语言下的较长答案相比，较短的答案应被认为更具创造力。

任何带有插入符XOR操作的REPL，5个字节

11^11

11^11当然是0。唯一的其他可能性是1^11或或11^1为10，或1111产生自身。

TI-BASIC，3 1

"

当程序的最后一行是表达式时，计算器将显示该表达式。否则，Done程序结束时将显示计算器。此处的表达式是空字符串，但也可以使用任何一位数字。

2个字节：

isClockOn

与上述相同，但带有2字节令牌。

3个字节：

ππ⁻¹

1由于隐式乘法打印。可以通过添加的对无限期扩展⁻¹。下面也可以。

√(25
e^(πi
⁻ii
ii³
2ππ   
cos(2π

更长的解决方案：

11/77►Frac
ᴇ⁻⁻44
cos(208341   //numerator of a convergent to pi; prints "-1"

也可能有多行解决方案，但我找不到。

CJam，JavaScript，Python等18字节

8.8888888888888888

CJam中的输出为：

8.8888888888888888 -> 8.88888888888889
8.888888888888888  -> 8.888888888888888
88888888888888888  -> 88888888888888888
.8888888888888888  -> 0.8888888888888888

JavaScript和Python以相似的方式工作。它在JavaScript和Python中没有竞争力，但是在CJam中找到较短的代码并不容易。

八度，5字节

10:10

（x：y）以1为增量给出x和y之间的数字数组，因此在10和10之间的唯一元素是10：

> 10:10
ans = 10

当第二个参数小于第一个参数时，octave打印空矩阵及其维数：

> 10:1
ans = [](1x0)

> 10:0
ans = [](1x0)

从第一个数字中删除字符后，数组中将包含更多元素：

> 1:10
ans = 1 2 3 4 5 6 7 8 9 10

> 0:10
ans = 0 1 2 3 4 5 6 7 8 9 10

删除冒号后，数字将返回：

> 1010
ans = 1010

Microscript，1个字节

h

这不会产生输出，因为可以h抑制语言的隐式打印。删除唯一字符将生成一个输出为的程序0\n。

稍后，我将尝试提供一个更好的答案。

11月17日编辑：

这也可以在Microscript II中使用，不同之处在于，0\n空程序产生而不是产生，而不是产生null。

Pyth，3个字节

cGG

G用字母中的小写字母预先初始化。c是拆分功能。

cGG按字母的出现来拆分字母，该字母以['', '']（8个字节）结尾。

当缺少第二个参数时，c按空格，制表符或换行符分隔字符串。因为其中没有出现在G，输出为cG是['abcdefghijklmnopqrstuvwxyz']（30个字节）。

并且GG只需在两个单独的行上打印两次字母表：abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz（53个字节）。

在线尝试：演示

Python REPL，6个字节

不是最短的，但这是另一个浮点滥用答案：

>>> 1e308
1e+308
>>> 11308
11308
>>> 11e08
1100000000.0
>>> 11e38
1.1e+39
>>> 11e30
1.1e+31

但...

>>> 11e308
inf

JavaScript（还有更多），5byte

44/44 要么

44/44 -> 1
44/4  -> 11
4444  -> 4444
4/44  -> 0.09090909090909091

果酱，5

''''=

在线尝试

''''=   compares two apostrophes and prints 1
'''=    prints '=
''''    prints ''

语言，5字节

00000

程序的长度为5，对应于brainf ***程序,读取输入字符的结尾并终止而不输出。

删除任何char都会导致0000长度为4 的代码对应于brainf ***程序.打印出一个字符（codepoint 0）并终止。

在一元相当于是0000000000000（13个零），因为你必须在前面加上一个领先1到的代码，使二进制长度101变1101。

PHP，6个字节

我已经看了这个小组几个星期了，对您的编程技术感到惊讶。现在我必须登录，有什么我可以做的，对不起:-)但是，这可能是我在这里的最后一篇文章...

<?php 

（注意第二个空格p）

这将输出空字符串。删除任何字符都会输出不带该字符的文本。请注意，它可能会产生HTML错误（浏览器无法呈现例如的内容<?ph）。

我也尝试过使用echo标签。即。例如。：

<?= __LINE__;;

这个输出1。如果=省略，<? __LINE__;;则为输出。但是，删除任何魔术常数字符将导致E_NOTICE：注意：使用未定义的常数LNE-在...中假定为' LNE '

如果通知不被认为是错误（规则的第4点），则这也适用:-)

Python，10 8个字节

256**.25

适用于Python和朋友。感谢Jakube展示了如何使其缩小2个字节。

从IDLE：

>>> 256**.25
4.0
>>> 26**.25
2.2581008643532257
>>> 56**.25
2.7355647997347607
>>> 25**.25
2.23606797749979
>>> 256*.25
64.0
>>> 256*.25
64.0
>>> 256**25
1606938044258990275541962092341162602522202993782792835301376L
>>> 256**.5
16.0
>>> 256**.2
3.0314331330207964

最初我有这个（10个字节）：

14641**.25

从IDLE：

>>> 14641**.25
11.0
>>> 4641**.25
8.253780062553423
>>> 1641**.25
6.364688382085818
>>> 1441**.25
6.161209766937384
>>> 1461**.25
6.18247763499657
>>> 1464**.25
6.185648950548194
>>> 14641*.25
3660.25
>>> 14641*.25
3660.25
>>> 14641**25
137806123398222701841183371720896367762643312000384664331464775521549852095523076769401159497458526446001L
>>> 14641**.5
121.0
>>> 14641**.2
6.809483127522302

并在同一说明上：

121**.25*121**.25

由于Python很好地舍入了17个字节，因此其工作原理相同。

>>> 121**.25*121**.25
11.0
>>> 21**.25*121**.25
7.099882579628641
>>> 11**.25*121**.25
6.0401053545372365
>>> 12**.25*121**.25
6.172934291446435
>>> 121*.25*121**.25
100.32789990825084
>>> 121*.25*121**.25
100.32789990825084
>>> 121**25*121**.25
3.8934141282176105e+52
>>> 121**.5*121**.25
36.4828726939094
>>> 121**.2*121**.25
8.654727864164496
>>> 121**.25121**.25
29.821567222277217
>>> 121**.25*21**.25
7.099882579628641
>>> 121**.25*11**.25
6.0401053545372365
>>> 121**.25*12**.25
6.172934291446435
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121**25
3.8934141282176105e+52
>>> 121**.25*121**.5
36.4828726939094
>>> 121**.25*121**.2
8.654727864164496

SWI-Prolog解释器

__A=__A.

注意：您不能删除最终版本.。Prolog解释器将始终寻找最后一个时段来运行您的查询，因此，如果我们严格遵守此竞赛的规则并允许我们自己删除将不会运行的时段，它将跳过一行并等待其他命令，直到出现一个以句号结束。

原始查询__A=__A.输出true.。

查询_A=__A.输出_A = '$VAR'('__A')。类似的修改（即删除_两者之一或其中之一A）将产生相似的输出。

最后，查询__A__A.在SWI-Prolog中输出：

% ... 1,000,000 ............ 10,000,000 years later
% 
%       >> 42 << (last release gives the question)

sed，1个字节

d

根据sed需要的输入流，我将提出一个约定，程序本身应作为输入提供。

$ sed -e 'd' <<<'d' | wc -c
0
$ sed -e '' <<<'d' | wc -c
2

一种替代方案是x，但只有来自改变1到2删除时输出的字节。

K，3个字节

2!2

0REPL中的输出。删除前2个输出0 1，删除感叹号结果22，然后删除最后2个结果，导致一个字符串在K个实现之间有所不同，但始终至少为2个字符（(2!)根据@Dennis，按@Dennis，Kona输出2!）。

MATLAB，9 7字节

它比其他MATLAB / Octave答案长2个字节，但我还是喜欢它，因为它有点复杂。

Matlab的'运算符是复共轭转置。在标量虚数上使用它，得到i' = -i。由于虚数可以简单地写成2i：

2i--2i'
ans =
     0    

删除任何一个字符将导致以下情况之一：

ans =
   0.0000 - 1.0000i
   2.0000 - 2.0000i
   0.0000 + 4.0000i
   0.0000 + 4.0000i
   0.0000 + 1.0000i
   2.0000 + 2.0000i
   0.0000 + 4.0000i

GolfScript，2个字节

这个答案是非竞争性的，但是由于正是这段代码激发了这一挑战，所以我还是想分享它。

:n

默认情况下，所有GolfScript程序都会通过puts在整个堆栈上执行打印整个堆栈，然后打印换行符。该函数puts本身是{print n print}在解释器中实现的，其中print是实际的内置函数，并且n是"\n"默认情况下包含字符串的变量。

现在，GolfScript程序始终将来自STDIN的输入推入堆栈。在这种情况下，由于没有任何输入，因此将推送一个空字符串。变量赋值:n将空字符串保存到中n，从而消除隐式换行符并使输出完全为空。

通过消除n，您将剩下不完整的变量赋值:（您会认为这是一个语法错误，但不是），因此隐式换行符照常打印。

消除后:，剩下的是n，它可以将换行符压入堆栈，因此程序将打印两个换行符。

APL，J和其他可能的变体，3字节

--1

它1以APL 输出。-1输出¯1，并--在TryAPL中输出以下内容：

┌┴┐
- -

J，5个字节

|5j12

5 + 12iREPL中复数的大小。

   |5j12 NB. original, magnitude of the complex number `5 + 12i`
13
   5j12  NB. the complex number `5 + 12i`
5j12
   |j12  NB. magnitude of the undefined function j12
| j12
   |512  NB. magnitude of 512
512
   |5j2  NB. magnitude of 5 + 2i
5.38516
   |5j1  NB. magnitude of 5 + 1i
5.09902

。

J，9个字节

%0.333333

基于浮点精度，倒数和矩阵逆。

   %0.333333 NB. original, reciprocal of 0.333333
3
   0.333333  NB. 0.333333
0.333333
   %.333333  NB. matrix inverse of 333333
3e_6
   %0333333  NB. reciprocal of 333333
3e_6
   %0.33333  NB. reciprocal of 0.33333
3.00003

在这里在线尝试。

Mathematica，3个字节

4!0

4!0  ->  0    the factorial of 4, times 0
4!   ->  24   the factorial of 4
40   ->  40
!0   ->  !0   the logical not of 0, but 0 is not a boolean value

Dyalog APL，2个字节

⍴0 返回一个空字符串（长度为0）

⍴返回⍴（长度1）

0返回0（长度1）

Swift（还有更多），8个字节

93^99<84

输出（4个字符）：

true

删除第n个字符时，输出为：

n -> out
----------
0 -> false
1 -> false
2 -> false
3 -> false
4 -> false
5 -> 10077
6 -> false
7 -> false

有78种可能的解决方案，格式为a^b<c。

我认为此挑战的目标应该是尽可能多的字节，因为字节越多，要删除的字节越多，因此就越困难。

MathGolf，2个字节

♂(

在线尝试！

说明

♂   Push 10
 (  Decrement TOS by 1

为什么这样做？

常规输出为9。如果将(删除，则输出为10。如果将♂删除，则程序会从堆栈中隐式弹出一个0以馈给(运算符，该运算符输出-1。

Clojure，11个字节

(defn x[]1)

一开始我想像其他语言一样在REPL中发布单个字符答案，例如

user=> 1
1

但是问题是，如果删除了该字符，则REPL在按下Enter键时不会执行任何操作。因此，它必须包装有问题规则所允许的功能。调用此函数时，它将返回1。如果删除函数中的唯一字符，

(defn x[])

该函数返回nil，并打印出另外两个字节。

user=> (defn x[]1)
#'user/x
user=> (x)
1
user=> (defn y[])
#'user/y
user=> (y)
nil

05AB1E（旧版），1 个字节

05AB1E（旧版）中的任何单个字节都可以工作，但[（无限循环）除外。

对于所有可能的单字节05AB1E程序，请参见此处的所有可能的输出。

删除该单个字节以便保留一个空程序，默认情况下会将info.txt的内容输出到STDOUT。

在线尝试。

05AB1E，1 个字节

?

在线尝试。

不幸的是，新版本的05AB1E中的空程序默认情况下仅输出1字节的换行符（在线尝试），因此几乎没有1字节的字符是可能的，因为它们不必输出任何内容。?据我所知，唯一不输出任何内容的程序（因此也不包含隐式换行符）。

Japt，2个字节

AÉ

在线尝试！

A预先初始化为10，然后É减去1，结果为1个字节：9。

删除É将在程序A中输出A的值10，因此结果为2个字节。

同样，删除A会得到的结果恰好É被解释为-1并输出为-1，因此结果为2个字节。

符文符文，6个（可更改）字节

11-{{B\
/B~~@/
\00<
R"Error"@

在线尝试！

符文没有REPL环境，编写完整的程序以满足约束并不容易（导致程序无效或无输出）。因此，代码的一部分11-{{B充当了内部函数，只有这部分可以修改。该B指令距离函数指针和return语句足够近，因此该分类应该是可以接受的（因为它将IP跳转到代码中的某个位置，并将返回位置压入堆栈，该堆栈可被后续访问B或丢弃） 。

• 标准输出： 0
• 删除任何一个1：05
• 删除-：11
• 删除{：Error051
• 删除B：120

如果\删除返回指令，则第一行末尾的最终内容将围绕内部函数提供一个外部边界，以使IP不会到处乱走（并且不输出任何输出）。

请注意，这Error051只是一个任意字符串，我可以将所需的任何内容放入代码的那部分，而“错误”是一个令人讨厌的结果，因为该代码具有使返回坐标变短并将IP传送到任意位置的代码。