Output adalah bentuk yang membungkus 1009 piksel.

• Bentuknya harus berbentuk loop tunggal, tertutup, tidak berpotongan.

Input adalah bilangan bulat positif bukan nol.

• Setiap input harus menghasilkan output yang unik - yaitu, setiap output harus unik dari yang dihasilkan menggunakan input yang lebih rendah.

Kemenangan ditentukan oleh batas input terbesar:

• Batas input kiriman Anda dianggap 1 kurang dari input terendah yang menghasilkan output tidak unik atau tidak valid.
• Misalnya, jika output yang valid dan unik dihasilkan untuk input 1, 2 atau 3 tetapi tidak 4, batas input Anda adalah 3.

Ada batas 1009 byte pada kode sumber. Jika ada undian, entri dengan byte paling sedikit menang.

Batasan dan klarifikasi:

• Ukuran maksimum bentuk adalah 109 kali 109 piksel. Ukuran termasuk garis yang digunakan untuk menggambar bentuk.
• Garis adalah lebar konstan.
• Ruang tertutup harus seluruhnya tertutup oleh garis - Anda tidak dapat menggunakan batas file gambar.
• 1009 piksel terlampir hanya mengacu pada ruang tertutup. Itu tidak termasuk garis.
• Output adalah gambar.
• Tidak ada batasan grafis lebih lanjut - misalnya pada warna, ketebalan garis dll.
• Keunikan output hanya merujuk pada ruang tertutup. Perubahan pada garis atau perubahan grafis lainnya tidak relevan jika ruang tertutup tidak unik.
• Terjemahan bentuk tidak unik. Rotasi, refleksi, dan transformasi lainnya dianggap unik.
• Output harus dapat direproduksi - input yang sama akan selalu memberikan output yang sama
• Tidak perlu ada hubungan antara output, berturut-turut atau sebaliknya.
• Di luar 'batas input' kiriman tidak ada output yang ditentukan.
• Tidak ada input atau pengambilan data eksternal lainnya diizinkan.
• Garis harus kontinu - yaitu piksel harus menyentuh (menyentuh jumlah sudut).
• Piksel adalah unit terkecil dari 'gambar' yang digunakan oleh metode menggambar Anda, dan tidak akan selalu sesuai dengan piksel layar.

Contoh:

• Berikut ini contoh bentuk yang valid:

  

• Bentuk berikut tidak valid:

  

EDIT: Menyentuh garis:

• Ruang tertutup harus kontinu yang didefinisikan sebagai menyentuh piksel. Sudut yang menyentuh penting.

• Sebuah garis tidak dapat melingkupi ruang di sisi luarnya. Gambar ini diposting oleh @Sparr menggambarkan titik ini - hanya bentuk pertama di setiap baris yang valid:

  

• Sisi luar garis mungkin menyentuh, tetapi tidak dengan cara yang menutupi ruang.

• Garis yang menyentuh mungkin tidak tumpang tindih - mis. Dua garis tebal 1 pixel yang menyentuh akan memiliki ketebalan gabungan 2px, tidak pernah 1px.

Python + Pycairo, 2 ¹⁰⁰ bentuk

Mari kita mulai dengan yang jelas.

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

Mengambil nomor pada baris perintah dan menulis o.png.

BBC Basic, skor 10 ^ 288 (minus 1 jika nol tidak dihitung)

Unduh interepreter di http://sourceforge.net/projects/napoleonbrandy/ (bukan penerjemah dasar BBC saya yang biasa, yang tidak mendukung string cukup lama.)

Untuk menyandikan banyak informasi, Anda memerlukan banyak perimeter. Itu artinya bentuknya tipis. Saya mulai dengan bilah vertikal 49 piksel di sebelah kiri, dan menambahkan sepuluh tentakel 96 piksel ke dalamnya. Setiap tentakel dapat mengkodekan 96 bit dengan cara yang mirip dengan solusi @ ell, total 960 bit.

Karena BBC Basic tidak dapat menangani angka yang besar, sejumlah hingga 288 angka desimal dimasukkan sebagai string, dan setiap rangkaian 3 angka desimal dikonversi ke angka biner 10-bit. Setiap bit kemudian digunakan untuk menggoyangkan salah satu dari tentakel dengan satu pixel jika itu adalah 1(tetapi tidak jika itu adalah 0.) Program ini dapat menangani hingga 288/3 = 96 set 3 digit.

    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

Keluaran

Output khas untuk angka 288 digit. Perhatikan bahwa 999 adalah 1111100111 dalam biner. Anda dapat melihat bagaimana set 9 digit menyebabkan tentakel bergelombang.

Teknisnya

A. Jawaban untuk poin Martin 3 "adalah bentuk terhubung jika sentuhan pixel-nya hanya sepanjang sudut?" adalah "ya" jadi saya mengerti jawaban saya sesuai. Namun demikian, jika Anda berganti-ganti (misalnya) 999 dan 000 di setiap baris, itu terlihat sangat sibuk.

B. Jika kita melihat ini sebagai persegi panjang dengan gigitan yang diambil dari samping, Anda dapat melihat bahwa saya membiarkan tiga piksel antara setiap pasang tentakel yang berdekatan, untuk memastikan bahwa garis hitam di sekeliling luar tidak pernah menyentuh dirinya sendiri. Tidak ada aturan khusus tentang ini (saya harap alasan saya untuk bertanya lebih jelas mengingat jawaban saya.) Jika garis dibiarkan menyentuh dirinya sendiri di luar bentuk, saya bisa memindahkan tentakel bersama dan menggunakan lebih sedikit piksel untuk bilah vertikal (dan membuat tentakel sedikit lebih lama.) Akan, bagaimanapun, menjadi sangat membingungkan untuk menentukan dengan mata apakah sebuah piksel berada di dalam atau di luar bentuk, jadi saya pikir interpretasi saya bahwa bagian luar garis hitam tidak boleh menyentuh itu sendiri adalah yang terbaik.

C. BBC basic dalam mode layar ini memperlakukan piksel layar 2x2 persegi sebagai piksel tunggal. Saya membiarkannya seperti ini, karena membantu melihat jika bentuknya tidak terlalu kecil. Masing-masing piksel dasar BBC ini dianggap sebagai kotak unit logis 4x4. Sejak awal, para pengembang dasar BBC memiliki pandangan ke depan untuk menyadari bahwa resolusi layar satu hari akan meningkat, sehingga mereka membuat resolusi logis lebih tinggi daripada resolusi fisik.

Mathematica, 496 bytes, Nilai: besar-ish (> 1157)

Batas bawah yang saya dapatkan di sana sangat rendah, tetapi saya belum menemukan cara yang lebih baik daripada brute force untuk memeriksanya.

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]

Saya belum bermain golf ini, karena tidak perlu. Saya akan melakukan itu begitu seseorang membuktikan mereka benar-benar mengikat saya.

Algoritma ini pada dasarnya melakukan pengisian banjir dari sudut kiri atas gambar 109x109 (diimbangi dengan satu piksel untuk memungkinkan jalur) dan ketika saya telah membanjiri 1009 sel, saya berhenti dan menandai perbatasan. Anda bilang warna terserah kita, jadi latar belakangnya putih, garisnya hitam dan interiornya abu-abu (saya bisa menghilangkan abu-abu untuk beberapa karakter jika perlu).

Isi banjir cukup terbatas, tetapi itu memastikan bahwa saya tidak perlu khawatir tentang lubang. Melonggarkan kendala-kendala ini mungkin akan secara dramatis meningkatkan skor saya (belum diketahui).

Saya akan mencoba memberi batas bawah pada skor sekarang.

Python 2, Nilai> 10 ^ 395

Ini sangat lambat, dan saya belum benar-benar berhasil mendapatkan hasil selain n = 0, tetapi jika Anda ingin mengujinya lebih rendah SIZE(jumlah piksel) dan BOUNDpanjang sisi maksimum kotak pembatas dan Anda harus bisa untuk mendapatkan banyak hasil. Sangat sulit untuk mencoba dan menghitung berapa yang akan dihasilkan; Saya cukup yakin bahwa batas bawah yang saya berikan akurat, tetapi saya curiga jumlah aktualnya secara signifikan lebih besar, dan saya dapat mencoba memperbaikinya nanti.

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