21

यह एपीएल कोडगॉल्फ के शरद ऋतु टूर्नामेंट से होल -3 है । मैं वहां समस्या का मूल लेखक हूं, और इस तरह इसे फिर से यहां पोस्ट करने की अनुमति दी गई है।

दिया हुआ:

बहुत सारे मोड़ (कृपया बताएं कि क्या कोई हलचल 0 नहीं है, अन्यथा हम मान लेंगे कि इसे 1 कहा जाता है) और
8 या 8 शतरंज की बिसात पर एक या अधिक प्रारंभिक पदों की सूची (किसी भी रूप में, उदाहरण के लिए 0 या 1 अनुक्रमित निर्देशांक या 64 लगातार संख्या / वर्ण या A1-H8 - जो राज्य)।

वापसी (किसी भी क्रम में) अद्वितीय पदों की सूची (इनपुट के समान प्रारूप में) जो कि नाइट (ओं) को दिए गए नंबर की संख्या के बाद हो सकती है।

प्रत्येक शूरवीर को हर मोड़ के साथ चलना चाहिए, लेकिन आपको एक ही वर्ग पर मौजूद कई शूरवीरों के बारे में चिंता करने की आवश्यकता नहीं है।
शूरवीर केवल अपनी वर्तमान स्थिति के सापेक्ष X के साथ चिह्नित पदों पर जा सकता है, move के साथ चिह्नित:

उदाहरण (1-अनुक्रमित निर्देशांक)

1इससे आगे बढ़ें [[1,1]]: [[2,3],[3,2]]

2से चलता है [[1,1]]: [[1,1],[1,3],[1,5],[2,4],[3,1],[3,5],[4,2],[4,4],[5,1],[5,3]]

1इससे आगे बढ़ें [[1,1],[5,7]]: [[2,3],[3,2],[3,6],[3,8],[4,5],[6,5],[7,6],[7,8]]

2से चलता है [[1,1],[5,7]]: [[1,1],[1,3],[1,5],[1,7],[2,4],[2,6],[2,8],[3,1],[3,3],[3,5],[3,7],[4,2],[4,4],[4,6],[4,8],[5,1],[5,3],[5,5],[5,7],[6,4],[6,6],[6,8],[7,3],[7,7],[8,4],[8,6],[8,8]]

0से चलता है [[3,4]]: [[3,4]]

code-golf chess board-game

— एडम
स्रोत

क्या शतरंज के स्थान को [रैंक, फ़ाइल] के बजाय 0-63 नंबर से इनपुट और आउटपुट किया जा सकता है?

— डेव

@ यकीन है, क्यों नहीं? बस I / O के अनुरूप होना चाहिए।

— आदम

8

मैं कसम खाता हूं कि मैंने इस HNQ को "व्हेयर द नाइट इन द नी मूव्स" के रूप में पढ़ा

— सिडनी

3

पुन चेतावनी: नाइट के लिए संकेतन N है

— जोशुआ

क्या हम चरणों की संख्या पर 1-आधारित अनुक्रमणिका का उपयोग कर सकते हैं? जैसे[[1,1]], 2 -> [[2,3],[3,2]]

— १ .:

11

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 45 बाइट्स

क्योंकि दूसरा समाधान गलत है (नीचे मार्टिन की टिप्पणी देखें), इसलिए मैं अपना समाधान पोस्ट करने का निर्णय लेता हूं:

8~KnightTourGraph~8~AdjacencyList~#&~Nest~##&

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

परम infix संकेतन ...

2 इनपुट लेता है, पहले एक की संख्या की एक सूची होती [1,64]है जिसमें शूरवीर के शुरुआती पदों का वर्णन होता है, दूसरा चरण की संख्या है।

यह समाधान मैथेमेटिका बिलिन कार्यों की चरम सुविधा पर निर्भर करता है:

AdjacencyListइसके दाईं ओर के कोने की सूची ले सकता है, और पहले से ही हटाए गए डुप्लिकेट और सॉर्ट किए गए लोगों में से किसी से सटे कोने की सूची वापस कर सकता है ।
KnightTourGraphबिलियन है। आश्चर्य नहीं।
Nestतर्क को क्रम में लेता है Nest[f, expr, n], जिसे हम ##इसके दाईं ओर के रूप में दिखा सकते हैं Nest[f, ##]।
और अंत में, Mathematica parse के a~b~c~d~eरूप में (a~b~c)~d~e, इसलिए कोई वर्ग ब्रैकेट आवश्यक नहीं है। Infix संकेतन और समतल बिना ##, यह होगा Nest[AdjacencyList[KnightTourGraph[8, 8], #] &, #, #2]&।

— user202729
स्रोत

1

मुझे नहीं लगता कि किसी मौजूदा समाधान को आउटगोल्फिंग के साथ कुछ गलत है।

— अदम

1

क्या यह कई शुरुआती पदों के साथ काम करता है?

— अदम

गजब का! अब मुझे यह पता लगाने की आवश्यकता है कि टीआई ने इसे कैसे पढ़ा ...

— डेव

यह शायद काल्पनिक Mthmca गोल्फ भाषा में 17 बाइट्स होगा।

— माइकल स्टर्न

7

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

इनपुट / आउटपुट प्रारूप: वर्गों सूचकांकों में [0 ... 63] ।

f=(a,n)=>n--?f([...Array(64).keys()].filter(p=>!a.every(P=>(p%8-P%8)**2^((p>>3)-(P>>3))**2^5)),n):a

परीक्षण के मामलों

इस स्निपेट में अनुवाद करने के लिए और ओपी द्वारा प्रदान किए गए प्रारूप में दो सहायक कार्य शामिल हैं।

कोड स्निपेट दिखाएं

f=(a,n)=>n--?f([...Array(64).keys()].filter(p=>!a.every(P=>(p%8-P%8)**2^((p>>3)-(P>>3))**2^5)),n):a

c2s = a => a.map(c => (c[0] - 1) * 8 + c[1] - 1)
s2c = a => JSON.stringify(a.map(s => [(s >> 3) + 1, s % 8 + 1]))

console.log(s2c(f(c2s([[1,1]]), 1)))
console.log(s2c(f(c2s([[1,1]]), 2)))
console.log(s2c(f(c2s([[1,1],[5,7]]), 1)))
console.log(s2c(f(c2s([[1,1],[5,7]]), 2)))
console.log(s2c(f(c2s([[3,4]]), 0)))

स्निपेट का विस्तार करें

कैसे?

से एक कदम (एक्स, वाई) के लिए (एक्स, वाई) अगर हम या तो एक वैध नाइट कदम है:

| xx | = 1 और | yY | = 2 , या
| xx | = 2 और | yY | = 1

पूर्ण मूल्यों का उपयोग करने के बजाय चुकता करके, इसे इस प्रकार व्यक्त किया जा सकता है:

(xX) x = 1 और (yY) , = 4 , या
(xX) x = 4 और (yY) ² = 1

क्योंकि 1 और 4 एकमात्र सही वर्ग हैं जो 5 देते हैं जब XOR'd एक साथ होते हैं, हमारे पास एक वैध नाइट चाल है यदि:

(xX) OR XOR (yY) 5 XOR 5 = 0

हम बोर्ड पर प्रत्येक वर्ग p = 8y + x के लिए इस सूत्र को लागू करते हैं और प्रत्येक नाइट स्क्वायर P = 8Y + X को नए संभव नाइट लक्ष्य वर्गों में कटौती करते हैं, और इस प्रक्रिया को n बार दोहराते हैं ।

— Arnauld
स्रोत

5

ऑक्टेव, 69 बाइट्स

function a=f(a,n,b=~a)for k=1:n;a=b&imdilate(a,de2bi(")0#0)"-31));end

ऑनलाइन डेमो!

इनपुट / आउटपुट बाइनरी 8 * 8 मैट्रिक्स के रूप में स्टार्ट / एंड पर बोर्ड का कॉन्फ़िगरेशन है।

स्पष्टीकरण:

nनिम्नलिखित मास्क के साथ बोर्ड के रूपात्मक दोहराव के चरणों के लिए :

— rahnema1
स्रोत

5

रेटिना , 147 102 बाइट्स

.$
$*	
¶
 ¶
{s`((?<=N(....|.{11}|.{13})?.{7})|(?=.{8}(....|.{11}|.{13})?N))\S(?=.*	)
n
Ts`	Nn`_:N`.*¶

इसे ऑनलाइन आज़माएं! के एक 8x8 बोर्ड के रूप में इनपुट लेता :शूरवीरों के साथ चिह्नित के साथ Nहै, अगली पंक्ति पर घुमावों की संख्या के लिए अंक के साथ (यह अधिक से अधिक 9 बदल जाता है करने के लिए कोई मतलब नहीं है, लेकिन अगर आप जोर देते हैं मैं एक अतिरिक्त के लिए यह समर्थन कर सकते हैं बाइट)। ध्यान दें कि आउटपुट में अतिरिक्त सफेद स्थान होता है। संपादित करें: @MartinEnder की बदौलत 45 बाइट्स बचाए गए। स्पष्टीकरण: पहला चरण एकरूपता में बदल जाता है, लेकिन टैब वर्णों का उपयोग करते हुए, ताकि बाद में दुर्घटना से मेल न खाएं, जबकि दूसरा चरण रीगेक्स को लपेटने से रोकने के लिए बोर्ड के दाईं ओर कुछ रिक्त स्थान जोड़ता है किनारा। तीसरे चरण सब बदल देता Nहै और :रों है कि एक से दूर एक नाइट के इस कदम हैं Nएक साथ n, जबकि चौथे चरण किसी भी शेष को हटा देता Nहै, बदलता हैnएस टू N, और मूव काउंट से 1 घटाएं। यह तब तक दोहराता है जब तक कि चाल की गिनती शून्य न हो।

— नील
स्रोत

यह सबसे प्रभावशाली है। निश्चित रूप से नौकरी के लिए सही उपकरण नहीं!

— 14

4

जेली , 29 बाइट्स

+þ1,2Œ!×þ1,-p`¤¤Ẏ¤Ẏ⁼%8$$ÐfQµ¡

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

0-अनुक्रमित निर्देशांक। लगभग यह कुछ उप-रूप है।

-120 उपयोगकर्ता के लिए धन्यवाद बाइट

व्याख्या

+þ1,2Œ!×þ1,-p`¤¤Ẏ¤Ẏ⁼%8$$ÐfQµ¡  Main Link
+þ                             Addition Table (all pairs using + as combining function) with
  1,2Œ!×þ1,-p`¤¤Ẏ¤             All knight moves:
  1,2                          [1, 2]
     Œ!                        All permutations ([1, 2], [2, 1])
       ×þ                      Product Table (all pairs using × as combining function) with
         1,-p`¤                [1, 1], [1, -1], [-1, 1], [-1, -1]
         1,-                   [1, -1]
            p`                 Cartestian Product with itself
               ¤               All knight moves (in a nested array) as a nilad
                Ẏ¤             Tighten (flatten once); all knight moves in a (semi-)flat array
                        Ðf     Keep elements where
                   ⁼%8$$       The element equals itself modulo 8 (discard all elements out of the range)
                          Q    Remove Duplicates
                           µ   Start new monadic chain (essentially, terminates previous chain)
                            ¡  Repeat n times; n is implicitly the second input (right argument)

— HyperNeutrino
स्रोत

1

0-अनुक्रमित जेली?

— आदम

1

@ Adám फ़िल्टरिंग को आसान बनाता है: P

— HyperNeutrino

2

मुझे उम्मीद है कि जेली 15 बाइट्स में ऐसा करने में सक्षम होगी, क्योंकि एपीएल में वर्तमान रिकॉर्ड धारक 24 पात्रों में करता है।

— आदम

जब आपके पास> = 3 $ होते हैं, तो संभावना है कि आप इसे पिछले लिंक पर ले जा सकते हैं और वापस भेज सकते हैं Ç।

— user202729

@ user202729 ओह हाँ सच है, धन्यवाद।

— हाइपरनेत्रिनो

3

05AB1E , 27 25 बाइट्स

2 बाइट्स बचाने के लिए Emigna को धन्यवाद !

1-अनुक्रमित निर्देशांक का उपयोग करता है।

कोड:

F•eĆ•SÍü‚Dí«δ+€`Ùʒ{`9‹*0›

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

F                          # Do the following <input_1> times..
 •eĆ•SÍ                    #   Push [-1, -2, 1, 2, -1]
       ü‚                  #   Pairwise pairing: [[-1, -2], [-2, 1], [1, 2], [2, -1]]
         D                 #   Duplicate the array
          í                #   Reverse each element
           «               #   Concatenate to the previous array

यह हमें निम्न सरणी देता है:

[[-1, -2], [-2, 1], [1, 2], [2, -1], [-2, -1], [1, -2], [2, 1], [-1, 2]]

जो शूरवीर की चाल के डेल्टा हैं।

            δ+             #   Addition vectorized on both sides
              €`           #   Flatten each element
                Ù          #   Uniquify
                 ʒ         #   Keep elements which..
                  {`9‹     #     Has a maximum element smaller than 9
                      *0›  #     And a minimum element larger than 0

— अदनान
स्रोत

आप 2 बाइट्स को बचाने के •eĆ•SÍü‚बजाय उपयोग कर सकते हैं Ƶ‡4в2ô<D(«।

— एमिग्ना

@Eigna आह, यह चतुर है, धन्यवाद!

— अदनान

2

पायथन 3, 105 बाइट्स

p=lambda g,i:i and list(set(p([x+y for x in g for y in[6,10,15,17,-6,-10,-15,-17]if 0<=x+y<64],i-1)))or g

पुनरावृत्ति के लिए एक नामित लैम्ब्डा का उपयोग करना होगा। यकीन नहीं है कि अगर अयोग्य है। 0-अनुक्रमित वर्ग संख्या सूची के रूप में प्रारंभिक स्थिति में पास करें। 0 कोई चाल नहीं है।

— mypetlion
स्रोत

2

जावा (ओपनजेडके 8) , 124 बाइट्स

(m,p)->{for(;m-->0;)for(long a=p,i=p=0,j;i<64;i++)for(j=64;j-->0;)p|=(p=i%8-j%8)*p+(p=i/8-j/8)*p==5?(a>>i&1)<<j:0;return p;}

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

इनपुट / आउटपुट प्रारूप

इनपुट / आउटपुट को बिट्स long( a 64 बिट्स) में बिट्स के रूप में दर्शाया गया है : सेट बिट्स का मतलब घोड़ा मौजूद है, परेशान बिट्स का मतलब घोड़ा नहीं है। उदाहरण:

// [[0, 0]]
0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001L

स्पष्टीकरण

(m, p) -> {                          // Lambda. No currying because m and p are modified
 for(;m-->0;)                        // For each move
  for(long a=p,i=p=0,j;i<64;i++)     // Declare variables, move p to a, create a new p and loop on bits of a.
   for(j=64;j-->0;)                  // Loop on bits of p.
    p |=                             // Assign to p a value.
     (p=i%8-j%8)*p+(p=i/8-j/8)*p==5  // If i -> j is a valid horse move, see Arnauld's JavaScript answer for full explanations
      ? (a>>i&1)<<j                  // Assign the presence of the horse (i-th bit of a) to the resulting board (j-th bit of p).
      : 0;                           // Else it's not a valid horse move
 return p;
}

क्रेडिट

19 बाइट्स नेवी को दिया धन्यवाद!
(X-x)²+(Y-y)²==5Arnauld के जावास्क्रिप्ट उत्तर से चाल का पुन: उपयोग किया
नई एल्गोरिथ्म में नेवय के लिए 1 और बाइट बचाया धन्यवाद!
7 और बाइट्स ने नेवे को फिर से int[]64-बिट से स्विच करके धन्यवाद दिया long।

— ओलिवियर ग्रेजायर
स्रोत

1

169 बाइट्स:

(m,p)->{for(;m-->0;){int i=64,a[]=p,x,y,u[]={1,3,5,9,15,19,21,23};for(p=new int[i];i-->0;)for(int z:u)if((((x=i/8+z/5-2)|(y=i%8+z%5-2))&-8)==0)p[x*8+y]|=a[i];}return p;}

— नेवय

1

-1 बाइट:

(m,p)->{for(int i,j,a[],x;m-->0;)for(a=p,p=new int[i=64];i-->0;)for(j=64;j-->0;)p[j]|=(x=i%8-j%8)*x+(x=i/8-j/8)*x==5?a[i]:0;return p;}

— नेवई

धन्यवाद @ नवीन! कोष्ठक / ब्लॉक हटाने के लिए कोड जोड़ना हमेशा अच्छा होता है! ;-)

— ओलिवियर ग्रेजायर

1

-7 बाइट्स के int[]साथ की जगह long:

(m,p)->{for(long i,j,a;m-->0;)for(a=p,p=i=0;i<64;i++)for(j=64;j-->0;)p|=(p=i%8-j%8)*p+(p=i/8-j/8)*p==5?(a>>i&1)<<j:0;return p;}

— नेवे

चीयर्स, मैंने ऐसा करने के बारे में सोचा भी नहीं था! अच्छी नौकरी, @ नवे ;-)

— ओलिवियर

2

जेली , 29 28 बाइट्स

8Rp`
“¦Ʋƈ2’D_2ṡ2+€µẎ
ÇƓ¡f1£Q

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

एसटीडीआईएन के माध्यम से घुमावों की संख्या होती है, और वर्ग एक तर्क है।

यह @ हाइपरनेट्रिनो के जेली समाधान को जोड़ता है, लेकिन एक अलग दृष्टिकोण के साथ।

अब 1 पूरे बाइट से @HyperNeutrino की पिटाई!

कुछ बाइट्स खटखटाने के लिए कोई सुझाव चाहते हैं!

लिंक 1 (शतरंज की बिसात)

8Rp`
8R   = The list [1,2,3,4,5,6,7,8]
  p` = cartesian multiplied with itself (this results in the chessboard)

लिंक 2 (मूव जनरेशन)

“¦Ʋƈ2’D_2ṡ2+€µẎ
“¦Ʋƈ2’          = the number 103414301
      D         = converted into a list of digits
       _2       = subtract two from each element
         ṡ2     = overlapping pairs
           +€   = add to the list of squares
             µ  = Make sure the next part isn't treated as a right argument
              Ẏ = Tighten the list (Reducing the depth by one)

लिंक 3 (वर्ग जाँच)

ÇƓ¡f1£Q
ÇƓ¡     = Repeat link #2 the requested amount of times
   f1£  = Remove everything not a member of link #1 (not on the chess board)
      Q = Make sure squares don't appear more than once

— जाकारी
स्रोत

1

हस्क , 18 बाइट्स

u!¡ṁö`fΠR2ḣ8=5ṁ□z-

वर्गों और चरणों के 1-आधारित अनुक्रमण का उपयोग करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

u!¡ṁö`fΠR2ḣ8=5ṁ□z-  Implicit inputs, say P=[[1,1],[5,7]] and n=2
  ¡                 Iterate on P:
   ṁö               Map the following function, then concatenate:
                     Argument is a pair, say p=[5,7].
          ḣ8         The range [1,2,..,8]
       ΠR2           Repeat twice, take cartesian product: [[1,1],[1,2],..,[8,8]]
     `f              Filter with this predicate:
                      Argument is a pair, say q=[3,8].
                z-    Zip p and q with difference: [-2,1]
              ṁ□      Sum of squares: 5
            =5        Is it 5? Yes, so [3,8] is kept.
 !                  Take n'th step of the iteration.
u                   Remove duplicates, implicitly print.

— Zgarb
स्रोत

1

आर , 145 183 134 बाइट्स

यह Giuseppe के मेरे शुरुआती नॉट-गोल्डी एल्गो की उत्कृष्ट गोल्फिंग का परिणाम है (नीचे टिप्पणी देखें)

function(x,n){x=x%/%8*24+x%%8
t=c(49,47,26,22)
t=c(t,-t)
for(i in 1:n)x=intersect(v<-outer(1:8,0:7*24,"+"),outer(x,t,"+"))
match(x,v)}

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

इनपुट और आउटपुट 1 ... 64 आधारित हैं। 1 ... 64 संकेतन का उपयोग करके स्थिति का एक वेक्टर लेता है। इसे 1: 576 संकेतन पर मानचित्रित करें, यह एक नौ बोर्ड से बना सुपर बोर्ड है। इस अंकन में, प्रत्येक पुनरावृत्ति पर, प्रत्येक शूरवीर +/- 22,26,47,49 से आगे बढ़ने में सक्षम होना चाहिए भविष्य के पदों को 1 ... 64 संकेतन पर वापस लौटाएं, केंद्रीय बोर्ड से बाहर आने वालों को छोड़कर। TIO उदाहरण 8x8 मैट्रिक्स का उपयोग करके परिणाम प्रदर्शित करता है।

— NofP
स्रोत

यह पहले परीक्षण के मामले में विफल लगता है (यह 2 के बजाय 4 निर्देशांक लौटाता है)।

— जर्बर्ग

इसे बाहर इंगित करने के लिए धन्यवाद Zgarb, मुझे लगता है कि मैंने इस मुद्दे को अब ठीक कर दिया है

— NofP

154 बाइट्स

— Giuseppe

या 148 बाइट्स यदि आप इसे [0...63]नोटेशन में लेते हैं ।

— Giuseppe

1

134 बाइट्स , [1..64]इनपुट और आउटपुट के लिए। +1, हालाँकि, यह एक उत्कृष्ट उत्तर है।

— ग्यूसेप

नाइट चाल में नाइट कहां हो सकता है?

उदाहरण (1-अनुक्रमित निर्देशांक)

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 45 बाइट्स

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

परीक्षण के मामलों

कैसे?

ऑक्टेव, 69 बाइट्स

रेटिना , 147 102 बाइट्स

जेली , 29 बाइट्स

व्याख्या

05AB1E , 27 25 बाइट्स

कोड:

स्पष्टीकरण:

पायथन 3, 105 बाइट्स

जावा (ओपनजेडके 8) , 124 बाइट्स

इनपुट / आउटपुट प्रारूप

स्पष्टीकरण

क्रेडिट

जेली , 29 28 बाइट्स

लिंक 1 (शतरंज की बिसात)

लिंक 2 (मूव जनरेशन)

लिंक 3 (वर्ग जाँच)

हस्क , 18 बाइट्स

व्याख्या

आर , 145 183 134 बाइट्स