输出是包围1009像素的形状。

• 形状必须采用单个，闭合，不相交的环的形式。

输入是一个正的非零整数。

• 每个输入必须产生唯一的输出-也就是说，每个输出必须与使用较低输入生成的输出唯一。

胜利取决于最大的输入限制：

• 您提交内容的输入限制被认为比提供非唯一或无效输出的最低输入少1。
• 例如，如果为输入1、2或3而不是4产生有效且唯一的输出，则您的输入限制为3。

源代码限制为1009字节。如果有平局，则字节数最少的条目获胜。

限制和说明：

• 形状的最大尺寸为109 x 109像素。大小包括用于绘制形状的线。
• 一条线是恒定的宽度。
• 封闭的空间必须完全由线条封闭-您不能使用图像文件的边界。
• 封闭的1009像素仅指封闭的空间。它不包括该行。
• 输出是图像。
• 没有其他图形限制-例如颜色，线条粗细等。
• 输出的唯一性仅指封闭的空间。如果封闭的空间不是唯一的，则线的更改或其他图形更改将是无关紧要的。
• 形状的转换并非唯一。旋转，反射和任何其他变换算作唯一的。
• 输出必须可重现-相同的输入将始终提供相同的输出
• 输出之间不需要有关系，连续的或其他的关系。
• 在提交的“输入限制”之外，没有定义的输出。
• 不允许其他输入或获取外部数据。
• 一条线必须是连续的，即像素必须接触（接触角点计数）。
• 像素是您的绘图方法使用的“绘图”的最小单位，不一定与屏幕像素相对应。

例子：

• 这是有效形状的示例：

  

• 以下形状无效：

  

编辑：线接触：

• 封闭空间必须是连续的，定义为像素接触。触角至关重要。

• 线不能在其外侧封闭任何空间。@Sparr发布的这张图片说明了这一点-仅每行的第一个形状有效：

  

• 线的外侧可以接触，但不能以包围空间的方式接触。

• 触摸线可能不会重叠-例如，两条触摸1像素粗的线的总厚度为2px，从不为1px。

Python + Pycairo，2 ^100种形状

让我们从显而易见的地方开始。

from cairo import *
from sys import argv

n = int(argv[1]) - 1

s = ImageSurface(FORMAT_ARGB32, 109, 109); c = Context(s)
c.set_antialias(ANTIALIAS_NONE); c.set_line_width(1); c.translate(54, 54)
def pixel(x, y): c.rectangle(x, y, 1, 1); c.fill()

W, H, R = 100, 10, 9
X1, Y1 = -W / 2 - 1, -H / 2 - 1
X2, Y2 = X1 + W + 1, Y1 + H + 1

pixel(X2 - 1, Y1)
c.move_to(X1, Y1 + 1); c.line_to(X1, Y2 + 1)
c.move_to(X2 + 1, Y1); c.line_to(X2 + 1, Y1 + R + 1);
c.move_to(X2, Y1 + R + 1); c.line_to(X2, Y2 + 1)
c.stroke()

for i in xrange(W):
    offset = (n >> i) & 1
    for y in Y1, Y2: pixel(X1 + i, y + offset)

s.write_to_png("o.png")

在命令行上获取数字并写入o.png。

BBC基础版，得分10 ^ 288（如果未计零，则减-1）

在http://sourceforge.net/projects/napoleonbrandy/下载解释器（不是我通常的BBC基本解释器，因为它不支持足够长的字符串。）

要编码很多信息，您需要很多周边。那意味着薄的形状。我从左侧的49像素的垂直条开始，然后向其添加10个96像素的触手。每个触手可以以类似于@ell的解决方案的方式编码96位，总共960位。

由于BBC Basic无法处理那么大的数字，因此最多将288个十进制数字作为字符串输入，并且每组3个十进制数字将转换为10位二进制数。然后，如果每个位是a，则将每个触角向上摆动一个像素1（但如果是a，则不翻转0）。该程序最多可以处理288/3 = 96这样的3位数字集

    1MODE1:VDU19,0,7;0;19,15,0;0;               :REM select an appropriate screen mode and change to black drawing on white background
   10INPUT a$
   20a$=STRING$(288-LEN(a$)," ")+a$             :REM pad input up to 288 characters with leading spaces
   50RECTANGLE0,0,8,200                         :REM draw a rectangle at the left, enclosing 49 pixels
   60FOR n=0 TO 95
   70  b=VAL(MID$(a$,n*3+1,3))                  :REM extract 3 characters from a$ and convert to number
   80  FOR m=0 TO 9                             :REM plot the ten tentacles
   90    PLOT71,n*4+8,m*20+8+(b/2^m AND 1)*4    :REM plot (absolute coordinates) a background colour pixel for tentacle m at horizontal distance n
  100    POINT BY 0,-4                          :REM offsetting vertically by 1 pixel according to the relevant bit of b
  110    POINT BY 4,4
  120    POINT BY -4,4                          :REM then plot foreground colour pixels (relative coordinates) above, below and to the right.
  130  NEXT
  140NEXT

输出量

288位数字的典型输出。注意999是二进制的1111100111。您可以看到这组9位数字如何使触手起伏。

技术性

答：对马丁第3点的回答是：“如果仅在一个角上触摸像素，该形状是否连通？” 是“是”，因此我理解我的回答符合要求。但是，如果在每行中交替显示（例如）999和000，则看起来非常忙。

B.如果我们将其视为矩形，侧面有咬痕，可以看到我在每对相邻的触角之间留出了三个像素，以确保围绕外部的黑线永远不会触及自己。对此没有具体规定（我希望我的回答更清楚我的询问的理由。）如果允许线条在形状的外侧触碰自己，我可以将触角移动到一起，并使用更少的像素竖线（这样会使触角更长一些。）但是，用肉眼确定像素是在形状的内部还是外部会变得非常混乱，因此我认为我的解释是黑线的外部永远不应该接触本身就是最好的。

C. BBC basic在此屏幕模式下将2x2平方的屏幕像素视为单个像素。我将其保留为原样，因为如果形状不太小，它可以帮助查看。这些BBC基本像素中的每个像素都被视为4x4逻辑单元的盒子。从一开始，BBC基础版的开发人员就具有远见卓识，意识到一天的屏幕分辨率会提高，因此他们使逻辑分辨率高于物理分辨率。

Mathematica，496个字节，得分：大型（> 1157）

我到达那里的下限低得离谱，但我还没有找到一种比蛮力检查更好的方法。

SeedRandom@Input[];
g = 0 &~Array~{109, 109};
g[[2, 2]] = 1;
h = {{2, 2}};
For[n = 1, n < 1009,
  c = RandomChoice@h;
  d = RandomChoice[m = {{1, 0}, {0, 1}}];
  If[FreeQ[e = c + d, 1 | 109] && 
    Count[g[[2 ;; e[[1]], 2 ;; e[[2]]]], 0, 2] == 1,
   ++n;
   h~AppendTo~e;
   g[[## & @@ e]] = 1
   ];
  ];
(
    c = #;
    If[e = c + #; g[[## & @@ e]] < 1,
       g[[## & @@ e]] = 2
       ] & /@ Join @@ {m, -m}) & /@ h;
ArrayPlot[g, ImageSize -> 109, PixelConstrained -> True, 
 Frame -> 0 > 1]

我还没有打高尔夫球，因为没有必要。一旦有人证明他们确实在和我联系，我就会这样做。

该算法基本上是从109x109图像的左上角开始填充（偏移一个像素以允许该行），并且当我填充1009个单元格时，我会停止并标记边框。您说颜色取决于我们，因此背景是白色，线条是黑色，内部是灰色（如有必要，我可以去除一些字符的灰色）。

洪水填充受到很大限制，但这确保了我不必担心孔洞。放宽这些限制可能会极大地提高我（至今未知）的分数。

现在，我将尝试在分数上设置一些下限。

Python 2，得分> 10 ^ 395

这非常慢，除了n = 0之外，我实际上没有得到任何其他结果，但是如果您要测试它SIZE（像素数）和BOUND边界正方形的最大边长较低，则应该能够得到很多结果。很难计算出它会产生多少。我相当有信心我给出的下限是准确的，但是我怀疑实际计数会大大增加，我可能会在以后尝试对其进行改进。

import sys
import pygame
sys.setrecursionlimit(1100)

def low(s):
    return min(sum(e[1] for e in s[:i+1]) for i in range(len(s)))
def high(s):
    return max(sum(e[1] for e in s[:i+1])+s[i][0] for i in range(len(s)))

BOUND = 109
SIZE = 1009

def gen(n,t=0):
    if n <= (BOUND-t)*BOUND:
        for i in range(1,min(n,BOUND)):
            for r in gen(n-i,t+1):
                a,b=r[0]
                for x in range(max(1-a,high(r)-low(r)-BOUND),i):
                    yield [(i,0),(a,x)]+r[1:]
        yield [(n,0)]

def create(n):
    g=gen(SIZE)
    for i in range(n+1):shape=g.next()
    s=pygame.Surface((BOUND+2,BOUND+2))
    l=low(shape);x=0
    for y,(t,o) in enumerate(shape):
        x+=o;pygame.draw.line(s,(255,255,255),(x-l+1,y+1),(x-l+t,y+1))
    out=[]
    for x in range(BOUND+2):
        for y in range(BOUND+2):
            if all((0,0,0)==s.get_at((x+dx,y+dy))for dx,dy in[(-1,0),(1,0),(0,-1),(0,1)]if 0<=x+dx<BOUND+2 and 0<=y+dy<BOUND+2):
                out.append((x,y))
    for x,y in out:
        s.set_at((x,y),(255,255,255))
    pygame.image.save(s,"image.png")