24

आउटपुट एक आकृति है जो 1009 पिक्सेल को घेरता है।

आकृति को एकल, बंद, गैर-प्रतिच्छेदन लूप का रूप लेना चाहिए।

इनपुट एक सकारात्मक गैर-शून्य पूर्णांक है।

प्रत्येक इनपुट को आउटपुट का उत्पादन करना चाहिए जो अद्वितीय है - अर्थात, प्रत्येक आउटपुट को कम इनपुट का उपयोग करके उत्पन्न होने वाले से अद्वितीय होना चाहिए।

विजय का फैसला सबसे बड़ी इनपुट सीमा से होता है:

आपके सबमिशन की इनपुट सीमा को सबसे कम इनपुट से 1 माना जाता है जो गैर-अद्वितीय या अन्यथा अमान्य आउटपुट देता है।
उदाहरण के लिए, यदि मान्य और अद्वितीय आउटपुट 1, 2 या 3 के इनपुट के लिए निर्मित होता है, लेकिन 4 नहीं, तो आपकी इनपुट सीमा 3 है।

सोर्स कोड पर 1009 बाइट की सीमा है। यदि ड्रॉ होता है तो सबसे कम बाइट्स जीत के साथ प्रवेश होता है।

प्रतिबंध और स्पष्टीकरण:

एक आकृति का अधिकतम आकार 109 बाई 109 पिक्सेल है। आकार में आकृति को खींचने के लिए उपयोग की जाने वाली रेखा शामिल है।
एक लाइन निरंतर चौड़ाई है।
संलग्न स्थान पूरी तरह से लाइन से घिरा होना चाहिए - आप छवि फ़ाइल की सीमा का उपयोग नहीं कर सकते।
संलग्न 1009 पिक्सेल केवल संलग्न स्थान को संदर्भित करता है। इसमें लाइन शामिल नहीं है।
आउटपुट एक छवि है।
आगे कोई चित्रमय प्रतिबंध नहीं हैं - जैसे रंग, लाइन मोटाई आदि।
एक आउटपुट की विशिष्टता केवल संलग्न स्थान को संदर्भित करता है। यदि संलग्न स्थान अद्वितीय नहीं है, तो लाइन में परिवर्तन या अन्य चित्रमय परिवर्तन अप्रासंगिक हैं।
आकार का अनुवाद अद्वितीय नहीं है। घुमाव, परावर्तन और कोई भी अन्य परिवर्तन अद्वितीय के रूप में गिना जाता है।
आउटपुट प्रतिलिपि प्रस्तुत करने योग्य होना चाहिए - एक ही इनपुट हमेशा एक ही आउटपुट देगा
वहाँ लगातार या अन्यथा, आउटपुट के बीच कोई संबंध नहीं होना चाहिए।
प्रस्तुत 'इनपुट सीमा' के बाहर कोई परिभाषित आउटपुट नहीं है।
किसी अन्य इनपुट या बाहरी डेटा को लाने की अनुमति नहीं है।
एक पंक्ति निरंतर होनी चाहिए - अर्थात पिक्सल को एक कोने को छूना (छूना) चाहिए।
एक पिक्सेल 'ड्राइंग' की सबसे छोटी इकाई है जिसका उपयोग आपके ड्राइंग की विधि द्वारा किया जाता है, और यह आवश्यक रूप से स्क्रीन पिक्सेल के अनुरूप नहीं होगा।

उदाहरण:

यहाँ एक मान्य आकार का एक उदाहरण दिया गया है:
निम्नलिखित आकार अमान्य हैं:

संपादित करें: पंक्ति स्पर्श:

संलग्न स्थान निरंतर होना चाहिए जिसे पिक्सेल स्पर्श के रूप में परिभाषित किया गया है। कोनों को छूना मायने रखता है।
एक पंक्ति किसी भी स्थान को उसके बाहरी हिस्से में नहीं घेर सकती है। @Sparr द्वारा पोस्ट की गई यह छवि इस बिंदु को दर्शाती है - प्रत्येक पंक्ति पर केवल पहला आकार मान्य है:
एक रेखा के बाहरी किनारे स्पर्श कर सकते हैं, लेकिन एक तरह से नहीं जो अंतरिक्ष को घेरता है।
स्पर्श रेखाएँ ओवरलैप नहीं हो सकती हैं - जैसे दो स्पर्श करने वाली 1 पिक्सेल मोटी लाइनों में 2px की संयुक्त मोटाई होगी, कभी भी 1px नहीं होगी।

code-challenge graphical-output geometry

— JSH
स्रोत

उसी आकृति के घूर्णन के बारे में क्या? क्या वे अलग हैं?

— मार्टिन एंडर

यदि मैं आकृति के किनारे से काटता हूं, तो क्या अग्रभूमि (काली) रेखा एक पिक्सेल चौड़ी होना ठीक है? या क्या यह 3 पिक्सेल चौड़ा होना चाहिए, ताकि आने वाली और बाहर जाने वाली रेखा स्पर्श न करें? या क्या यह 2 पिक्सेल चौड़ा है, इसलिए आने वाली और बाहर जाने वाली लाइन टच है, लेकिन ओवरलैप नहीं है?

— लेवल रिवर सेंट

कुछ और प्रश्न: 1. क्या 109x109 छवि की सीमा आकृति की एक सीमा के रूप में कार्य कर सकती है? 2. यदि लाइन की मोटाई मेरे ऊपर है, तो क्या मैं यह कह सकता हूं कि यह 200 पिक्सल है, ताकि आकार एक काली छवि पर सिर्फ सफेद पिक्सेल हो? 3. क्या आकार जुड़ा हुआ है यदि इसका पिक्सेल केवल एक कोने से स्पर्श करता है? 4. मैं चरित्र सीमा का बहुत बड़ा प्रशंसक नहीं हूं। बहुत सी भाषाएँ सटीक आउटपुट विनिर्देशों को सेट करने के लिए 3/4 का उपयोग कर सकती हैं।

— मार्टिन एंडर

2

प्रश्न, आपको 1009 कैसे मिलेगा?

— क्लाउडीयू

1

इनमें से कौन सी आकृति वैध और छिद्रहीन हैं? i.imgur.com/FSV0nHz.png

— शुक्राणु

25

पायथन + पाइकैरो, 2 ¹⁰⁰ आकृतियाँ

आइए स्पष्ट के साथ शुरू करते हैं।

एनीमेशन 1

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

कमांड लाइन पर संख्या लेता है और लिखता है o.png।

— पक्ष
स्रोत

बहुत अच्छा। सरल विचार, अच्छी तरह से निष्पादित। विजेता स्कोर नहीं होगा, लेकिन आगे की प्रविष्टियों के लिए एक अच्छा बार सेट करता है।

— बजे

... * 2, जैसा किRotations [...] count as unique.

— edc65

@ edc65: वास्तव में * 4, क्योंकि यह सममित नहीं है।

— जस्टफुल

19

बीबीसी बेसिक, स्कोर 10 ^ 288 (शून्य से 1 शून्य न होने पर)

पर डाउनलोड interepreter http://sourceforge.net/projects/napoleonbrandy/ (नहीं मेरे सामान्य बीबीसी बुनियादी दुभाषिया, कि एक काफी लंबे समय से तार का समर्थन नहीं करता।)

बहुत सारी जानकारी को एनकोड करने के लिए, आपको बहुत सी परिधि की आवश्यकता होती है। इसका मतलब है कि एक पतली आकृति। मैं बाईं ओर 49 पिक्सल के ऊर्ध्वाधर बार के साथ शुरू करता हूं, और इसमें 96 पिक्सल के दस तम्बू जोड़ता हूं। प्रत्येक टेंटकल 96 बिट्स को @ ell के समाधान के समान तरीके से एन्कोड कर सकता है, कुल 960 बिट्स।

जैसा कि बीबीसी बेसिक इतनी बड़ी संख्या को संभाल नहीं सकता है, 288 दशमलव अंकों तक की संख्या एक स्ट्रिंग के रूप में इनपुट होती है, और 3 दशमलव अंकों के प्रत्येक सेट को 10-बिट बाइनरी नंबर में बदल दिया जाता है। प्रत्येक बिट को तब एक पिक्सेल द्वारा एक टेंकलेस को एक करने के लिए उपयोग किया जाता है यदि यह एक है 1(लेकिन नहीं तो यह एक है 0।) कार्यक्रम 3 अंकों के 288/3 = 96 तक संभाल सकता है।

    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

उत्पादन

288-अंकीय संख्या के लिए एक सामान्य आउटपुट। ध्यान दें कि बाइनरी में 999 1111100111 है। आप देख सकते हैं कि कैसे 9 अंकों के सेट टेंकल्स को कम करने का कारण बनते हैं।

यहाँ छवि विवरण दर्ज करें

शब्दावली

मार्टिन के बिंदु 3 का उत्तर "क्या आकार जुड़ा हुआ है यदि इसका पिक्सेल केवल एक कोने से स्पर्श करता है?" "हां" था, इसलिए मैं अपने उत्तर को समझता हूं। फिर भी, यदि आप वैकल्पिक (उदाहरण के लिए) 999 और 000 हर पंक्ति में हैं, तो यह बहुत व्यस्त दिखता है।

B. अगर हम इसे एक आयत के रूप में देखते हैं, तो इसे साइड से बाहर काटने पर आप देख सकते हैं कि मैंने आसन्न तम्बू के प्रत्येक जोड़े के बीच तीन पिक्सेल की अनुमति दी है, यह सुनिश्चित करने के लिए कि बाहर की काली रेखा कभी भी खुद को नहीं छूती है। इस पर कोई विशिष्ट नियम नहीं है (मुझे आशा है कि मेरे पूछने का कारण मेरे उत्तर के प्रकाश में स्पष्ट है।) यदि रेखा को आकार के OUTSIDE पर स्वयं को छूने की अनुमति है, तो मैं एक साथ तम्बू को स्थानांतरित कर सकता हूं और इसके लिए कम पिक्सेल का उपयोग कर सकता हूं ऊर्ध्वाधर पट्टी (और इसलिए तम्बू को थोड़ा लंबा कर दें।) हालांकि, यह इस बात से निर्धारित करने के लिए बहुत भ्रामक हो जाएगा कि क्या पिक्सेल आकार के अंदर या बाहर था, इसलिए मुझे लगता है कि मेरी व्याख्या यह है कि काली रेखा के बाहर कभी स्पर्श नहीं करना चाहिए। खुद सर्वश्रेष्ठ है।

इस स्क्रीन मोड में सी। बेसिक एक पिक्सेल के रूप में स्क्रीन पिक्सल के 2x2 वर्ग को मानता है। मैंने इसे छोड़ दिया है क्योंकि यह है, क्योंकि यह देखने में मदद करता है कि आकार बहुत छोटा नहीं है। बीबीसी बेसिक पिक्सल में से प्रत्येक को 4x4 तार्किक इकाइयों के एक बॉक्स के रूप में माना जाता है। शुरुआत से, बीबीसी बेसिक के डेवलपर्स को यह महसूस करने की दूरदर्शिता थी कि एक दिन स्क्रीन रिज़ॉल्यूशन बढ़ेगा, इसलिए उन्होंने तार्किक रिज़ॉल्यूशन को भौतिक रिज़ॉल्यूशन से अधिक बना दिया।

— स्तर नदी सेंट
स्रोत

एक: जवाब "हाँ" रहता है, हालांकि मैं देख रहा हूं कि यह थोड़ा अजीब है। ख। मैंने अब आपकी बात देखी और स्पष्ट करने के लिए एक संपादन किया, भ्रम की स्थिति के लिए क्षमा करें।

— jsh

C: यह एक समस्या नहीं है। एक पिक्सेल अब ड्राइंग की सबसे छोटी इकाई के रूप में परिभाषित किया गया है।

— जेएस

6

गणितज्ञ, 496 बाइट्स, स्कोर: बड़ी-ईश (> 1157)

मुझे जो कम बाउंड मिला है वह हास्यास्पद रूप से कम है, लेकिन मुझे अभी तक जांच करने के लिए क्रूर बल से बेहतर तरीका नहीं मिला है।

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]

मैंने अभी तक इस पर विचार नहीं किया है, क्योंकि इसकी कोई आवश्यकता नहीं थी। मैं ऐसा करूंगा कि एक बार कोई साबित कर दे कि वे वास्तव में मेरे साथ बंध रहे हैं।

एल्गोरिथ्म मूल रूप से 109x109 छवि (लाइन के लिए अनुमति देने के लिए एक पिक्सेल द्वारा ऑफसेट) के शीर्ष-बाएं कोने से बाढ़-भरण कर रहा है और जब मैंने 1009 कोशिकाओं को भर दिया है, तो मैं सीमा को रोक देता हूं और चिह्नित करता हूं। आपने कहा कि रंग हमारे ऊपर हैं, इसलिए पृष्ठभूमि सफेद है, रेखा काली है और इंटीरियर ग्रे है (यदि आवश्यक हो तो मैं मुट्ठी भर पात्रों के लिए ग्रे निकाल सकता हूं)।

बाढ़ भराव काफी विवश है, लेकिन यह सुनिश्चित करता है कि मुझे छेद के बारे में चिंता करने की ज़रूरत नहीं है। इन बाधाओं को शांत करने से संभवतः मेरे (अभी तक अज्ञात) स्कोर में नाटकीय रूप से वृद्धि होगी।

मैं अब स्कोर पर कुछ कम सीमा लगाने की कोशिश करूंगा।

— मार्टिन एंडर
स्रोत

क्या आप CDF फ़ाइल प्रदान करने में सक्षम हैं ताकि मैं इसे आज़मा सकूं ?

— jsh

1

@ जेश यह कोशिश करें

— मार्टिन

मुझे लगता है कि यादृच्छिक संख्याओं पर निर्भर सभी समाधानों को मान्य करने के लिए एक बल-बल की आवश्यकता होगी। मुझे यकीन नहीं है कि आप पिक्सेल चेक द्वारा पिक्सेल कर रहे हैं, लेकिन आप प्रत्येक आउटपुट को मोनोक्रोमैटिक बिटमैप (छोटी फ़ाइलों) को सहेजने और हैश की तुलना करने की कोशिश कर सकते हैं। मुझे लगता है कि जितनी तेजी से आप छवि की तुलना के लिए प्राप्त करेंगे।

— स्टोकैस्टिक

@stokastic मैं वर्तमान में बहुत भोली हैश (सभी पिक्सेल निर्देशांक का योग) का निर्माण कर रहा हूं, और फिर मैं टकराते हुए डिब्बे की विस्तार से जाँच कर रहा हूँ। समस्या यह है कि टकराव की जाँच के लिए मेरे द्वारा उपयोग किए जाने वाले दृष्टिकोण को कितना भी परिष्कृत क्यों न किया जाए, पीढ़ी विधि इतनी धीमी है, कि मैं उचित समय में कुछ 10k या 100k बीज से अधिक हल करने में सक्षम नहीं हो पाऊंगा। एल्गोरिथ्म को गति देने के कई तरीके हैं, हालांकि, मुझे लगता है, इसलिए मैं कुछ बिंदुओं पर गौर कर सकता हूं।

— मार्टिन एंडर

@ मार्टिनबटनर आपने शायद पहले ही इसका परीक्षण कर लिया था (या गणितज्ञ इसका समर्थन नहीं करता है), लेकिन एक सीधे फाइल-हैश जल्दी हो सकता है। यदि आपने ऐसा प्रयास नहीं किया है तो बस एक सुझाव।

— स्टोकैस्टिक

1

पायथन 2, स्कोर> 10 ^ 395

यह बहुत धीमा है, और मैं वास्तव में n = 0 के अलावा किसी भी परिणाम को प्राप्त करने में कामयाब नहीं हुआ हूं, लेकिन यदि आप इसे कम SIZE(पिक्सेल की संख्या) और BOUNDबाउंडिंग स्क्वायर की अधिकतम लंबाई की जांच करना चाहते हैं और आपको सक्षम होना चाहिए बहुत सारे परिणाम पाने के लिए। यह प्रयास करना और गणना करना बहुत मुश्किल था कि यह कितने उत्पादन करेगा; मुझे पूरा विश्वास है कि मैं जो निचला बाउंड दे रहा हूं वह सटीक है, लेकिन मुझे लगता है कि वास्तविक गिनती काफी बड़ी है, और मैं बाद में इसमें सुधार करने की कोशिश कर सकता हूं।

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

— KSab
स्रोत

2

क्या आप छवि दे सकते हैं n=0? और क्या आप यह भी बता सकते हैं कि आप 10 ^ 395 कैसे प्राप्त करते हैं?

— जस्टफुल

1009 पिक्सल संलग्न करें

पायथन + पाइकैरो, 2 100 आकृतियाँ

बीबीसी बेसिक, स्कोर 10 ^ 288 (शून्य से 1 शून्य न होने पर)

गणितज्ञ, 496 बाइट्स, स्कोर: बड़ी-ईश (> 1157)

पायथन 2, स्कोर> 10 ^ 395

पायथन + पाइकैरो, 2 ¹⁰⁰ आकृतियाँ