La sortie est une forme qui contient 1009 pixels.

• La forme doit prendre la forme d'une boucle unique, fermée et sans intersection.

L'entrée est un entier positif non nul.

• Chaque entrée doit produire une sortie unique - c'est-à-dire que chaque sortie doit être unique de celles générées à l'aide d'une entrée inférieure.

La victoire est décidée par la plus grande limite d'entrée:

• La limite d'entrée de votre soumission est considérée comme inférieure de 1 à l'entrée la plus basse qui donne une sortie non unique ou non valide.
• Par exemple, si une sortie valide et unique est produite pour une entrée de 1, 2 ou 3 mais pas 4, votre limite d'entrée est de 3.

Il y a une limite de 1009 octets sur le code source. S'il y a égalité, l'entrée avec le moins d'octets gagne.

Restrictions et clarifications:

• La taille maximale d'une forme est de 109 x 109 pixels. La taille inclut la ligne utilisée pour dessiner la forme.
• Une ligne est de largeur constante.
• L'espace inclus doit être entièrement délimité par la ligne - vous ne pouvez pas utiliser la limite du fichier image.
• Les 1009 pixels inclus se réfèrent uniquement à l'espace clos. Il n'inclut pas la ligne.
• La sortie est une image.
• Il n'y a pas d'autres restrictions graphiques - par exemple sur la couleur, l'épaisseur du trait, etc.
• L'unicité d'une sortie se réfère uniquement à l'espace clos. Les modifications apportées à la ligne ou d'autres modifications graphiques ne sont pas pertinentes si l'espace clos n'est pas unique.
• Une traduction de forme n'est pas unique. Les rotations, réflexions et autres transformations comptent comme uniques.
• La sortie doit être reproductible - la même entrée donnera toujours la même sortie
• Il n'est pas nécessaire qu'il y ait une relation entre les sorties, consécutives ou non.
• En dehors de la «limite d'entrée» d'une soumission, aucune sortie n'est définie.
• Aucune autre saisie ou extraction de données externes n'est autorisée.
• Une ligne doit être continue - c'est-à-dire que les pixels doivent se toucher (toucher un coin compte).
• Un pixel est la plus petite unité de «dessin» utilisée par votre méthode de dessin et ne correspondra pas nécessairement à un pixel d'écran.

Exemples:

• Voici un exemple de forme valide:

  

• Les formes suivantes ne sont pas valides:

  

EDIT: Ligne touchant:

• L'espace clos doit être continu, ce qui est défini comme des pixels se touchant. Toucher les coins compte.

• Une ligne ne peut contenir aucun espace sur son côté extérieur. Cette image publiée par @Sparr illustre ce point - seule la première forme de chaque ligne est valide:

  

• Les côtés extérieurs d'une ligne peuvent se toucher, mais pas d'une manière qui enferme l'espace.

• Les lignes en contact ne peuvent pas se chevaucher - par exemple, deux lignes en contact de 1 pixel d'épaisseur auraient une épaisseur combinée de 2 pixels, jamais de 1 pixel.

Python + pycairo, 2 ¹⁰⁰ formes

Commençons par l'évidence.

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

Prend le nombre sur la ligne de commande et écrit o.png.

BBC Basic, score 10 ^ 288 (moins 1 si zéro n'est pas compté)

Téléchargez l'interprète sur http://sourceforge.net/projects/napoleonbrandy/ (ce n'est pas mon interpréteur de base BBC habituel, celui-ci ne prend pas en charge les chaînes suffisamment longues).

Pour encoder beaucoup d'informations, vous avez besoin de beaucoup de périmètre. Cela signifie une forme mince. Je commence par une barre verticale de 49 pixels à gauche, et j'y ajoute dix tentacules de 96 pixels. Chaque tentacule peut coder 96 bits de la même manière que la solution @ ell, soit un total de 960 bits.

Étant donné que BBC Basic ne peut pas gérer des nombres aussi volumineux, un nombre allant jusqu'à 288 chiffres décimaux est entré sous forme de chaîne et chaque ensemble de 3 chiffres décimaux est converti en un nombre binaire de 10 bits. Chaque bit est ensuite utilisé pour remuer l'un des tentacules d'un pixel s'il s'agit d'un 1(mais pas s'il s'agit d'un 0.) Le programme peut gérer jusqu'à 288/3 = 96 de ces ensembles de 3 chiffres

    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

Sortie

Une sortie typique pour un nombre à 288 chiffres. Notez que 999 est 1111100111 en binaire. Vous pouvez voir comment les ensembles de 9 chiffres font onduler les tentacules.

Détails techniques

A. La réponse au point 3 de Martin "la forme est-elle connectée si son pixel ne touche que le long d'un coin?" était «oui», donc je comprends que ma réponse est conforme. Néanmoins, si vous alternez (par exemple) 999 et 000 dans chaque ligne, cela semble très occupé.

B. Si nous considérons cela comme un rectangle avec des piqûres prises sur le côté, vous pouvez voir que j'ai laissé trois pixels entre chaque paire de tentacules adjacents, pour garantir que la ligne noire autour de l'extérieur ne se touche jamais. Il n'y a pas de règle spécifique à ce sujet (j'espère que ma raison de demander est plus claire à la lumière de ma réponse.) Si la ligne est autorisée à se toucher à l'extérieur de la forme, je pourrais déplacer les tentacules ensemble et utiliser moins de pixels pour la barre verticale (et ainsi rallonger un peu les tentacules.) Il serait cependant très déroutant de déterminer à l'œil si un pixel était à l'intérieur ou à l'extérieur de la forme, donc je pense que mon interprétation que l'extérieur de la ligne noire ne devrait jamais toucher lui-même est le meilleur.

C. BBC basic dans ce mode d'écran traite un carré 2x2 de pixels d'écran comme un seul pixel. Je l'ai laissé tel quel, car cela aide à voir si la forme n'est pas trop petite. Chacun de ces pixels de base BBC est considéré comme une boîte d'unités logiques 4x4. Dès le début, les développeurs de BBC basic ont eu la prévoyance de réaliser que les résolutions d'écran augmenteraient un jour, de sorte qu'ils ont rendu la résolution logique supérieure à la résolution physique.

Mathematica, 496 octets, Score: grand-ish (> 1157)

La limite inférieure que j'ai là-bas est ridiculement basse, mais je n'ai pas encore trouvé de meilleur moyen que la force brute pour vérifier.

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]

Je n'ai pas encore joué au golf, car ce n'était pas nécessaire. Je le ferai une fois que quelqu'un aura prouvé qu'il me lie réellement.

L'algorithme fait essentiellement un remplissage à partir du coin supérieur gauche de l'image 109x109 (décalé d'un pixel pour permettre la ligne) et lorsque j'ai inondé 1009 cellules, je m'arrête et marque la bordure. Vous avez dit que les couleurs dépendaient de nous, donc l'arrière-plan est blanc, la ligne est noire et l'intérieur est gris (je peux supprimer le gris pour une poignée de caractères si nécessaire).

Le remblayage est assez contraint, mais cela garantit que je n'ai pas à me soucier des trous. Assouplir ces contraintes augmentera probablement considérablement mon score (encore inconnu).

Je vais essayer de mettre des limites inférieures sur le score maintenant.

Python 2, Score> 10 ^ 395

C'est extrêmement lent, et je n'ai pas réussi à obtenir un résultat autre que n = 0, mais si vous voulez le tester plus bas SIZE(le nombre de pixels) et BOUNDla longueur maximale du côté du carré de délimitation et vous devriez pouvoir pour obtenir beaucoup de résultats. Il était très difficile d'essayer de calculer combien cela produirait; Je suis assez confiant que la limite inférieure que je donne est exacte, mais je soupçonne que le nombre réel est considérablement plus élevé, et je peux essayer de l'améliorer plus tard.

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