Saída é uma forma que inclui 1009 pixels.

• A forma deve assumir a forma de um loop único, fechado e sem interseção.

A entrada é um número inteiro positivo diferente de zero.

• Cada entrada deve produzir uma saída única - ou seja, cada saída deve ser única daquelas geradas usando uma entrada mais baixa.

A vitória é decidida pelo maior limite de entrada:

• O limite de entrada do seu envio é considerado 1 menor que a entrada mais baixa que fornece saída não exclusiva ou inválida.
• Por exemplo, se uma saída válida e exclusiva for produzida para uma entrada de 1, 2 ou 3, mas não 4, seu limite de entrada será 3.

Há um limite de 1009 bytes no código fonte. Se houver um empate, a entrada com o menor número de bytes vence.

Restrições e esclarecimentos:

• O tamanho máximo de uma forma é 109 por 109 pixels. Tamanho inclui a linha usada para desenhar a forma.
• Uma linha tem largura constante.
• O espaço delimitado deve ser totalmente delimitado pela linha - você não pode usar o limite do arquivo de imagem.
• Os 1009 pixels fechados referem-se apenas ao espaço fechado. Não inclui a linha.
• Saída é uma imagem.
• Não há mais restrições gráficas - por exemplo, cor, espessura da linha etc.
• A exclusividade de uma saída refere-se apenas ao espaço fechado. Alterações na linha ou outras alterações gráficas são irrelevantes se o espaço fechado não for exclusivo.
• Uma tradução da forma não é única. Rotações, reflexões e outras transformações contam como únicas.
• A saída deve ser reproduzível - a mesma entrada sempre dará a mesma saída
• Não precisa haver uma relação entre saídas, consecutivas ou não.
• Fora do 'limite de entrada' de um envio, não há saída definida.
• Nenhuma outra entrada ou busca de dados externos é permitida.
• Uma linha deve ser contínua - ou seja, os pixels devem tocar (tocar em um canto conta).
• Um pixel é a menor unidade de 'desenho' usada pelo seu método de desenho e não corresponde necessariamente a um pixel da tela.

Exemplos:

• Aqui está um exemplo de uma forma válida:

  

• As seguintes formas são inválidas:

  

EDIT: Linha tocando:

• O espaço fechado deve ser contínuo, definido como pixels tocando. Cantos tocantes contam.

• Uma linha não pode colocar nenhum espaço em seu lado externo. Esta imagem postada por @Sparr ilustra este ponto - somente a primeira forma em cada linha é válida:

  

• Os lados externos de uma linha podem tocar, mas não de maneira a envolver o espaço.

• As linhas tocantes podem não se sobrepor - por exemplo, duas linhas grossas com 1 pixel de espessura teriam uma espessura combinada de 2 px, nunca 1 px.

Python + Pycairo, 2 ¹⁰⁰ formas

Vamos começar com o óbvio.

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")

Pega o número na linha de comando e grava o.png.

BBC Basic, pontuação 10 ^ 288 (menos 1 se zero não for contado)

Faça o download do interepreter em http://sourceforge.net/projects/napoleonbrandy/ (não é meu intérprete básico da BBC habitual, que não suporta seqüências de caracteres longas o suficiente).

Para codificar muita informação, você precisa de muito perímetro. Isso significa uma forma fina. Começo com uma barra vertical de 49 pixels à esquerda e adiciono dez tentáculos de 96 pixels a ela. Cada tentáculo pode codificar 96 bits de maneira semelhante à solução da @ ell, um total de 960 bits.

Como o BBC Basic não pode manipular números tão grandes, um número de até 288 dígitos decimais é inserido como uma string e cada conjunto de três dígitos decimais é convertido em um número binário de 10 bits. Cada bit é então usado para mover um dos tentáculos para cima em um pixel, se for um 1(mas não se for um 0). O programa pode lidar com até 288/3 = 96 conjuntos de 3 dígitos

    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

Saída

Uma saída típica para um número de 288 dígitos. Observe que 999 é 1111100111 em binário. Você pode ver como os conjuntos de 9 dígitos causam ondulações nos tentáculos.

Technicalities

A. A resposta ao ponto 3 de Martin "é a forma conectada se o pixel tocar apenas em um canto?" foi "sim", então eu entendo que minha resposta está em conformidade. No entanto, se você alternar (por exemplo) 999 e 000 em todas as linhas, parece muito ocupado.

B. Se vemos isso como um retângulo com mordidas retiradas do lado, você pode ver que eu permiti três pixels entre cada par de tentáculos adjacentes, para garantir que a linha preta em volta do lado de fora nunca se toque. Não existe uma regra específica sobre isso (espero que minha razão para perguntar seja mais clara à luz da minha resposta.) Se a linha puder tocar-se no lado de fora da forma, eu poderia mover os tentáculos juntos e usar menos pixels para a barra vertical (e, portanto, torna os tentáculos um pouco mais longos.) Seria, no entanto, muito confuso determinar a olho se um pixel estava dentro ou fora da forma, então acho que minha interpretação de que o exterior da linha preta nunca deve tocar em si é o melhor.

C. A BBC básica neste modo de tela trata um quadrado de 2 x 2 de pixels da tela como um único pixel. Deixei como está, porque ajuda a ver se a forma não é muito pequena. Cada um desses pixels básicos da BBC é considerado como uma caixa de unidades lógicas 4x4. Desde o início, os desenvolvedores da BBC Basic tiveram a previsão de perceber que um dia as resoluções de tela aumentariam, por isso aumentaram a resolução lógica que a resolução física.

Mathematica, 496 bytes, Pontuação: ish grande (> 1157)

O limite inferior que eu tenho lá é ridiculamente baixo, mas ainda não encontrei uma maneira melhor do que a força bruta para verificar.

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]

Ainda não joguei isso porque não havia necessidade. Farei isso quando alguém provar que está realmente se amarrando comigo.

O algoritmo está basicamente fazendo um preenchimento no canto superior esquerdo da imagem de 109x109 (deslocamento de um pixel para permitir a linha) e, quando inundamos 1009 células, paro e marquei a borda. Você disse que as cores são nossas, então o fundo é branco, a linha é preta e o interior é cinza (posso remover o cinza para alguns caracteres, se necessário).

O preenchimento da inundação é bastante restrito, mas isso garante que eu não precise me preocupar com buracos. Relaxar essas restrições provavelmente aumentará dramaticamente minha pontuação (ainda desconhecida).

Vou tentar estabelecer limites mais baixos agora.

Python 2, Pontuação> 10 ^ 395

É extremamente lento, e na verdade não consegui obter nenhum resultado além de n = 0, mas se você quiser testá-lo mais baixo SIZE(o número de pixels) e BOUNDo comprimento máximo do lado do quadrado delimitador, você poderá para obter muitos resultados. Era muito difícil tentar calcular quantos produziria; Estou bastante confiante de que o limite inferior que eu dou é preciso, mas suspeito que a contagem real seja significativamente maior e posso tentar melhorá-la mais tarde.

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")