L'output è una forma che racchiude 1009 pixel.

• La forma deve assumere la forma di un singolo loop chiuso e non intersecante.

L'input è un numero intero positivo diverso da zero.

• Ogni input deve produrre un output univoco, ovvero ogni output deve essere univoco rispetto a quelli generati utilizzando un input inferiore.

La vittoria è decisa dal limite di input più grande:

• Il limite di input del tuo invio è considerato 1 in meno dell'input più basso che fornisce output non univoci o comunque non validi.
• Ad esempio, se viene prodotto un output valido e unico per un input di 1, 2 o 3 ma non 4, il limite di input è 3.

C'è un limite di 1009 byte sul codice sorgente. Se c'è un pareggio, vince la voce con il minor numero di byte.

Restrizioni e chiarimenti:

• La dimensione massima di una forma è 109 per 109 pixel. La dimensione include la linea utilizzata per disegnare la forma.
• Una linea ha larghezza costante.
• Lo spazio racchiuso deve essere interamente racchiuso dalla linea: non è possibile utilizzare il limite del file di immagine.
• I 1009 pixel racchiusi si riferiscono solo allo spazio chiuso. Non include la linea.
• L'output è un'immagine.
• Non ci sono ulteriori restrizioni grafiche - ad es. Su colore, spessore della linea ecc.
• L'unicità di un'uscita si riferisce solo allo spazio racchiuso. Le modifiche alla linea o altre modifiche grafiche sono irrilevanti se lo spazio racchiuso non è univoco.
• Una traduzione di forma non è unica. Rotazioni, riflessioni e qualsiasi altra trasformazione valgono come uniche.
• L'output deve essere riproducibile: lo stesso input fornirà sempre lo stesso output
• Non è necessario che vi sia una relazione tra output, consecutivi o meno.
• Al di fuori del "limite di input" di un invio non esiste un output definito.
• Nessun altro input o recupero di dati esterni è consentito.
• Una linea deve essere continua, ovvero i pixel devono toccarsi (toccando un conteggio degli angoli).
• Un pixel è la più piccola unità di "disegno" utilizzata dal metodo di disegno e non corrisponde necessariamente a un pixel dello schermo.

Esempi:

• Ecco un esempio di una forma valida:

  

• Le seguenti forme non sono valide:

  

EDIT: linea toccando:

• Lo spazio chiuso deve essere continuo, definito come pixel toccanti. Toccare gli angoli conta.

• Una linea non può racchiudere alcuno spazio sul suo lato esterno. Questa immagine pubblicata da @Sparr illustra questo punto: solo la prima forma su ogni riga è valida:

  

• I lati esterni di una linea possono toccarsi, ma non in un modo che racchiuda spazio.

• Le linee toccanti potrebbero non sovrapporsi, ad esempio due linee spesse di 1 pixel che toccano avrebbero uno spessore combinato di 2px, mai 1px.

Python + Pycairo, 2 ¹⁰⁰ forme

Cominciamo con l'ovvio.

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

Prende il numero dalla riga di comando e scrive o.png.

BBC Basic, punteggio 10 ^ 288 (meno 1 se lo zero non viene conteggiato)

Scarica l'interprete su http://sourceforge.net/projects/napoleonbrandy/ (non il mio solito interprete di base della BBC, che non supporta stringhe abbastanza lunghe.)

Per codificare molte informazioni, hai bisogno di molto perimetro. Ciò significa una forma sottile. Comincio con una barra verticale di 49 pixel a sinistra e vi aggiungo dieci tentacoli di 96 pixel. Ogni tentacolo può codificare 96 bit in modo simile alla soluzione di @ ell, per un totale di 960 bit.

Dato che BBC Basic non è in grado di gestire numeri così grandi, un numero di fino a 288 cifre decimali viene immesso come stringa e ogni serie di 3 cifre decimali viene convertita in un numero binario a 10 bit. Ogni bit viene quindi utilizzato per spostare uno dei tentacoli di un pixel se è un 1(ma non se è un 0.) Il programma può gestire fino a 288/3 = 96 tali insiemi di 3 cifre

    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

Produzione

Un output tipico per un numero di 288 cifre. Si noti che 999 è 1111100111 in binario. Puoi vedere come le serie di 9 cifre fanno ondulare i tentacoli.

Aspetti tecnici

A. La risposta al punto 3 di Martin "è la forma collegata se il suo pixel si tocca solo lungo un angolo?" era "sì" quindi capisco che la mia risposta è conforme. Tuttavia, se si alternano (ad esempio) 999 e 000 in ogni riga, sembra molto occupato.

B. Se lo vediamo come un rettangolo con i morsi tolti dal lato, puoi vedere che ho permesso tre pixel tra ogni coppia di tentacoli adiacenti, per garantire che la linea nera attorno all'esterno non si tocchi mai. Non esiste una regola specifica al riguardo (spero che il motivo della mia domanda sia più chiaro alla luce della mia risposta.) Se la linea è autorizzata a toccarsi all'esterno della forma, potrei spostare i tentacoli insieme e usare meno pixel per la barra verticale (e quindi rendere i tentacoli un po 'più lunghi). Sarebbe comunque molto confuso determinare a occhio se un pixel era all'interno o all'esterno della forma, quindi penso che la mia interpretazione che l'esterno della linea nera non dovrebbe mai toccare stesso è il migliore.

C. BBC basic in questa modalità schermo tratta un pixel 2x2 di pixel dello schermo come un singolo pixel. L'ho lasciato così com'è, perché aiuta a vedere se la forma non è troppo piccola. Ognuno di questi pixel di base della BBC è considerato come una scatola di unità logiche 4x4. Fin dall'inizio, gli sviluppatori di BBC basic avevano la lungimiranza di rendersi conto che un giorno le risoluzioni dello schermo sarebbero aumentate, quindi hanno reso la risoluzione logica superiore alla risoluzione fisica.

Mathematica, 496 byte, Punteggio: large-ish (> 1157)

Il limite inferiore che ho lì è ridicolmente basso, ma non ho ancora trovato un modo migliore della forza bruta per controllare.

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]

Non ho ancora giocato a golf, perché non ce n'era bisogno. Lo farò quando qualcuno dimostrerà che si stanno legando con me.

L'algoritmo sta fondamentalmente eseguendo un riempimento di riempimento dall'angolo in alto a sinistra dell'immagine 109x109 (offset di un pixel per consentire la linea) e quando ho inondato 1009 celle, mi fermo e segnare il bordo. Hai detto che i colori dipendono da noi, quindi lo sfondo è bianco, la linea è nera e l'interno è grigio (posso rimuovere il grigio per una manciata di caratteri se necessario).

Il riempimento dell'inondazione è piuttosto limitato, ma ciò assicura che non devo preoccuparmi dei buchi. Rilassare questi vincoli probabilmente aumenterà notevolmente il mio punteggio (ancora sconosciuto).

Proverò a mettere alcuni limiti inferiori sul punteggio ora.

Python 2, Punteggio> 10 ^ 395

È estremamente lento e in realtà non sono riuscito a ottenere alcun risultato diverso da n = 0, ma se si desidera testarlo più in basso SIZE(il numero di pixel) e BOUNDla lunghezza laterale massima del riquadro di delimitazione e si dovrebbe essere in grado per ottenere molti risultati. Era molto difficile provare a calcolare quanti ne avrebbe prodotto; Sono abbastanza fiducioso che il limite inferiore che do sia accurato, ma sospetto che il conteggio effettivo sia significativamente più grande e potrei provare a migliorarlo in seguito.

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