Đầu ra là một hình bao quanh 1009 pixel.

• Hình dạng phải có dạng một vòng lặp đơn, khép kín, không giao nhau.

Đầu vào là một số nguyên dương khác không.

• Mỗi đầu vào phải mang lại đầu ra duy nhất - nghĩa là, mỗi đầu ra phải là duy nhất so với đầu ra được tạo bằng đầu vào thấp hơn.

Chiến thắng được quyết định bởi giới hạn đầu vào lớn nhất:

• Giới hạn đầu vào của trình của bạn được coi là ít hơn 1 so với đầu vào thấp nhất cung cấp đầu ra không duy nhất hoặc không hợp lệ.
• Chẳng hạn, nếu đầu ra hợp lệ và duy nhất được tạo ra cho đầu vào là 1, 2 hoặc 3 chứ không phải 4, giới hạn đầu vào của bạn là 3.

Có giới hạn 1009 byte đối với mã nguồn. Nếu có một bản vẽ, mục có ít byte nhất sẽ thắng.

Hạn chế và làm rõ:

• Kích thước tối đa của hình dạng là 109 x 109 pixel. Kích thước bao gồm các đường được sử dụng để vẽ hình.
• Một dòng có chiều rộng không đổi.
• Không gian kín phải được bao kín hoàn toàn bởi dòng - bạn không thể sử dụng đường biên của tệp hình ảnh.
• 1009 pixel kèm theo chỉ đề cập đến không gian kín. Nó không bao gồm các dòng.
• Đầu ra là một hình ảnh.
• Không có giới hạn đồ họa nào nữa - ví dụ về màu sắc, độ dày của đường, v.v.
• Tính duy nhất của đầu ra chỉ liên quan đến không gian kín. Thay đổi đối với dòng hoặc thay đổi đồ họa khác là không liên quan nếu không gian kín không phải là duy nhất.
• Một bản dịch của hình dạng không phải là duy nhất. Xoay, phản xạ và bất kỳ biến đổi khác được tính là duy nhất.
• Đầu ra phải có khả năng tái tạo - cùng một đầu vào sẽ luôn cho cùng một đầu ra
• Không cần phải có mối quan hệ giữa các đầu ra, liên tiếp hoặc cách khác.
• Bên ngoài một 'giới hạn đầu vào' của một đệ trình không có đầu ra được xác định.
• Không có đầu vào hoặc tìm nạp dữ liệu bên ngoài được cho phép.
• Một dòng phải liên tục - tức là pixel phải chạm (chạm vào một góc đếm).
• Pixel là đơn vị 'bản vẽ' nhỏ nhất được sử dụng bởi phương pháp vẽ của bạn và không nhất thiết phải tương ứng với pixel màn hình.

Ví dụ:

• Dưới đây là một ví dụ về hình dạng hợp lệ:

  

• Các hình dạng sau không hợp lệ:

  

EDIT: Chạm dòng:

• Không gian kèm theo phải liên tục được xác định là chạm pixel. Chạm vào góc đếm.

• Một dòng không thể bao quanh bất kỳ không gian ở phía bên ngoài của nó. Hình ảnh này được đăng bởi @Sparr minh họa điểm này - chỉ hình đầu tiên trên mỗi hàng là hợp lệ:

  

• Các mặt bên ngoài của một dòng có thể chạm vào, nhưng không phải theo cách bao quanh không gian.

• Các đường chạm có thể không trùng nhau - ví dụ: hai đường chạm dày 1 pixel sẽ có độ dày kết hợp là 2px, không bao giờ là 1px.

Python + Pycairo, 2 ¹⁰⁰ hình

Hãy bắt đầu với điều hiển nhiên.

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

Lấy số trên dòng lệnh và viết o.png.

BBC Basic, điểm 10 ^ 288 (trừ 1 nếu không tính)

Tải xuống interepreter tại http://sourceforge.net/projects/napoleonbrandy/ (không phải trình thông dịch cơ bản thông thường của BBC của tôi, rằng trình dịch này không hỗ trợ chuỗi đủ dài.)

Để mã hóa nhiều thông tin, bạn cần rất nhiều chu vi. Điều đó có nghĩa là một hình dạng mỏng. Tôi bắt đầu với một thanh dọc 49 pixel ở bên trái và thêm mười xúc tu 96 pixel vào nó. Mỗi xúc tu có thể mã hóa 96 bit theo cách tương tự như giải pháp của @ ell, tổng cộng là 960 bit.

Vì BBC Basic không thể xử lý các số lớn như vậy, một số lượng lên tới 288 chữ số thập phân được nhập dưới dạng một chuỗi và mỗi bộ gồm 3 chữ số thập phân được chuyển đổi thành số nhị phân 10 bit. Mỗi bit sau đó được sử dụng để vẫy một trong các xúc tu lên một pixel nếu đó là một 1(nhưng không phải là một 0.) Chương trình có thể xử lý tối đa 288/3 = 96 bộ 3 chữ số như vậy

    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

Đầu ra

Một đầu ra điển hình cho một số 288 chữ số. Lưu ý rằng 999 là 1111100111 ở dạng nhị phân. Bạn có thể thấy làm thế nào các bộ 9 chữ số làm cho các xúc tu nhấp nhô.

Kỹ thuật

A. Câu trả lời cho điểm 3 của Martin "là hình dạng được kết nối nếu điểm chạm của pixel chỉ dọc theo một góc?" là "có" vì vậy tôi hiểu câu trả lời của tôi tuân thủ. Tuy nhiên, nếu bạn thay thế (ví dụ) 999 và 000 trong mỗi hàng, có vẻ rất bận rộn.

B. Nếu chúng ta xem đây là một hình chữ nhật có vết cắn ở bên cạnh, bạn có thể thấy rằng tôi cho phép ba pixel giữa mỗi cặp xúc tu liền kề, để đảm bảo rằng đường màu đen quanh bên ngoài không bao giờ chạm vào chính nó. Không có quy tắc cụ thể nào về điều này (tôi hy vọng lý do hỏi của tôi rõ ràng hơn trong câu trả lời của tôi.) Nếu đường thẳng được phép chạm vào BÊN NGOÀI của hình dạng, tôi có thể di chuyển các xúc tu lại với nhau và sử dụng ít pixel hơn cho thanh dọc (và do đó làm cho các xúc tu dài hơn một chút.) Tuy nhiên, sẽ rất khó hiểu khi xác định bằng mắt xem một pixel ở bên trong hay bên ngoài hình dạng, vì vậy tôi nghĩ rằng giải thích của tôi rằng bên ngoài đường màu đen không bao giờ chạm vào bản thân nó là tốt nhất

C. BBC cơ bản trong chế độ màn hình này coi một pixel màn hình 2x2 là một pixel. Tôi đã để nó như vậy, vì nó giúp xem nếu hình dạng không quá nhỏ. Mỗi một trong số các pixel cơ bản này của BBC được coi là một hộp gồm các đơn vị logic 4 x 4. Ngay từ đầu, các nhà phát triển của BBC cơ bản đã có tầm nhìn xa để nhận ra rằng một ngày độ phân giải màn hình sẽ tăng lên, vì vậy họ đã làm cho độ phân giải logic cao hơn độ phân giải vật lý.

Mathicala, 496 byte, Điểm: lớn-ish (> 1157)

Giới hạn dưới mà tôi có ở đó thấp đến mức nực cười, nhưng tôi chưa tìm ra cách nào tốt hơn lực lượng vũ phu để kiểm tra.

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]

Tôi chưa chơi golf này, vì không cần thiết. Tôi sẽ làm điều đó một khi ai đó chứng minh rằng họ thực sự ràng buộc với tôi.

Thuật toán về cơ bản là thực hiện lấp đầy từ góc trên bên trái của hình ảnh 109x109 (được bù một pixel để cho phép đường kẻ) và khi tôi đã tràn ngập 1009 ô, tôi dừng lại và đánh dấu đường viền. Bạn nói màu sắc tùy thuộc vào chúng ta, vì vậy nền là màu trắng, đường kẻ là màu đen và bên trong là màu xám (tôi có thể loại bỏ màu xám cho một số ký tự nếu cần thiết).

Lũ lụt khá hạn chế, nhưng điều đó đảm bảo rằng tôi không phải lo lắng về các lỗ hổng. Thư giãn những hạn chế này có thể sẽ làm tăng đáng kể điểm số (chưa biết) của tôi.

Bây giờ tôi sẽ cố gắng đặt một số giới hạn thấp hơn vào điểm số.

Python 2, Điểm> 10 ^ 395

Nó cực kỳ chậm và tôi thực sự đã không thể đạt được bất kỳ kết quả nào ngoài n = 0, nhưng nếu bạn muốn kiểm tra nó thấp hơn SIZE(số pixel) và BOUNDđộ dài cạnh tối đa của hình vuông giới hạn và bạn sẽ có thể để có được nhiều kết quả. Rất khó để thử và tính xem nó sẽ sản xuất bao nhiêu; Tôi khá tự tin rằng giới hạn dưới mà tôi đưa ra là chính xác, nhưng tôi nghi ngờ số lượng thực tế sẽ lớn hơn đáng kể và tôi có thể cố gắng cải thiện nó sau này.

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