ट्रैप नाइट सीक्वेंस

परिचय

हाल ही के वीडियो द ट्रैप्ड नाइट - नंबरफाइल से प्रेरित होकर , मैं एक चुनौती लेकर आया हूं।

फंस नाइट अनुक्रम लंबाई 2016 1 से शुरू की एक निश्चित पूर्णांक अनुक्रम है, और निम्नलिखित निर्माण नियम हैं:

निम्नलिखित तरीके से एक संख्या सर्पिल लिखें:

17 16 15 14 13 ...
18  5  4  3 12 ...
19  6  1  2 11 ...
20  7  8  9 10 ...
21 22 23 24 25 ...

1 पर एक नाइट रखें।
शूरवीरों को ग्रिड में ले जाएं सबसे छोटी संख्या के साथ यह जा सकता है जो पहले नहीं देखा गया है, शतरंज के नियमों के अनुसार (यानी 2 इकाइयां लंबवत और 1 इकाई क्षैतिज रूप से, या इसके विपरीत)।
तब तक दोहराएं जब तक कि नाइट फंस न जाए।

यहाँ पहले तीन चरण हैं:

चरण 1

 17  [16]  15  [14]  13 
[18]   5    4    3  [12]
 19    6  < 1>   2   11 
[20]   7    8    9  [10]
 21  [22]  23  [24]  25

संभावित चाल 10, 12, 14, 16, 18, 20, 22, 24 हैं, जिनमें से सबसे छोटी 10 है, इसलिए दूसरा शब्द 10 है।

चरण 2

  4  [ 3]  12  [29]  54
( 1)   2   11   28  [53] 
  8    9  <10>  27   52 
[23]  24   25   26  [51] 
 46  [47]  48  [49]  50

संभावित चाल 1 , 3, 23, 29, 47, 49, 51, 53 हैं, जिनमें से सबसे छोटी 3 है, इसलिए तीसरा पद 3 है।

चरण 3

 35  [34]  33  [32]  31 
[16]  15   14   13  [30] 
  5    4  < 3>  12   29 
[ 6] ( 1)   2   11  [28] 
  7  [ 8]   9  (10)  27

संभावित चाल 6, 8, 10 , 16, 28, 30, 32, 34 हैं, जिनमें से सबसे छोटी 6 है, इसलिए चौथा शब्द 6 है।

अनुक्रम सितारों के साथ:

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

और के साथ समाप्त होता है

... 2099 2284 2477 2096 2281 2474 2675 2884 3101 2880 2467 2084

चुनौती

इनपुट के रूप में सीमा में एक पूर्णांक [1, 2016](या [0, 2015]यदि 0-अनुक्रमित का उपयोग किया जाता है) प्राप्त करने के लिए एक छोटा कार्यक्रम या फ़ंक्शन लिखें, फंसे हुए नाइट अनुक्रम में उस सूचकांक पर संख्या को आउटपुट करें। आप 0-अनुक्रमित या 1-अनुक्रमित के साथ अनुक्रम अनुक्रमित करने के लिए चुन सकते हैं, लेकिन आपको यह निर्दिष्ट करना होगा कि आप किस इंडेक्सिंग योजना का उपयोग करते हैं।

परीक्षण के मामले (1-अनुक्रमित)

n    | s(n)
-----+-----
   1 |    1
   2 |   10
   3 |    3
   6 |    4
  11 |   11
  21 |   23
  51 |   95
 101 |   65
 201 |  235
 501 |  761
1001 | 1069
2001 | 1925
2016 | 2084

सभी संभावित आउटपुट के लिए, कृपया इस पृष्ठ को देखें ।

जीत का मानदंड

प्रत्येक भाषा का सबसे छोटा कोड जीतता है। मानक खामियों पर प्रतिबंध लागू होते हैं।

code-golf number

— शायरु असकोतो
स्रोत

बहुत बारीकी से संबंधित

— अरनौलड

@ अरनल्ड यह सवाल मेरा (जैसा संकेत दिया गया) से प्रेरित था, केवल मुख्य जाने के लिए तेज होना था। इसके अलावा, यह अनुक्रम परिमित है, इसलिए गोल्फ के कुछ पहलू उस अर्थ में भिन्न हो सकते हैं।

— शायरु असकोतो

अन्य अनुक्रम भी परिमित है, 12851850258

— जो

@JoKing खैर, लेकिन क्योंकि यह बहुत जल्दी बंद हो जाता है, मैं छोटे पूर्णांक श्रेणियों के साथ esolangs में उत्तर देखना चाहता हूं (क्या 16-बिट पूर्णांक को लागू करने वाले कोई भी esolangs हैं?)

— Shieru Asakoto

ठीक है, अगर यह प्रश्न पहले सैंडबॉक्स में पोस्ट किया गया था, तो इसका मतलब यह नहीं है कि दुपट्टा अन्य प्रश्न होगा ?

— लुइस फेलिप डी जीसस मुनोज

जवाबों:

जावास्क्रिप्ट (ईएस 7), 182 181 बाइट्स

f=(n,[x,y]=[2,1],a=[...Array(4e3)].map((_,n)=>[1,-1].map(s=>(i&1?-s:s)*(i+s*n-(n>0?n:-n)>>1),i=n**.5|0,n-=i*++i)))=>n--?f(n,a.find(([X,Y],j)=>(i=j,(x-X)*(y-Y))**2==4),a,a[i]=[]):i+1

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

कैसे?

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

कलन विधि:

$3199$
$(X,Y)$

$((एक्स - एक्स) \times (y - Y))^{2} = 4$ $((x-X)\times(y-Y))^2=4$

$(x,y)$

$|x-X|=1$ $|y-Y|=2$ $|x-X|=2$ $|y-Y|=1$
$(x,y)=(X,Y)$
हम या तो चरण 2 पर पुनः आरंभ करते हैं या अंतिम इंडेक्स लौटाते हैं जो यदि हमें मिल गया था।

नोड.जेएस , 155 बाइट्स

n=>(g=(x,y)=>n--?g(Buffer('QHUbcdWJ').map(m=c=>g[i=4*((x+=c%6-2)*x>(y+=c%7-2)*y?x:y)**2,i-=(x>y||-1)*(i**.5+x+y)]|i>m||(H=x,V=y,m=i))|H,V,g[m]=1):m+1)(1,2)

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

— Arnauld
स्रोत

05AB1E , 53 बाइट्स

Xˆ0UF2D(Ÿ0KãʒÄ1¢}εX+}Dε·nàDtyÆ+yO·<.±*->}D¯KßDˆkèU}¯θ

32θ $n+1$

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें (सबसे बड़े परीक्षण मामलों के लिए समय)।

स्पष्टीकरण:

मेरे लिंक्ड इन द वाइल्डएबेस्ट उत्तर का पथ देखें । केवल संशोधित भागों हैं:

2D(Ÿ    # Get a list in the range [-2,2]: [-2,-1,0,1,2]

और एक अनुगामी:

θ       # Only leave the last item of the list

EDIT: @Arnauld के दृष्टिकोण का एक पोर्ट उसके जावास्क्रिप्ट (ES7) उत्तर में है (वर्तमान में):

05AB1E , 57 56 बाइट्स

0D‚DˆUF64D(ŸãΣ·nàDtyÆ+yO·<.±*->}©ʒX-Pn4Q}¯¡˜2£DˆU}®J¯Jk>θ

स्पष्टीकरण:

‚%                # Create a pair of zeros: [0,0]
                  # (by pairing the (implicit) input with itself,
                  #  and then using modulo (implicit) input)
  DˆU             # Set both variable `X` to this, and add it to the global_array
F                 # Loop the (implicit) input amount of times:
 64D(Ÿ            #  Create a list in the range [-64,64]
      ã           #  Create each possible pair of `x,y`-coordinates
       Σ·nàDtyÆ+yO·<.±*->}
                  #  Sort this list in a spiral
        ©         #  Save it in the register (without popping)
 ʒ      }         #  Filter the list of coordinates by:
  X-              #   Subtract the coordinate of variable `X`
    P             #   Take the product
     n            #   Take the square
      4Q          #   Check if its equal to 4
                  # Since 05AB1E cannot remove inner lists, we use a workaround:
         ¯¡       # Split this list on each coordinate in the global_array
           ˜      # Flatten the entire list
            2£    # Only leave the first two integers as `x,y`-coordinate
                  # (if 05AB1E could remove inner lists, this would've been `¯Kн` instead)
              DˆU # Replace variable `X` with this, and add it to the global_array
}®                # After the loop: push all coordinates sorted in a spiral from the register
  J               # Join each coordinate together to a string
   ¯J             # Push the global_array, and also join them together to a string
                  # (if 05AB1E could index inner lists, both `J` could have been removed)
     k            # Get the index of each item of the global_array in the spiral list
      >           # Increase the 0-indexed index by 1 to make it 1-based
       θ          # And only leave the last one (which is output implicitly)

Σ·nàDtyÆ+yO·<.±*->} $x,y$

— केविन क्रूज़सेन
स्रोत

MATL , 41 37 बाइट्स

62lYLt1=i:"YYw(t5Mf'<@{}'ot_h+)X<y=])

इनपुट 0-आधारित है।

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

— लुइस मेंडो
स्रोत