Die Ausgabe ist eine Form, die 1009 Pixel einschließt.

• Die Form muss die Form einer einzelnen, geschlossenen, sich nicht schneidenden Schleife haben.

Die Eingabe ist eine positive Ganzzahl ungleich Null.

• Jede Eingabe muss eine eindeutige Ausgabe liefern - das heißt, jede Ausgabe muss eine eindeutige Ausgabe sein, die mit einer niedrigeren Eingabe generiert wird.

Der Sieg wird durch die größte Eingabegrenze entschieden:

• Das Eingabelimit Ihrer Übermittlung wird als 1 weniger als die niedrigste Eingabe angesehen, die eine nicht eindeutige oder anderweitig ungültige Ausgabe ergibt.
• Wenn beispielsweise eine gültige und eindeutige Ausgabe für eine Eingabe von 1, 2 oder 3, jedoch nicht von 4 erstellt wird, liegt die Eingabegrenze bei 3.

Der Quellcode ist auf 1009 Byte begrenzt. Bei einem Unentschieden gewinnt der Eintrag mit den wenigsten Bytes.

Einschränkungen und Erläuterungen:

• Die maximale Größe einer Form beträgt 109 x 109 Pixel. Die Größe enthält die Linie, mit der die Form gezeichnet wurde.
• Eine Linie hat eine konstante Breite.
• Der umschlossene Raum muss vollständig von der Linie umschlossen sein - Sie können den Rand der Bilddatei nicht verwenden.
• Die eingeschlossenen 1009 Pixel beziehen sich nur auf den eingeschlossenen Raum. Die Zeile ist nicht enthalten.
• Ausgabe ist ein Bild.
• Es gibt keine weiteren grafischen Einschränkungen - zB bezüglich Farbe, Strichstärke etc.
• Die Einzigartigkeit einer Ausgabe bezieht sich nur auf den umschlossenen Raum. Änderungen an der Linie oder andere grafische Änderungen sind irrelevant, wenn der umschlossene Raum nicht eindeutig ist.
• Eine Übersetzung von Form ist nicht eindeutig. Rotationen, Reflexionen und andere Transformationen gelten als einzigartig.
• Die Ausgabe muss reproduzierbar sein - dieselbe Eingabe gibt immer dieselbe Ausgabe
• Es muss keine Beziehung zwischen aufeinanderfolgenden oder anderen Ausgaben geben.
• Außerhalb der Eingabegrenze einer Übermittlung gibt es keine definierte Ausgabe.
• Eine anderweitige Eingabe oder das Abrufen von externen Daten ist nicht gestattet.
• Eine Linie muss durchgehend sein - dh Pixel müssen sich berühren (Berühren einer Ecke zählt).
• Ein Pixel ist die kleinste Zeicheneinheit, die von Ihrer Zeichenmethode verwendet wird, und entspricht nicht unbedingt einem Bildschirmpixel.

Beispiele:

• Hier ist ein Beispiel für eine gültige Form:

  

• Die folgenden Formen sind ungültig:

  

BEARBEITEN: Linie berühren:

• Der umschlossene Raum muss durchgehend sein, was als Pixel definiert wird, die sich berühren. Das Berühren von Ecken zählt.

• Eine Linie darf an ihrer Außenseite kein Leerzeichen enthalten. Dieses Bild von @Sparr zeigt diesen Punkt - nur die erste Form in jeder Zeile ist gültig:

  

• Die Außenseiten einer Linie dürfen sich berühren, aber nicht in einer Weise, die den Raum einschließt.

• Berührungslinien dürfen sich nicht überlappen - z. B. hätten zwei sich berührende 1 Pixel dicke Linien eine kombinierte Dicke von 2 Pixel, niemals 1 Pixel.

Python + Pycairo, 2 ¹⁰⁰ Formen

Beginnen wir mit dem Offensichtlichen.

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

Nimmt die Nummer in die Kommandozeile und schreibt o.png.

BBC Basic, Punktzahl 10 ^ 288 (minus 1, wenn die Null nicht gezählt wird)

Laden Sie interepreter unter http://sourceforge.net/projects/napoleonbrandy/ herunter. (nicht mein üblicher BBC-Interpreter, der nicht lange genug Zeichenfolgen unterstützt).

Um viele Informationen zu kodieren, benötigen Sie viele Perimeter. Das bedeutet eine dünne Form. Ich beginne mit einem vertikalen Balken von 49 Pixel links und füge zehn Tentakeln von 96 Pixel hinzu. Jedes Tentakel kann 96 Bit, also insgesamt 960 Bit, auf ähnliche Weise wie die @ ell-Lösung codieren.

Da BBC Basic keine so großen Zahlen verarbeiten kann, werden bis zu 288 Dezimalstellen als Zeichenfolge eingegeben, und jede Gruppe von 3 Dezimalstellen wird in eine 10-Bit-Binärzahl konvertiert. Jedes Bit wird dann verwendet, um einen der Tentakel um ein Pixel nach oben zu wackeln, wenn es sich um einen handelt 1(aber nicht, wenn es sich um einen handelt 0). Das Programm kann bis zu 288/3 = 96 solcher Sätze von 3 Ziffern verarbeiten

    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

Ausgabe

Eine typische Ausgabe für eine 288-stellige Zahl. Beachten Sie, dass 999 binär 1111100111 ist. Sie können sehen, wie die 9-stelligen Sätze bewirken, dass die Tentakel wellenförmig sind.

Technische Details

A. Die Antwort auf Martins Punkt 3 "Ist die Form verbunden, wenn sich die Pixel nur entlang einer Ecke berühren?" war "ja" so verstehe ich meine antwort entspricht. Wenn Sie jedoch (zum Beispiel) 999er und 000er in jeder Zeile abwechseln, sieht es sehr beschäftigt aus.

B. Wenn wir dies als ein Rechteck mit seitlich herausgenommenen Bissen betrachten, können Sie sehen, dass ich drei Pixel zwischen jedem Paar benachbarter Tentakeln zulasse, um sicherzustellen, dass sich die schwarze Linie um die Außenseite niemals selbst berührt. Hierfür gibt es keine spezielle Regel (ich hoffe, mein Grund für die Anfrage ist im Lichte meiner Antwort klarer.) Wenn die Linie sich AUSSEN an der Form berühren darf, könnte ich die Tentakel zusammen bewegen und weniger Pixel für verwenden Die vertikale Leiste (und damit die Tentakeln ein bisschen länger machen.) Es würde jedoch sehr verwirrend werden, mit dem Auge zu bestimmen, ob ein Pixel innerhalb oder außerhalb der Form liegt, daher denke ich, dass sich die Außenseite der schwarzen Linie niemals berühren sollte selbst ist am besten.

C. BBC basic behandelt in diesem Bildschirmmodus ein 2x2-Quadrat von Bildschirmpixeln als ein einzelnes Pixel. Ich habe das so belassen, weil es beim Betrachten hilft, wenn die Form nicht zu klein ist. Jedes dieser BBC-Grundpixel wird als Box mit 4 × 4 logischen Einheiten betrachtet. Die Entwickler von BBC basic hatten von Anfang an die Voraussicht, dass sich die Bildschirmauflösung eines Tages erhöhen würde, und haben die logische Auflösung daher höher als die physikalische Auflösung gewählt.

Mathematica, 496 Bytes, Score: groß (> 1157)

Die Untergrenze, die ich dort habe, ist lächerlich niedrig, aber ich habe noch keinen besseren Weg gefunden, als brutale Gewalt zu überprüfen.

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]

Ich habe das noch nicht golfen, weil es nicht nötig war. Ich mache das, sobald jemand beweist, dass er tatsächlich mit mir zu tun hat.

Der Algorithmus füllt das 109x109-Bild im Grunde genommen von der oberen linken Ecke aus (um einen Pixel versetzt, um die Linie zu berücksichtigen). Wenn ich 1009 Zellen geflutet habe, halte ich an und markiere den Rand. Sie sagten, die Farben liegen bei uns, der Hintergrund ist also weiß, die Linie ist schwarz und das Innere ist grau (ich kann das Grau für eine Handvoll Zeichen entfernen, wenn nötig).

Die Flutfüllung ist ziemlich begrenzt, aber das stellt sicher, dass ich mich nicht um Löcher kümmern muss. Die Lockerung dieser Einschränkungen wird wahrscheinlich meine (noch unbekannte) Punktzahl dramatisch erhöhen.

Ich werde jetzt versuchen, ein paar niedrigere Grenzen für die Partitur zu setzen.

Python 2, Score> 10 ^ 395

Es ist extrem langsam, und ich habe es tatsächlich nicht geschafft, ein anderes Ergebnis als n = 0 zu erhalten, aber wenn Sie es niedriger testen möchten SIZE(die Anzahl der Pixel) und BOUNDdie maximale Seitenlänge des Begrenzungsquadrats und Sie sollten in der Lage sein viele Ergebnisse zu erzielen. Es war sehr schwierig zu berechnen, wie viele es produzieren würde; Ich bin mir ziemlich sicher, dass die von mir angegebene Untergrenze korrekt ist, aber ich vermute, dass die tatsächliche Anzahl bedeutend höher ist, und ich kann versuchen, sie später zu verbessern.

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