एक सर्पिल अनुक्रम

Question

पृष्ठभूमि

OEIS अनुक्रम A272573 एक हेक्सागोनल ग्रिड पर एक सर्पिल का वर्णन इस प्रकार है:

एक हेक्सागोनल टाइलिंग पर संख्याओं का एक सर्पिल शुरू करें, प्रारंभिक षट्भुज के साथ एक (1) = 1. ए (एन) के रूप में सबसे छोटा सकारात्मक पूर्णांक है जो इसके पड़ोसियों के बराबर या पहले नहीं है।

क्रम शुरू होता है

1, 2, 3, 4, 5, 6, 7, 4, 6, 8, 5, 9, 8, 10, 2, 11, ...

यहाँ सर्पिल पैटर्न का एक चित्रण है:

• a(11) != 1क्योंकि तब 3और 1दो स्थानों पर आसन्न होगा।
• a(11) != 2क्योंकि तब 3और 2दो स्थानों पर आसन्न होगा।
• a(11) != 3क्योंकि तब 3खुद से सटे होंगे।
• a(11) != 4क्योंकि तब 3और 4दो स्थानों पर आसन्न होगा।
• इसलिए a(11) = 5।

चुनौती

A272573 की गणना करने वाले प्रोग्राम को लिखना चुनौती है । यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

Comments

मैं छवि को देख नहीं सकता क्योंकि यह यहां अवरुद्ध है, इसलिए शायद मैं कुछ याद कर रहा हूं, लेकिन आपका उदाहरण एक (11) = 4 दिखाता है, लेकिन आपकी अनुक्रम सूची में एक (11) 5. है

— जियोबिट्स

बस एक गलती - इसे पकड़ने के लिए धन्यवाद।

— पीटर कैगी

इस OEIS अनुक्रम को स्वयं द्वारा प्रस्तुत किया गया था, जाहिरा तौर पर। अच्छा लगा। :)

— अरनौलड

n की सीमा क्या है? क्या कोई समय सीमा है?

— सेट

हेक्सागोनी उत्तर की प्रतीक्षा में ...

— जोनाथन एलन

Answer 1

जावास्क्रिप्ट (ईएस 6),  267 .. 206  199 बाइट्स

अनुक्रम के $N$ पहले शब्दों से युक्त एक सरणी देता है ।

n=>(F=v=>++i<n?F([...v,(A=N[i]=[1,!j++||d+1,j%L?d:(j%=L*6)?++d:L++&&d++].map(k=>N[k=i-k].push(i)&&k),g=k=>v[E='every']((V,x)=>V-k|N[x][E](y=>A[E](z=>v[y]-v[z])))?k:g(-~k))()]):v)([L=1],N=[[i=j=d=0]])

इसे ऑनलाइन आज़माएं!

कैसे?

परिभाषाएं

कन्वेंशन द्वारा, हम कॉर्नर-सेल को एक सेल कहेंगे, जिसमें सर्पिल की पिछली परत के साथ केवल एक किनारे होता है और साइड-सेल एक सेल होता है जिसमें पिछली परत के साथ सामान्य रूप से दो किनारे होते हैं। जैसा कि Ourous द्वारा सुझाया गया है, हम उन्हें क्रमशः क्रम -1 कोशिकाएँ और क्रम -2 कोशिकाएँ भी मान सकते हैं।

कॉर्नर-कोशिकाओं को नीचे पीले रंग में दिखाया गया है। अन्य सभी कोशिकाएं साइड-सेल हैं (केंद्र सेल को छोड़कर जो एक विशेष मामला है)।

सेल पड़ोसियों के बारे में

हमें वास्तव में ग्रिड पर कोशिकाओं के निर्देशांक का ट्रैक रखने की आवश्यकता नहीं है। केवल एक चीज जो हमें जानने की आवश्यकता है वह किसी भी समय सर्पिल में प्रत्येक कोशिका के लिए पड़ोसी कोशिकाओं की सूची है।

निम्नलिखित आरेखों में, पिछली परत में पड़ोसियों को हल्की छाया में दिखाया गया है और वर्तमान परत में अतिरिक्त पड़ोसियों को गहरे रंग की छाया में दिखाया गया है।

एक सेल में पिछली कोशिकाओं के बीच 2 पड़ोसी हैं यदि:

• यह एक नई परत का पहला साइड-सेल है (जैसे 8 )
• या यह एक कोना-कक्ष है, लेकिन परत के अंतिम एक नहीं (जैसे 9 )

एक सेल में पिछली कोशिकाओं के बीच 3 पड़ोसी हैं यदि:

• यह एक साइड-सेल है, लेकिन लेयर का पहला नहीं है (जैसे 10 )
• या यह वर्तमान परत का अंतिम कोना-कक्ष है (जैसे 19 )

सेल पड़ोसियों का कार्यान्वयन

$1$$i$$n$$A[n]$

$1$$-1$

[                    //
  1,                 // the previous cell is always a neighbor of the current cell
  !j++ || d + 1,     // if this is not the first cell of the layer, the cell at -(d + 1)
                     // is a neighbor (otherwise, we insert 1 twice; doing it that way
                     // saves bytes and having duplicate neighbors is not a problem)
  j % L ?            // if this is a side-cell:
    d                //   the cell at -d is a neighbor
  :                  // else (corner-cell):
    (j %= L * 6) ?   //   if this is not the last cell:
      ++d            //     insert the dummy duplicate neighbor at -(d + 1); increment d
    :                //   else (last cell):
      L++ && d++     //     the cell at -d is a neighbor; increment L; increment d
]                    //

उपरोक्त कोड में:

• $L$$1$
• $j$$1$$6\times L$
• $d$

map()$k$$i-k$

.map(k =>
  N[k = i - k].push(i) && k
)

अनुक्रम का अगला शब्द खोजना

$k$

$n$$v[n]$

( g =                 // g = recursive function taking
  k =>                // the candidate value k
    v.every((V, x) => // for each previous cell of value V at position x, make sure that:
      V - k           //   V is not equal to k
      |               //   OR
      N[x].every(y => //   for each neighbor y of x:
        A.every(z =>  //     for each neighbor z of the current cell:
          v[y] - v[z] //       the value of y is not equal to the value of z
        )             //     end
      )               //   end
    )                 // end
    ?                 // if the above conditions are fulfilled:
      k               //   stop recursion and return k
    :                 // else:
      g(-~k)          //   try again with k + 1
)()                   // initial call to g with k undefined (this will cause V - k to be
                      // evaluated as NaN and force the 1st iteration to fail)

Comments

महान व्याख्या। एक संभावित सुधार: क्षैतिज स्क्रॉलिंग की आवश्यकता के बिना पूरी तरह से दिखाई देने वाले कोड ब्लॉक में स्पष्टीकरण बनाना (गोल्फ कोड के लिए कोई फर्क नहीं पड़ता)। फ़ायरफ़ॉक्स में देखना, पहले स्पष्टीकरण कोड ब्लॉक में 5 छिपे हुए कॉलम हैं, और दूसरे में 6 छिपे हुए कॉलम हैं।

— ट्राइकोप्लाक्स

@trichoplax आपकी टिप्पणी और सुझाव के लिए धन्यवाद। क्या आप फ़ायरफ़ॉक्स के किस संस्करण का उपयोग कर रहे हैं और किस प्लेटफ़ॉर्म पर निर्दिष्ट कर सकते हैं? मैं हमेशा स्पष्टीकरण ब्लॉकों को प्रारूपित करने की कोशिश करता हूं ताकि कोई क्षैतिज स्क्रॉलिंग की आवश्यकता न हो। मैं अभी फ़ायरफ़ॉक्स 65 / Win10 पर हूँ और मेरे पास कोई छिपा हुआ कॉलम नहीं है।

— Arnauld

जब मैं घर पहुंचूंगा तो फ़ायरफ़ॉक्स के संस्करण की जांच करूंगा, लेकिन हो सकता है कि मैं फेडोरा पर हूं। दूसरे ओएस पर जांच करेंगे और आपको बताएंगे

— ट्राइकोप्लाक्स

यह ओएस द्वारा भिन्न होता है। एमएसई पर इसे बढ़ाएंगे जब मुझे कुछ सबूत इकट्ठा करने का मौका मिला है (यदि यह पहले से ही नहीं हुआ है)

— ट्राइकोप्लाक्स

मैंने इसे MSE पर उठाया है । यदि कोई अन्य OS / ब्राउज़र संयोजन देखता है जो क्षैतिज स्क्रॉल बार दिखाता है, तो उसे संपादित करने के लिए स्वतंत्र महसूस करें।

— ट्राइकोप्लाक्स

Answer 2

क्लीन , 284 279 272 262 बाइट्स

import StdEnv
l=[0,-1,-1,0,1,1]
c(u,v)(p,q)=(u-p)^2+(v-q)^2<2||(u-p)*(q-v)==1
$[h:t]m=hd[[e: $t[(h,e):m]]\\e<-[1..]|and[e<>j\\(u,v)<-m|c h u,(p,q)<-m|q==v,(i,j)<-m|c p i]]

$(scan(\(a,b)(u,v)=(a-u,b-v))(0,0)[(i,j)\\n<-[1..],i<-[1,1:l]&j<-l,_<-[max(~j<<i)1..n]])[]

इसे ऑनलाइन आज़माएं!

क्रम को हमेशा के लिए पैदा करता है।

षट्भुज मानचित्रण

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

मैप किए गए अंक इस तरह दिखते हैं:

              ---
        --- < 2,-2> ---       x-axis ___.X'
  --- < 1,-2> === < 2,-1> ---  /__.X'
< 0,-2> === < 1,-1> === < 2, 0>'
  === < 0,-1> === < 1, 0> ===
<-1,-1> === < 0, 0> === < 1, 1>
  === <-1, 0> === < 0, 1> ===
<-2, 0> === <-1, 1> === < 0, 2>.__
  --- <-2, 1> === <-1, 2> ---  \  'Y.___
        --- <-2, 2> ---       y-axis    'Y.
              ---

वहाँ से, आसन्न का निर्धारण तुच्छ है, और तब होता है जब एक:

• x1 == x2 तथा abs(y1-y2) == 1
• y1 == y2 तथा abs(x1-x2) == 1
• y1 == y2 - 1 तथा x2 == x1 - 1
• y1 == y2 + 1 तथा x2 == x1 + 1
• x1 == x2 तथा y1 == y2

प्वाइंट जनरेशन

ध्यान दें कि जब सर्पिल में षट्भुज को पार करते हैं तो प्रत्येक परत के लिए अंतर पुनरावृत्ति होते हैं n:

1. n के कदम (1,0)
2. n-1 के कदम (1,-1)
3. n के कदम (0,-1)
4. n के कदम (-1,0)
5. n के कदम (-1,1)
6. n के कदम (0,1)

यह इस क्रम के उपसर्गों की रकम लेकर सही क्रम में अंक उत्पन्न करता है:

scan(\(a,b)(u,v)=(a-u,b-v))(0,0)[(i,j)\\n<-[1..],i<-[1,1:l]&j<-l,_<-[max(~j<<i)1..n]]

साथ लाना

कोड जो वास्तव में प्रश्न से अनुक्रम पाता है, वह है:

$[h:t]m=hd[[e: $t[(h,e):m]]\\e<-[1..]|and[e<>j\\(u,v)<-m|c h u,(p,q)<-m|q==v,(i,j)<-m|c p i]]

बदले में, ज्यादातर फ़िल्टरिंग द्वारा किया जाता है and[r<>j\\(u,v)<-m|c h u,(p,q)<-m|q==v,(i,j)<-m|c p i]

यह फ़िल्टर m(पहले से मैप किए गए बिंदुओं की सूची) से अंक लेता है:

• प्राकृतिक संख्याओं को अनदेखा करना जो किसी के बराबर हैं j
• हर (i,j)जहाँ के iलिए आसन्न हैp
• प्रत्येक के लिए (p,q)जहां मूल्य qके बराबर हैv
• प्रत्येक के लिए (u,v)जहां uवर्तमान बिंदु से सटे हैं