टाइलिंग, दिए गए शीर्ष विन्यास


11

कार्य

कार्य बहुभुज है, जिसे एक शीर्ष विन्यास दिया गया है।

स्कोरिंग

आपका स्कोर "जटिलता स्तर" के बराबर है जो आपकी अधीनता तक पहुँचता है। जटिलता स्तर संचयी हैं, जिसका अर्थ है कि # 3 तक पहुंचने के लिए आपको # 1 & # 2 का भी समर्थन करना चाहिए।

एक समान जटिलता स्तर पर प्रस्तुतियाँ बाइट काउंट द्वारा प्रतिष्ठित होती हैं; सबसे कम जीत।

इनपुट

इनपुट एक स्ट्रिंग है जिसमें एक शीर्ष विन्यास होता है, जो एक शीर्ष आंकड़ा का प्रतिनिधित्व करता है। यही है, पूर्णांक की एक अलग-अलग सूची, जहां प्रत्येक पूर्णांक (एन) एक सामान्य एन-गॉन का प्रतिनिधित्व करता है, जो एक सामान्य शीर्ष से जुड़ा होता है।

निम्नलिखित शीर्ष विन्यास का समर्थन किया जाना चाहिए:

  • 3.3.3.3.3.3
  • 3.3.3.3.6
  • 3.3.3.4.4 (ध्यान दें कि ऑर्डर वर्टेक्स फिगर में परिलक्षित होता है, इसलिए नीचे भिन्न है)
  • 3.3.4.3.4
  • 3.12.12
  • 3.4.6.4
  • 3.6.3.6
  • 4.4.4.4
  • 4.6.12
  • 4.8.8
  • 6.6.6

आउटपुट - जटिलता स्तर # 1: वर्टेक्स चित्रा

इस जटिलता स्तर पर, आउटपुट एक छवि है जो दिए गए इनपुट के अनुरूप वर्टेक्स आंकड़ा दिखाती है।

इनपुट के साथ Fसंकेत दिया गया है कि यह इंगित करने के लिए कि शीर्ष आंकड़ा आउटपुट होना चाहिए, न कि पूर्ण टाइलिंग।

उदाहरण के लिए F3.6.3.6इस शीर्ष आंकड़ा देता है:

3.6.3.6 शीर्ष आंकड़ा

आउटपुट - जटिलता स्तर # 2: टाइलिंग

इस जटिलता के स्तर पर आउटपुट एक छवि है जो दिए गए इनपुट के अनुरूप वर्टेक्स आंकड़ा का उपयोग करके एक समान टाइलिंग दिखाती है ।

उदाहरण के लिए 3.6.3.6यह टाइलिंग देता है:

3.6.3.6 टाइलिंग

रंग या प्रारूप (बैरिंग लूपोल्स) पर कोई प्रतिबंध नहीं है।

आउटपुट - जटिलता स्तर # 3: दोहरी टाइलिंग

इस जटिलता स्तर पर प्रत्येक टाइलिंग से एक 'दोहरी टाइलिंग' बनाई जा सकती है। यह प्रत्येक बहुभुज के केंद्र से प्रत्येक सीमावर्ती बहुभुज के केंद्र तक रेखाएं खींचकर प्राप्त किया जाता है।

दोहरी टाइलिंग एक के साथ इनपुट प्रस्तुत करने द्वारा निर्दिष्ट की गई है V

उदाहरण के लिए V3.6.3.6यह दोहरी टाइलिंग देता है (लाल रंग में):

V3.6.3.6 टाइलिंग


इनमें से कुछ झुकावों के पर्यायवाची हैं। उदाहरण के लिए निम्नलिखित सभी एक ही कर रहे हैं: 3.3.3.4.4 3.3.4.4.3 3.4.4.3.3 4.4.3.3.3 4.3.3.3.4। क्या हमें सभी समानार्थक शब्दों का समर्थन करना है, या सिर्फ लेक्सिकली सबसे कम एक (जैसा कि प्रश्न में दिया गया है)? इसके अलावा, 3.3.3.3.6दो दर्पण छवि रूपों में मौजूद है। मैं समझता हूं या तो स्वीकार्य है।
लेवल रिवर सेंट

आपके द्वारा जोड़ा गया पृष्ठ दी गई सूची से मेल नहीं खाता है। 3.3.3.4.4उदाहरण के लिए गायब है। en.wikipedia.org/wiki/… आपकी सूची से बिल्कुल मेल खाता है। मैं समझता हूं कि रूपरेखा या भरे हुए बहुभुज स्वीकार्य हैं (या दोनों का संयोजन?) कुछ ड्यूल पहले से ही सूची में हैं। उदाहरण के लिए 4.4.4.4दोहरी अपनी ही है और 3.3.3.3.3.3और 6.6.6mutally दोहरी कर रहे हैं। जैसा कि दोहरे अपने माता-पिता के स्वतंत्र रूप से प्रदर्शित होते हैं, मैं समझता हूं कि माता-पिता के साथ सही संरेखण की कोई आवश्यकता नहीं है।
लेवल रिवर सेंट

आपको इनपुट का समर्थन करना चाहिए क्योंकि यह सूची में दिखाई देता है - आप समानार्थक शब्द का समर्थन कर सकते हैं लेकिन आपके पास नहीं है - आपको सभी दोहरे, यहां तक ​​कि स्वयं-दोहरे का समर्थन करना चाहिए।
jsh

रूपरेखा / भरा - दोनों तरह से ठीक। किसी भी स्टाइल को लूपहोल्स के अलावा अनुमति दी जाती है (सब कुछ सफेद कर दें, ड्राइंग क्षेत्र को छोटा कर दें आदि)। संरेखण की आवश्यकता नहीं है। मैं आपको बता सकता हूं कि आपको एक प्रतिबिंब का उपयोग करने की अनुमति नहीं है 3.3.3.3.6लेकिन आप यह कैसे जान पाएंगे कि यह कौन सा है? :)
jsh

अब आपने स्कोरिंग बदल दी है, टाई-ब्रेक क्या है? क्या वह अब भी सबसे छोटा कोड है? यदि ऐसा है, तो क्या शीर्ष विन्यास को डॉट्स द्वारा सीमांकित किया जाना है या हम कॉमा या अंतरिक्ष जैसे किसी अन्य प्रतीक को चुन सकते हैं?
लेवल रिवर सेंट

जवाबों:


9

बीबीसी बेसिक

Rev 1 गोल्फ कोड, 655 ASCII वर्ण, टोकन फ़ाइलें 614

डेटा तालिका में कुछ बड़े सुधार, स्ट्रिंग A.B..Nको एक नंबर तक देखने (1*A+2*B+..n*N)+nसे पहले हैशिंग द्वारा , और केवल एक अनुवाद वेक्टर (दूसरे को कोड द्वारा जनरेट किया गया है।) अधिक स्पष्टीकरण जब मैंने गोल्फ समाप्त किया है।

t=PI*2DIMm(9)
c=0z=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1m(c)=d%i-=d%=12z+=c*d%
NEXTREPEATREADl,e,f
UNTILl=z+c
l=4-3*(m(3)MOD3=0)-8*(l=59)
DATA69,0,70,65,100,35,66,149,0,49,109,0,52,80,0,55,0,189,39,120,0,44,40,40,58,55,95,47,136,0,59,40,0
VDU23,23,3|
FORr=-9TO19FORs=-9TO9a=1+e*(r*2+s)-f*l*s/4b=1+f*(r*2+s)+e*l*s/4p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3)IFe=109ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

Rev 0 गोल्फ कोड, 770 ASCII वर्ण, टोकन फ़ाइलें 728

मैंने यहां जो कुछ किया है वह टिप्पणी, अनावश्यक व्हाट्सएप और उद्धरण चिह्नों को हटा दिया है, और सभी DATAको एक पंक्ति में रखा है। निश्चित रूप से अधिक गोल्फ के लिए जगह है।

t=PI*2DIMm(9)
c=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1:m(c)=d%:i-=d%=12
NEXTREPEATREADl$,e,f,g,h
UNTILMID$(z$,1-(VAL(z$)=0))=l$
DATA3.3.3.3.3.3,240,0,120,70,3.3.3.3.6,200,70,40,210,3.3.3.4.4,80,0,40,150,3.3.4.3.4,-40,150,150,40,3.12.12,300,0,150,260,3.4.6.4,220,0,110,188,3.6.3.6,160,0,80,140,4.4.4.4,80,0,0,80,4.6.12,0,380,330,-190,4.8.8,272,0,136,136,6.6.6,240,0,120,70
VDU23,23,3|
FORr=-9TO19 FORs=0TO9a=1+e*r+g*s
b=1+f*r+h*s
p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3):IFe=220ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

व्याख्या

यह मेरे पिछले स्तर 1 उत्तर की निरंतरता है, लेकिन मैंने इसे अलग से पोस्ट करने का फैसला किया क्योंकि यह लंबा है।

लेवल 2

यह मेरे पिछले उत्तर से मेरे "स्तर 1.5" टेम्पलेट्स के अनुवाद द्वारा प्राप्त किया गया है। प्रत्येक टाइलिंग के लिए दो अनुवाद वैक्टर हार्डकोड किए गए हैं। मैं इस तथ्य का लाभ उठाता हूं कि आधार 80 और ऊंचाई 70 का एक समद्विबाहु त्रिभुज एक समबाहु त्रिभुज का एक बहुत अच्छा सन्निकटन है, और कर्ण वेक्टर के साथ एक सही त्रिभुज (56,56)में कर्ण की लंबाई 80 के करीब है।

स्तर 3

दोहरी को प्लॉट करने के लिए, बहुभुज के एक किनारे की साजिश रचने के बजाय, हम उस छोर के बीच से बहुभुज के केंद्र में एक स्पोक प्लॉट करते हैं। यह किनारे पर समकोण है और 1/TAN/(PI/n)वेक्टर के कई गुना (यू, वी) है जो बदले में किनारे के रूप में आधा है।

दुर्भाग्य से, क्योंकि झुकाव में कुछ बहुभुज 3.3.3.3.6और 3.4.6.4स्पष्ट रूप से प्लॉट नहीं किए गए हैं, उन्हें प्लॉट नहीं किया जाएगा यदि हम केवल ऐसा करते हैं। इसलिए बोली बहुभुज से बाहर तक फैली हुई है। बाहरी विस्तार को चर द्वारा नियंत्रित किया जाता है o

डिफ़ॉल्ट रूप से विस्तार एक त्रिकोण के केंद्र तक पहुंचने के लिए पर्याप्त है, लेकिन इसके लिए 3.4.6.4स्पष्ट रूप से प्लॉट किए गए वर्गों के दोहरी को खींचने के लिए इसे अधिक विस्तारित करने की आवश्यकता है। लापता वर्गों में भरने के लिए पर्याप्त विस्तार तब लागू किया जाता है जब हेक्सागोन और त्रिकोण स्पष्ट रूप से प्लॉट किए जाते हैं, लेकिन सामान्य विस्तार तब लागू किया जाता है जब वर्गों को स्पष्ट रूप से प्लॉट किया जाता है, आसन्न त्रिकोण में स्पैरियस लाइनों से बचने के लिए।

यहां वे बात किए गए एक्सटेंशन के बिना दिखते हैं। दोहरे पैटर्न में छेद स्पष्ट रूप से देखे जा सकते हैं। उत्तर के निचले भाग में मुख्य तस्वीर में सही आउटपुट देखा जा सकता है

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

टिप्पणी कोड

मेरे पिछले उत्तर के अंतर को इनलाइन इंगित किया गया है

  t=PI*2                                          :REM constant Tau = PI*2

  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  REM BLOCK OF NEW CODE to define vectors (e,f) and (g,h) for each possible tiling

  REPEAT
    READ l$,e,f,g,h                               :REM read an entire line of the data below
  UNTIL MID$(z$,1-(VAL(z$)=0))=l$                 :REM abort the loop when l$ coincides with the input. the MID$ strips off the 'V' from the input where necessary.

  DATA"3.3.3.3.3.3",240,0,120,70
  DATA"3.3.3.3.6",200,70,40,210
  DATA"3.3.3.4.4",80,0,40,150
  DATA"3.3.4.3.4",-40,150,150,40
  DATA"3.12.12",300,0,150,260
  DATA"3.4.6.4",220,0,110,188
  DATA"3.6.3.6",160,0,80,140
  DATA"4.4.4.4",80,0,0,80
  DATA"4.6.12",0,380,330,-190
  DATA"4.8.8",272,0,136,136
  DATA"6.6.6",240,0,120,70

  VDU23,23,3|                                           :REM change linewidth to 3 (default is 1)

  REM END BLOCK OF NEW CODE

  FORr=-9TO19 FORs=0TO9                                 :REM two new loops for translations

      a=1+e*r+g*s                                       :REM modified code for
      b=1+f*r+h*s                                       :REM coordinates to start drawing at


      p=40:q=0                                          :REM vector of first line

      FORk=1TOm(c)/2                                    :REM draw half as many vertex figures as there are sides on the last polygon in the list

        FORj=1TOc                                       :REM for each polygon on the list
          n=m(j)                                        :REM n=number of sides
          o=TAN(PI/3): IF e=220 AND n<>4 o=1            :REM new code for the spoke extension 1/o. 

          w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
          q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
          p=w

          u=p:v=q                                       :REM make a local copy of the vector and coordinates
          x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
          MOVE x,y                                      :REM move the graphics cursor to the start without drawing
          FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
            x+=u*2                                      :REM increment x and y by the vector representing the side
            y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later

            REM if z$ begins with a numeric character, draw an edge. If not, change to red and draw a spoke.
            IFVAL(z$) DRAW x,y ELSE GCOL9: LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)             

            w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
            u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
            v=w
          NEXT                                          :REM draw next edge of the current polygon
        NEXT                                            :REM draw next polygon of the current vertex

        p=u:q=v                                         :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
        a=x:b=y                                         :REM copy the position and direction data into p,q,a,b.
      NEXT                                              :REM draw next vertex figure

    NEXT                                                :REM close the two new translation loops
  NEXT

उत्पादन

कार्यक्रम प्रत्येक रन के लिए केवल एक टाइलिंग या दोहरी प्रदर्शन करता है। हालाँकि यह लाल रंग में डुबकी लगाता है। अंतरिक्ष को बचाने के लिए, मैंने नियमित रूप से टाइलिंग के शीर्ष पर दोहरे को सुपरिमिशन करने के लिए स्क्रीन को साफ़ किए बिना कार्यक्रम को दो बार चलाया।

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


8

मेथेमेटिका

लेवल 1 में बुनियादी टाइल टेम्प्लेट होते हैं जो एक प्लेन को टाइल करने के लिए बार-बार मुहर लगाते हैं।

स्तर 2 टाइलिंग करता है।

अभी भी 2 झुकाव हैं जिन्हें मैं हासिल नहीं कर पाया। उन्हें अनुवाद के साथ-साथ रोटेशन की आवश्यकता होती है।

स्तर 1: वर्टेक्स चित्रा (559 बाइट्स)

nGon[n_]:=
{ColorData[46,"ColorList"][[n]],Polygon@Switch[n,
3,{{0,0},{-1/2,.866},{-1,0},{0,0}},
4,{{0,0},{0,1},{-1,1},{-1,0},{0,0}},
6,Table[{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-.5,.866},{i,0,n}],
8,Table[1.31{Cos[i Pi/4],Sin[i Pi/4]}+{-0.5`,1.207},{i,1/2,9}],
_,Table[2{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-0.5176,1.932},{i,1/2,13}]]}
innerAngle[n_]:=180-360/n
g[{}]=0;
g[a_]:=-(Plus@@innerAngle/@a)

h[{{},__,out_}]:=out
h[{list_,angles_,out_}]:=(
z=GeometricTransformation[nGon[l=list[[1]]],RotationTransform[g[angles] Degree]];
h[{Rest@list,Append[angles,l],Append[out,z]}])

परिक्षण

Row[Graphics[{EdgeForm[{Blue}], #}, 
      ImageSize -> 70] & @@ {h[{#, {}, {}}]} & /@ {{3, 3, 3, 3, 3, 
    3}, {3, 3, 3, 3, 6}, {3, 3, 3, 4, 4}, {3, 3, 4, 3, 4}, {3, 12, 
    12}, {3, 4, 6, 4}, {3, 6, 3, 6}, {4, 4, 4, 4}, {4, 6, 12}, {4, 8, 
    8}, {6, 6, 6}}]

टिकटों


स्तर 2: टाइलिंग (690 अतिरिक्त बाइट्स)

नियम प्रत्येक कॉन्फ़िगरेशन के लिए ऑफसेट टाइल और इंडेंट लौटाते हैं।

r मूल कार्य है जो झुकाव का उत्पादन करता है।

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

rules={
{3,6,3,6}-> {2,3.47,0,0},
{4,4,4,4}-> {1,1,0,0},
{6,6,6}-> {3,2.6,1.5,0},
{3,3,3,3,3,3}-> {1.5,1.74,0,.9},
{3,3,3,3,6}-> {2,2.6,-0.4,1.8},

{4,6,12}->{4.2,4.9,0,2.5},
{3,3,4,3,4}-> {1.87,1.86,-.5,-0.5},
{4,8,8}-> {3.4,3.4,0,0},
{3,3,3,4,4}-> {2,1.87,.52,0},
{3,12,12}-> {3.82,6.73,0,0},
{3,4,6,4}-> {1.4,4.3,0(*1.375*)-1,-2.4}};


r[nGons_]:=
Module[{horizHop,vertHop,indent,downIndent},
{horizHop,vertHop,indent,downIndent}=(nGons/.rules);
Graphics[{EdgeForm[{Blue}],Table[GeometricTransformation[h[{#,{},{}}]&/@{nGons},
TranslationTransform[{
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],indent *row,indent Boole[OddQ[row]]]+col horizHop,
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],downIndent *col,downIndent Boole[OddQ[col]]]-row vertHop}]],
{col,0,5},{row,0,4}]},ImageSize-> 250]]

p[nGon_]:=Row[{Graphics[{EdgeForm[{Blue}],h[{nGon,{},{}}]},ImageSize->70],r@nGon}];

परिक्षण

त्रिकोणीय टाइलिंग

p[{3, 3, 3, 3, 3, 3}]

त्रिकोणीय


हेक्सागोनल

p[{6, 6, 6}]

हेक्सागोनल


वर्ग

p[{4, 4, 4, 4}]

वर्ग


अनजान

p[{3, 3, 4, 3, 4}]

archimedes1


छोटा वर्ग

p[{4, 8, 8}]

छोटा वर्ग


trihexagonal

p[{3, 6, 3, 6}]

trihexagonal


हेक्सागोनल काट दिया

p[{3, 12, 12}]

हेक्सागोनल काट दिया


अज्ञात

p[{3, 3, 3, 3, 6}]

sloped


लम्बा त्रिकोणीय

p[{3, 3, 3, 4, 4}]

लम्बा त्रिकोणीय


पता लगाने के लिए झुकाव

बाएं


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

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

@DavidCarraher की शानदार शुरुआत मैंने स्कोरिंग मानदंड में बदलाव किया है जो आपको प्रभावित कर सकता है।
3

अच्छा रहा अब तक! यदि आप अपने क्षैतिज अनुवाद को 3.3.3.3.3.3आधे से कम कर देते हैं , ताकि इकाइयां ओवरलैप हो जाएं, तो आप उन हीरों से छुटकारा पा सकते हैं और उस टाइलिंग को ठीक कर सकते हैं। तुम अब भी पर करने के लिए अधिक है 3.3.3.3.6, 3.4.6.4और 4.6.12यद्यपि।
लेवल रिवर सेंट

पुन 4.6.12 anyone know what it should look like?: सभी आवश्यक झुकाव en.wikipedia.org/wiki/… पर हैं । सवाल पर मेरी टिप्पणी देखें। यह प्रश्न में उल्लिखित एक अलग पृष्ठ है । लेकिन 4.6.12वैसे भी उस पेज पर दिखाया गया है।
लेवल रिवर सेंट

6

आर

चरण 1

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

i=as.numeric(unlist(strsplit(readline(),"[.]")))
e=c()
for(n in 1:length(i)){
    o=sum(c(0,180-360/i[1:n-1]))
    for(z in 1:i[n]){
        e=c(e,(360/i[n])*(z-1)+o)
    }
}
f=pi/180
plot(c(0,cumsum(sin(e*f))),c(0,cumsum(cos(e*f))),type="l")

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

चरण # 1, # 2 और # 3: 1898

अंत में वापस आ गया। इसमें से अधिकांश को ऑफसेट स्थापित करने और विशेष मामलों को संभालने के साथ लिया जाता है :)। संपादित करें: दोहरे के लिए V ध्वज अब संभाला जाता है

सामान्य प्रक्रिया है:

  • इनपुट लें और एक सूची बनाएं
  • प्रारंभिक टाइल खींचने के लिए कोणों की एक सूची बनाएं
  • प्रत्येक बहुभुज के केंद्रों की गणना करें यह टाइल और उन से वैक्टर किनारों को काटने के लिए
  • निर्धारित किए जा रहे टाइल सेट को निर्धारित करें और कोण ऑफसेट की सूची बनाएं। कुछ टाइलों में अतिरिक्त बहुभुज होते हैं जो उन्हें छिद्रों को भरने में सहायता करते हैं।
  • टाइल्स ड्रा करें
  • द्वंद्व ड्रा

मैं शायद अभी भी इसे थोड़ा और अधिक गोल्फ कर सकता हूं।

##Get input (Enter by itself then type in the tile scheme)
i=strsplit(readline(),"[.]")[[1]]
## Run once i is set
q=0
if(substr(i[1],1,1)=="V"){q=1;i[1]=substr(i[1],2,9)}
i=as.numeric(i)
f=pi/180
e=x=y=q=p=c()
l=length(i)
d=1/(2*tan(pi/3))
g=1/(2*sin(pi/3))
for(n in 1:l){o=sum(c(0,180-360/i[1:n-1]))
r=1/(2*sin(pi/i[n]))
a=o+(180-360/i[n])/2
b=1/(2*tan(pi/i[n]))+d
for(z in 1:i[n]){x=c(x,r*sin(a*f))
y=c(y,r*cos(a*f))
q=c(q,b)
p=c(p,(360/i[n])*(z-1)+o-90)
e=c(e,(360/i[n])*(z-1)+o)}}
if(sum(i)==18&l==6){h=c(60,0);w=c(60,120)}
if(sum(i)==18&l==5){h=c(0,0,60);w=c(60,120,60)
e=c(e,0,-60,60,180,60,180)
x=c(x,g*sin(-30*f),g*sin(-30*f),g*sin(90*f))
y=c(y,1+g*cos(-30*f),1+g*cos(-30*f),1)
q=c(q,d+d,d+d,d+d)
p=c(p,-30,90,-30)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==2){h=c(0,0);w=c(90,60)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==4){h=c(0,30);w=c(270,300)}
if(sum(i)==17&l==4){h=c(0,30,-30);w=c(60,30,90)
e=c(e,150,120,210,300)
x=c(x,sin(150*f)+g*sin(90*f),sin(150*f)+sin(210*f)/2)
y=c(y,cos(150*f)+(1/(2*cos(pi/3)))*cos(90*f),cos(150*f)+cos(210*f)/2)
q=c(q,1,1)
p=c(p,210,120)}
if(sum(i)==18&l==4){h=c(0,0);w=c(120,120)}
if(sum(i)==16&l==4){h=c(0,0);w=c(90,90)}
if(sum(i)==27&l==3){h=c(0,-30,0,30);w=c(60,90,120,150,180)}
if(sum(i)==22&l==3){h=c(0,-30,30,90,60,30)
w=c(90,150,120,90,60,30)
e=c(e,0,-30,-60,30,120,210,30,90,150)
q=q-d+1/(2*tan(pi/4));q[13]=q[17]=q[21]=q[21]+3}
if(sum(i)==20&l==3){h=c(0,-45,-90);w=c(90,0,45)}
if(sum(i)==18&l==3){h=c(0,60,0,-60);w=c(0,60,120,60)}
hx=sum(sin(h*f))
hy=sum(cos(h*f))
wx=sum(sin(w*f))
wy=sum(cos(w*f))
plot(0,0,type="n")
par(pin=c(5,5),usr=c(0,20,0,20))
for(c in -20:20){for(j in -20:20){lines(c((c*hx)+(j*wx)+0,(c*hx)+(j*wx)+cumsum(sin(e*f))),c((c*hy)+(j*wy)+0,(c*hy)+(j*wy)+cumsum(cos(e*f))),type="l")
if(q){for(n in 1:length(x)){lines(c((c*hx)+(j*wx)+x[n],(c*hx)+(j*wx)+x[n]+q[n]*sin(p[n]*f)),c((c*hy)+(j*wy)+y[n],(c*hy)+(j*wy)+y[n]+q[n]*cos(p[n]*f)),col="RED")}}}}

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


वाह, मेरे पीछे केवल 4 घंटे। और वे बहुत अच्छे लगते हैं, +1! क्या आपको अभी तक सभी मामले काम कर रहे हैं?
लेवल रिवर सेंट

@steveverrill धन्यवाद और यह प्रश्न के सभी मामलों के लिए काम करता है।
मिकी

4

बीबीसी बेसिक

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर एमुलेटर डाउनलोड करें

स्तर 1

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

स्तर 1.5

स्तर 1.5 मेरा अपना पद है, लेकिन यह मेरी पद्धति का एक महत्वपूर्ण मील का पत्थर है।

वर्टेक्स के आंकड़ों का अनुवाद हमेशा सही टाइलिंग के लिए नहीं होता है। कुछ मामलों में लाइनें गायब हैं।

इसका मेरा समाधान सबसे बड़े बहुभुज के चारों ओर जाना है, उस बहुभुज के हर दूसरे शीर्ष के लिए शीर्ष आंकड़ा आरेखण। यह सभी मामलों के लिए एक सामान्य समाधान है। ध्यान दें कि सबसे बड़े बहुभुज में हमेशा पक्षों की एक समान संख्या होती है और वर्टेक्स का आंकड़ा अक्सर बहुभुज के चारों ओर जाने पर दक्षिणावर्त / एंटीक्लॉकवाइज को वैकल्पिक करता है। यह सबसे स्पष्ट रूप से देखा जा सकता है 4.6.12, लेकिन यह भी सच है 4.8.8और 3.12.12: जब किसी विशेष 8-गॉन या 12-गॉन से देखा जाता है, तो अल्टरनेटिंग वर्ट्स एक दूसरे के दर्पण चित्र होते हैं। यह भी क्या हो रहा है, कुछ कम स्पष्ट रूप से, के साथ 3.3.3.4.4और 3.3.4.3.4: जब किसी विशेष वर्ग से देखा जाता है, बारी-बारी से कोने एक दूसरे के दर्पण चित्र होते हैं।

बहुभुज के चारों ओर 2 पक्षों को स्थानांतरित करने के लिए मैं जिस एल्गोरिथ्म का उपयोग करता हूं, वह हमेशा किनारे-ड्राइंग लूप के 14 पुनरावृत्तियों को करना है, भले ही बहुभुज के कितने किनारे हों। 8 16 का एक कारक है, इसलिए ऑक्टैगन्स को खींचते समय ग्राफिक्स कर्सर 16-14 = 2 वर्टिकल के पीछे समाप्त हो जाता है जहां यह शुरू हुआ था। ३- ४- ६- और १२- गोन्स में सभी पक्ष ऐसे होते हैं जो १२ के कारक होते हैं, इसलिए ग्राफिक्स कर्सर 14-12 = २ कोने तक समाप्त हो जाता है, जहाँ यह शुरू हुआ था।

आंकड़े नीचे देखे जा सकते हैं। कल मुझे उम्मीद है कि टाइलिंग को पूरा करने के लिए सही अनुवादों पर काम किया जाएगा। सभी मामलों में केवल अनुवाद के साथ स्तर 2 को पूरा करने के लिए पर्याप्त रेखाएँ खींची गई हैं। कुछ मामलों में न्यूनतम आवश्यक से अधिक एक बड़ा सौदा खींचा जाता है, लेकिन ओवरलैप के साथ कोई समस्या नहीं है: नियम केवल रेखा खींचने के बारे में कुछ नहीं कहते हैं :-)

सामान्य तौर पर, सबसे बड़ा बहुभुज सूची में अंतिम होता है। दुर्भाग्य से, एक मामला है जहां ऐसा नहीं है: 3.4.6.4इसलिए इस मामले में तैयार किया गया आंकड़ा एक षट्भुज के बजाय एक वर्ग पर केंद्रित है। केवल अनुवादों का उपयोग करके स्तर 2 को पूरा करने के लिए पर्याप्त लाइनें हैं, हालांकि कुछ ऐसे वर्ग हैं जो स्पष्ट रूप से नहीं खींचे गए हैं। यह स्तर 3 में कुछ समस्याएं पेश करेगा (सौभाग्य से मुझे लगता है कि मुझे पता है कि इसे कैसे हल करना है।) इसी तरह 3.3.3.3.6केवल अनुवाद का उपयोग करके स्तर 2 को पूरा करने के लिए पर्याप्त लाइनें हैं, लेकिन कुछ त्रिकोण होंगे जो स्पष्ट रूप से तैयार नहीं हैं।

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

कोड

स्तर 1.5 के लिए कोड टिप्पणी की गई है, केवल स्तर 1 के लिए कोड सक्रिय है। एक के साथ शुरू होने वाली चार लाइनें हैं REMREMस्तर 1.5 को सक्रिय करने के लिए इन को हटा दें ।

  t=PI*2                                          :REM constant Tau = PI*2
  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  FORi=1TOc PRINTm(i),:NEXT                       :REM parsing check for debugging.


  a=601:b=601                                     :REM coordinates to start drawing at
  p=40:q=0                                        :REM vector of first line

  REM FORk=1TOm(c)/2                              :REM draw half as many vertex figures as there are sides on the last polygon in the list

  FORj=1TOc                                       :REM for each polygon on the list
    n=m(j)                                        :REM n=number of sides

    w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
    q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
    p=w

    u=p:v=q                                       :REM make a local copy of the vector and coordinates
    x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
    MOVE x,y                                      :REM move the graphics cursor to the start without drawing
    FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
      x+=u*2                                      :REM increment x and y by the vector representing the side
      y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later
      IFVAL(z$) DRAW x,y ELSE LINEx-u,y-v,x-u,y-v :REM if the first character of the input is a number, draw the side of the polygon. The ELSE part is unfinished and will be for drawing duals.
      w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
      u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
      v=w
    NEXT                                          :REM draw next edge of the current polygon
  NEXT                                            :REM draw next polygon of the current vertex

  REM p=u:q=v                                     :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
  REM a=x:b=y                                     :REM copy the position and direction data into p,q,a,b.
  REM NEXT                                        :REM draw next vertex figure

स्तर 2 और 3

मेरा दूसरा जवाब देखिए।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.