एक यादृच्छिक हेक्सा-ग्लिफ़ ड्रा करें

Question

उपरोक्त छवि को हेक्सा-ग्लिफ़ कहा जाता है। हेक्सा-ग्लिफ़ कुछ शांत पैटर्न हैं जिन्हें मैंने अपने डिफेक क्लास के दौरान डूडलिंग करते समय बनाया था। यहां बताया गया है कि आप कैसे बनाते हैं:

1. अंक के निम्नलिखित सेट पर विचार करें, एक नियमित षट्भुज के आकार का। आंतरिक षट्भुज वह होता है जिसमें अंतिम ग्लिफ़ होता है, जबकि बाहरी 6 बिंदु एक तारा बनाते हैं और जहाँ हम अपनी रेखाएँ बनाना शुरू करेंगे।

2. बाहरी छह बिंदुओं से, बेतरतीब ढंग से एक जोड़ी का चयन करें। दक्षता के लिए, दो चयनित बिंदुओं के बीच कम से कम एक अन्य बिंदु होना चाहिए (अन्यथा, अंतिम आंकड़े पर इसका कोई प्रभाव नहीं होगा)। फिर, दो बिंदुओं में से प्रत्येक से, दूसरे की ओर एक किरण डाली । यह किरण पिछली लाइनों द्वारा अवरुद्ध है।

3. इस प्रक्रिया को तब तक दोहराएं जब तक कि सभी 9 किनारों का निर्माण न हो जाए, जैसा कि अगले कुछ चित्रों में दिखाया गया है।

4. यहाँ किरणों का एक उदाहरण अवरुद्ध है। किरण खंड के छोर अभी भी दिखाई दे रहे हैं, लेकिन मध्य भाग पहले दो खंडों से भरा हुआ है, जिन्हें हमने आकर्षित किया था।

5. इन दो किरणों को "अवरुद्ध" भी किया जाता है, लेकिन यह किसी भी दृश्य अंतर का कारण नहीं बनता है क्योंकि वे एक ही अन्य रेखा द्वारा अवरुद्ध होते हैं।

6. सभी 9 लाइनों को खींचने तक फास्ट-फ़ॉरवर्डिंग। यदि आप इन छोड़े गए चरणों का अधिक विस्तृत विवरण चाहते हैं, तो मैं समाप्त कर सकता हूं।

7. अंत में, स्टार के बिंदुओं को हटा दें। इसे सुंदर दिखाने के लिए, मोटे डॉट्स को भी हटा दिया जाता है।

चुनौती

आप चुनौती एक यादृच्छिक हेक्सा-ग्लिफ़ के दृश्य प्रतिनिधित्व को आउटपुट करना है। यह कोड-गोल्फ, सबसे कम बाइट्स जीतता है।

1. सभी संभव हेक्सा-ग्लिफ़ कुछ सकारात्मक संभावना के साथ दिखाई देने चाहिए। अलग-अलग हेक्सा-ग्लिफ़ उस क्रम को बदलकर उत्पन्न होते हैं जिसमें 9 किनारों को खींचा जाता है।

2. इसके अलावा, आपके प्रोग्राम द्वारा सभी इमेज आउटपुट को हेक्सा-ग्लिफ़ होना चाहिए। कुछ पैटर्न (जैसे कि आंतरिक षट्भुज की पूरी रूपरेखा) संभवतः हेक्सा-ग्लिफ़ के रूप में प्रकट नहीं हो सकते हैं, और इसलिए आपको प्रोग्राम को इनका उत्पादन नहीं करना चाहिए।

3. आउटपुट एक चित्रमय छवि (स्क्रीन या फ़ाइल के लिए मुद्रित) होना चाहिए।

4. षट्भुज नियमित होना चाहिए, लेकिन किसी भी अभिविन्यास में दिखाई दे सकता है।

5. प्रतिबिंब / घुमाव को अद्वितीय नहीं माना जाता है। (यह आवश्यकता का पालन करने के लिए 1 आसान बना सकता है)।

Comments

I made up while doodling during my DiffEq class। जिस तरह से सभी महान खोजें होती हैं ...: पी

— R

छवि के लिए न्यूनतम आवश्यकताएं क्या हैं? ASCII कला को किस सीमा तक पहचाना जाना चाहिए, जब तक कि प्रत्येक किनारे का प्रतिनिधित्व न किया जाए और सही जगह पर रखा जाए?

— जॉन ड्वोरक

@JanDvorak I ने चुनौती के ASCII कला विकल्प (जैसे पोस्ट करने के 2 मिनट के भीतर) को हटा दिया क्योंकि ASCII- कला और चित्रमय आउटपुट उत्पन्न करने वाले प्रोग्राम आसानी से तुलनीय नहीं हैं।

— PhiNotPi

पिक्सेल कला के बारे में क्या? एक PPM हेडर बहुत भारी नहीं है, और बाद में अंतर केवल '01'इसके स्थान पर उपयोग किए जाने वाले स्थान के साथ उपयोग किया जाता है ' *'।

— जॉन ड्वोरक

@JanDvorak आउटपुट तब एक ठीक से स्वरूपित छवि फ़ाइल होगी, है ना? तब मुझे इसमें कुछ गलत नहीं लगता।

— PhiNotPi

Answer 1

गणितज्ञ, 273 268 264 242 बाइट्स

c=CirclePoints;b@_=k=1>0;Graphics[Line/@Cases[Append[Join@@({c@6,{3^.5/2,-Pi/6}~c~6}),{0,0}][[b@#=!k;#]]&/@TakeWhile[#,t=k;(r=t;t=b@#;r)&]&/@Join@@RandomSample[{#,Reverse@#}&/@Partition[Range@12,3,2,1]~Join~Array[{2#,13,2#+6}&,3]],{_,__}]]

एक सुपरस्क्रिप्ट के रूप में प्रस्तुत करने Tमेथेमेटिका में और एक पोस्टफ़िक्स पक्षांतरित ऑपरेटर है।

इस में कीड़े को हमेशा के लिए छाँट लिया ... अंत में मैंने इसे काम करने के लिए कुछ चीजों को एक साथ हैक कर लिया, इसलिए यह निश्चित रूप से सबऑप्टिमल है। मुझे यह भी आश्चर्य है कि क्या बाहरी हेक्सागोन की तर्ज पर विशेष रूप से कल्पना को लागू करने के लिए समग्र रूप से बेहतर हो सकता है और मैथेमेटिका के ज्यामिति कार्यों को चौराहों को संभालने दें।

ध्यान दें कि यह एक पूर्ण कार्यक्रम है और यदि आप एक ही REPL सत्र के भीतर कोड को कई बार चलाना चाहते हैं, तो आपको इसके साथ उपसर्ग करना होगा Clear[b]।

यहाँ 20 रन के परिणाम हैं:

व्याख्या

यह समाधान बाहरी स्टार बिंदुओं का उपयोग बिल्कुल नहीं करता है। इसके बजाय यह सीधे उन बिंदुओं के साथ काम करता है जो हेक्साग्लाइफ का हिस्सा हैं और एक समय में उनमें से तीन को कवर करने वाली रेखाएं हैं।

चलो अंक लेबल:

1थोड़ा अजीब कोने पर शुरू होता है लेकिन यह (कुछ हद तक अजीब) डिफ़ॉल्ट व्यवहार के कारण होता है CirclePoints। वहाँ से षट्भुज शुरू करना सबसे सस्ता निकला।

अब हम उन तीन बिंदुओं के माध्यम से संबंधित लाइनों को खोजना चाहते हैं जो बाहरी तारे के जुड़े बिंदुओं के अनुरूप हैं। हेक्सागोन के आसपास के लोग बेशक 3 आसन्न बिंदु (मॉडुलो 12) हैं, जो एक विषम संख्या से शुरू होते हैं। पूरे केंद्र में एक सम संख्या होती है n, 13और n+6।

इन पंक्तियों के प्रतिनिधित्व (तीन बिंदुओं की सूचियों के रूप में निम्नलिखित कोड द्वारा उत्पन्न होते हैं):

Partition[Range@12,3,2,1]~Join~Array[{2#,13,2#+6}&,3]

Partitionषट्भुज के आसपास लाइनों और उत्पन्न Arrayलाइनों केंद्र के माध्यम से। दोनों बीमों को संसाधित करने के लिए, हम इस फ़ंक्शन को लाइनों की सूची में मैप करते हैं:

{#,Reverse@#}&

अब हम इन्हें RandomSampleयादृच्छिक क्रम में संसाधित करने के लिए फेरबदल करते हैं । Join @@जोड़े की सूची को समतल करता है ताकि हमारे पास बीम की एक सूची हो।

लघु मध्यांतर: जिन बिंदुओं पर पहले से रोक है, उन पर नज़र रखने के लिए हम एक लुकअप फ़ंक्शन का उपयोग करते हैं b, जिसे Trueसभी मानों के लिए प्रारंभ किया जाता है b@_=k=1>0;। एक बीम को संसाधित करते समय हम पहले बिंदु तक सभी बिंदु रखते हैं, जिसमें b[n] == False( उस एक सहित ):

TakeWhile[#,t=k;(r=t;t=b@#;r)&]&

मुझे ऐसा लगता है कि यह अभी सबसे गोल्फ का हिस्सा है ... मास्टरमाइंड को खेलने के लिए दो अस्थायी चर का उपयोग वास्तव में महंगा लगता है। वैसे भी, इसका परिणाम हमें एक पंक्ति में अंक देता है जिसे हम आकर्षित करने की अनुमति देते हैं। अब यह फ़ंक्शन उन प्रत्येक बिंदुओं पर मैप किया गया है:

Append[Join@@({c@6,{3^.5/2,-Pi/6}~c~6}),{0,0}][[b@#=!k;#]]&

पहला भाग सभी 13 बिंदुओं की सूची उत्पन्न करता है, जिसमें दो कॉलों के बीच के परिणाम CirclePoints(बढ़त केंद्रों और षट्भुज के कोनों के लिए अलग-अलग राड के साथ) का उपयोग किया जाता है। ध्यान दें कि b@#=!kअब वर्तमान बिंदु के लिए लुकअप तालिका का मान सेट करता है Falseताकि कोई और बीम इसके माध्यम से न गुजर सके। अंत में, मान का उपयोग सही 2D बिंदु प्राप्त करने के लिए निर्देशांक की सूची में एक सूचकांक के रूप में किया जाता है।

Cases[...,{_,__}]

यह सभी एकल-तत्व सूचियों को अलग करता है, क्योंकि वे व्यक्तिगत (और दृश्यमान) बिंदुओं के रूप में प्रस्तुत करेंगे। अंत में हम परिणाम प्रस्तुत करते हैं:

Graphics[Line/@...]

Comments

b@_=1>0=b=1>0&

— कैलक्यूलेटरफैनलाइन

@CatsAreFluffy मुझे नहीं लगता कि वह काम करता है, क्योंकि मुझे बाद में व्यक्तिगत मूल्यों को अधिलेखित करने में सक्षम होने की आवश्यकता है।

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

CirclePoints का अच्छा उपयोग।

— डेविडक्र्स

मैंने उस Youtube लिंक की सराहना की।

— 5

Answer 2

जूते (रूबी) Rev C 184 बाइट्स

12 बाइट्स चेकिंग के लिए जिम्मेदारी को हस्तांतरित करके बचाई जाती है, यदि मुख्य कार्यक्रम से ड्राइंग विधि के लिए एक विशेष अर्ध-रेखा खींची जानी चाहिए। मुख्य कार्यक्रम को अभी भी जांचना है कि क्या पूरी लाइन पूरी तरह से अवरुद्ध है, हालांकि।

Shoes.app{t=[]
d=->p,q{t[p]&&t[q]||line(p/6*8,p%6*14,q/6*8,q%6*14)}
%w{1I IW WM M5 5' '1 =A P. R,}.shuffle.map{|i|b=i.sum/2
c=b*2-a=i.ord
t[a]&&t[c]||(d[a,b]
d[b,c]
t[a]=t[b]=t[c]=1)}}

जूते (रूबी) 205 ... रेव बी 196 बाइट्स

जीयूआई के निर्माण के लिए जूते एक रूबी-आधारित उपकरण है यह पहली बार है जब मैंने इसका उपयोग किया है। mothereff.in/byte-counter मेरी सबमिशन को 196 बाइट्स के रूप में गिनता है, लेकिन किसी कारण से शूज़ इसे 202 के रूप में गिना जाता है।

इसके अलावा, रूबी आपको चीजों को करने देती है t[a=i.ord]लेकिन अजीब तरह से, यह जूते के साथ अपेक्षा के अनुरूप काम नहीं करता है।

Shoes.app{t=[]
d=->p,q{line(p/6*8,p%6*14,q/6*8,q%6*14)}
%w{1I IW WM M5 5' '1 =A P. R,}.shuffle.map{|i|b=i.sum/2
c=b*2-a=i.ord
t[a]&&t[c]||(t[a]&&t[b]||d[a,b]
t[b]&&t[c]||d[b,c]
t[a]=t[b]=t[c]=1)}}

व्याख्या

मैं षट्भुज के बाहर लाइन के हिस्सों पर विचार नहीं करता। मैं केवल वह हिस्सा खींचता हूं जिसे खींचने की जरूरत है। महत्वपूर्ण बात यह है कि क्या लाइनें चौराहों को पार करती हैं (यदि हम केवल उन हिस्सों को खींचते हैं जिन्हें खींचने की आवश्यकता है, इसका मतलब है कि वे चौराहों पर शुरू / समाप्त होते हैं।)

मूल नियम यह है कि यदि किसी रेखा के दोनों छोरों का दौरा किया गया है, तो रेखा अवरुद्ध है और उसे खींचा नहीं जाना चाहिए। जैसा कि लाइनें दो हिस्सों में खींची गई हैं, हमें यह भी जांचना होगा कि क्या मध्यबिंदु का दौरा किया गया है या नहीं यह देखने के लिए कि प्रत्येक आधे को खींचा जाना चाहिए या नहीं।

मैं इस बात का ध्यान रखता हूं कि कौन से बिंदु सरणी में गए हैं t[]। यह नीचे ग्रिड पर प्रत्येक भौतिक समन्वय के लिए एक प्रविष्टि समाप्‍त करता है। अलग-अलग 13-तत्व तार्किक सरणी नहीं है। अंत तक, t[]इसमें 87 तत्व हो सकते हैं, हालांकि केवल 13 तक ही उपयोगी डेटा होगा।

आंतरिक रूप से, लाइनों के अंत बिंदुओं के निर्देशांक एक एकल संख्या z द्वारा दिए जाते हैं, जहां z% 6 y समन्वय है और z / 6 x समन्वय है। इस प्रणाली में षट्कोण को समतल किया जाता है। जब लाइनों को प्लॉट किया जाता है, तो x स्केल को 8 से गुणा किया जाता है और y स्केल को 14 से गुणा किया जाता है, जो कि सही अनुपात के लिए एक बहुत करीब तर्कसंगत सन्निकटन है: 14/8 = 1.75 बनाम sqrt (3) = 1.732।

आंतरिक समन्वय प्रणाली नीचे दिखाया गया है, कुछ नमूना आउटपुट के साथ।

Ungolfed

Shoes.app{
  t=[]                                          #Empty array for status tracking
  d=->p,q{line(p/6*8,p%6*14,q/6*8,q%6*14)}      #Drawing method. Convert p and q into x,y pairs, scale and draw line.
  %w{1I IW WM M5 5' '1 =A P. R,}.shuffle.map{|i|#take an array of the coordinates of the endpoints of each line, shuffle, then for each line
    b=i.sum/2                                   #b = midpoint of line, convert ASCII sum to number (average of the two coordinates)
    a=i.ord                                     #a = first endpoint of line, convert ASCII to number (no need to write i[0].ord)
    c=b*2-a                                     #c = second endpoint of line (calculating is shorter than writing i[1].ord)
    t[a]&&t[c]||(                               #if both endpoints have already been visited, line is completely blocked, do nothing. ELSE
      t[a]&&t[b]||d[a,b]                        #if first endpoint and midpoint have not both been visited, draw first half of line
      t[b]&&t[c]||d[b,c]                        #if second endpoint and midpoint have not both been visited, draw second half of line
      t[a]=t[b]=t[c]=1                          #mark all three points of the line as visited
    )
  }
}

अधिक नमूना आउटपुट

ये कार्यक्रम के पुराने संस्करण के साथ किए गए थे। अंतर केवल इतना है कि विंडो में हेक्साग्लाइफ की स्थिति अब थोड़ी अलग है।

Comments

mothereff.in/byte-counter counts my submission as 196 bytes, but for some reason Shoes counts it as 202.अगर यह सच है तो मुझे 100% पता नहीं है, लेकिन मुझे लगता है कि यह कारण है कि जूतों ने आपके कोड को 196 के बजाय 202 बाइट्स के रूप में गिना है, क्योंकि आपके न्यूलाइन्स वास्तव में एक दो वर्ण अनुक्रम "\ r \ n" हैं। इससे हर न्यूलाइन की दो बार गिनती हो जाती है। यहाँ \ r और \ n के संबंध में एक ढेर अतिप्रवाह उत्तर दिया गया है।

— के झांग

Hehe मैं जूते XD के साथ रूबी नाम पर नहीं मिल सकता

— बीटा Decay

Answer 3

अजगर, 604 591 574 561 538 531 536 534 528 493 483 452 431 420 419 415 388 385 384 बाइट्स

मैंने लेवल रिवर सेंट के जाँच के विचार को अनुकूलित कर लिया है कि क्या लाइन की जाँच करने से कोई रेखा अवरुद्ध हो जाएगी यदि लाइन के दोनों समापन बिंदु पहले ही देखे जा चुके हैं। इससे 27 बाइट बचती हैं। गोल्फ सुझाव का स्वागत करते हैं।

संपादित करें:g(p,q) 3 बाइट्स के लिए बग फिक्सिंग और गोल्फिंग । Lएक बाइट के लिए गोल्फ ।

from turtle import*
from random import*
R=range
G=goto
*L,=R(9)
shuffle(L)
a=[0]*13
ht()
T=12
c=[(j.imag,j.real)for j in(1j**(i/3)*T*.75**(i%2/2)for i in R(T))]+[(0,0)]
def g(p,q):pu();G(c[p]);a[p]*a[q]or pd();G(c[q])
for m in L:
 p=2*m;x,y,z=R(p,p+3)
 if m<6:
  if a[x]*a[z%T]<1:g(x,y);g(y,z%T);a[x]=a[y]=a[z%T]=1
 else:
  if a[p-11]*a[p-5]<1:g(p-11,T);g(p-5,T);a[p-11]=a[p-5]=a[T]=1

Ungolfing:

from turtle import*
from random import*

def draw_line(points, p_1, p_2):
    penup()
    goto(points[p_1])
    if not (a[p] and a[q]):
        pendown()
    goto(points[p_2])

def draw_glyph():
    ht()
    nine_lines = list(range(9))
    shuffle(nine_lines)
    size = 12
    center = [0,0]

    points = []
    for i in range(12):      # put in a point of a dodecagon
                             # if i is even, keep as hexagon point
                             # else, convert to hexagon midpoint
        d = 1j**(i/3) * 12   # dodecagon point
        if i%2:
            d *= .75**.5     # divide by sqrt(3/4) to get midpoint
        points += (d.imag, d.real)
    points.append(center)

    a = [0]*13
    for m in nine_lines:
        p = 2*m
        if m<6:
            x, y, z = p, p+1, p+2
            if not (a[x] and a[z%12]):
                draw_line(points, x, y)
                draw_line(points, y, z%12)
                a[x] = a[y] = a[z%12] = 1
        else:
            if not (a[p-11] and a[p-5]):
                draw_line(p-11, 12)
                draw_line(p-5, 12)
                a[p-11] = a[p-5] = a[12] = 1

हेक्सा-ग्लिफ़्स स्वयं काफी छोटे होते हैं क्योंकि हम एक 12-पिक्सेल हेक्सागोन को आधार के रूप में उपयोग करते हैं (गोल्फ कारणों के लिए)। यहाँ कुछ उदाहरण हेक्सा-ग्लिफ़ (गरीब फसल के लिए माफी) हैं:

Comments

कुछ बाइट बचा सकता है:R=range;G=goto

— टिम