चुनौती

अपने हल किए गए राज्य में पंद्रह पहेली के निम्नलिखित आरेख पर विचार करें:

_____________________
|    |    |    |    |
| 1  | 2  | 3  | 4  |
|____|____|____|____|
|    |    |    |    |
| 5  | 6  | 7  | 8  |
|____|____|____|____|
|    |    |    |    |
| 9  | 10 | 11 | 12 |
|____|____|____|____|
|    |    |    |    |
| 13 | 14 | 15 |    |
|____|____|____|____|

हर कदम पर, एक उत्साहित गूढ़ व्यक्ति को रिक्त स्थान से सटे एक टुकड़े को खाली स्थान में स्थानांतरित करने का अवसर मिलता है। उदाहरण के लिए, इस 1कदम के बाद , हमारे पास 2संभावित परिदृश्य हैं ( 0रिक्त स्थान होने दें ):

1   2   3   4          1   2   3   4
5   6   7   8          5   6   7   8
9   10  11  12   and   9   10  11  0
13  14  0   15         13  14  15  12

2चाल के बाद , पहेली के 5अलग-अलग परिणाम हैं (ध्यान दें कि ऊपर के दो मामलों को बाहर रखा गया है, क्योंकि उन्हें 2 चालों में नहीं पहुँचा जा सकता है)। इन स्थितियों में से एक मूल हल की स्थिति है, और दो अलग-अलग तरीकों से पहुंचा जा सकता है।

इस चुनौती में आपका काम विभिन्न परिणामों की संख्या का उत्पादन करना है जो एक निश्चित संख्या में चालें पैदा कर सकता है। इनपुट के रूप में, एक संख्या लें N >= 0, और उन विशिष्ट स्थितियों की संख्या को आउटपुट करें जो Nचालों के बाद दिखाई दे सकती हैं ।

नियम

यह कोड-गोल्फ है। सबसे छोटा कोड जीतता है!
मानक खामियों को अस्वीकार कर दिया जाता है।
आपका कोड N = 10कुछ मिनटों के लिए मामले की गणना करने में सक्षम होना चाहिए । मैं इस नियम का परीक्षण नहीं करूंगा जब तक कि एक उत्तर में समय का स्पष्ट दुरुपयोग मौजूद न हो।

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

( मार्टिन ओउटनर की स्क्रिप्ट द्वारा स्वचालित रूप से OEIS A089484 ( चैट में वर्णित ज्योबिट्स के योग से उत्पन्न परिणाम ), सभी मदद के लिए धन्यवाद!)

0 moves: 1
1 moves: 2
2 moves: 5
3 moves: 12
4 moves: 29
5 moves: 66
6 moves: 136
7 moves: 278
8 moves: 582
9 moves: 1224
10 moves: 2530
11 moves: 5162
12 moves: 10338
13 moves: 20706
14 moves: 41159
15 moves: 81548
16 moves: 160159
17 moves: 313392
18 moves: 607501
19 moves: 1173136
20 moves: 2244884
21 moves: 4271406
22 moves: 8047295
23 moves: 15055186
24 moves: 27873613
25 moves: 51197332
26 moves: 93009236
27 moves: 167435388
28 moves: 297909255
29 moves: 524507316
30 moves: 911835416
31 moves: 1566529356

— BrainSteel
स्रोत

5

पायथ, 36 बाइट्स

lu{smmXd,0@dk)fq1.a.DR4,Txd0UdGQ]U16

प्रदर्शन । दोहन परीक्षण।

lu{smmXd,0@dk)fq1.a.DR4,Txd0UdGQ]U16

                 .a.DR4,Txd0            Find the Euclidean distance between the
                                        present location of 0 and a given location.
              fq1           Ud          Filter over all locations on that distance
                                        equaling 1.
     mXd,0@dk)                          Map each such location to the grid with 0
                                        and the value at that location swapped.
  {sm                         G         Map all unique grids possible after n-1
                                        steps to all unique grids after n steps.
 u                             Q]U16    Repeat <input> times, starting with the
                                        initial grid.
l                                       Print the length of the resulting set.

— isaacg
स्रोत

3

CJam, 54 52 51 50 49 47 45 बाइट्स

G,ari{{:S0#S{4md2$4md@-@@-mh1=},f{Se\}}%:|}*,

इसे सीजेएम दुभाषिया में ऑनलाइन प्रयास करें (10 सेकंड से कम समय लेना चाहिए)।

यह काम किस प्रकार करता है

G,a       e# Push R := [[0 1 ... 15]].
ri{       e# Do int(input()) times:
  {:S     e#   For each S in R:
    0#    e#     Push the index of 0 in S (I).
    S{    e#     Filter S; for each J in in S:
      4md e#       Push J/4 and J%4.
      2$  e#       Copy I.
      4md e#       Push I/4 and I%4.
      @-  e#       Compute (I%4)-(J%4).
      @@- e#       Compute (J%4)-(I%4).
      mh  e#       2-norm distance: a b -> sqrt(aa + bb)
      1=  e#       Check if the distance is 1.
    },    e#     Keep all values of J with distance 1 from I.
    f{    e#     For each J:
      S   e#       Push S. 
      e\  e#       Swap S at indexes I and J.
    }     e#     This pushes an array of all valid modifications of S.
  }%      e#   Collect the results for all S in R in an array.
  :|      e#   Reduce the outmost array using set union (removes duplicates).
}*        e#

— डेनिस
स्रोत

3

रेटिना , 289 276 बाइट्स

^
,abcd%efgh%ijkl%mnox,
(`(,[^,]*)x([^,%])([^,y]*),
$0$1$2x$3y,
(,[^,]*)([^,%])x([^,y]*),
$0$1x$2$3y,
(,[^,]*)x([^,]{4})([^,])([^,y]*),
$0$1$3$2x$4y,
(,[^,]*)([^,])([^,]{4})x([^,y]*),
$0$1x$3$2$4y,
,.{19},(?=.*1)|,[^,]{20},(?=[^1]*$)|y|1$

+)`([^,]{19})(.*),\1,
$1$2
[^a]

a
1

इनपुट लेता है और आउटपुट को प्रिंट करता है।

आप प्रत्येक पंक्ति को एक फ़ाइल में रख सकते हैं या कोड को -sध्वज के साथ चला सकते हैं । उदाहरण के लिए:

> echo -n 111|retina -s fifteen_puzzle
111111111111

विधि का मूल यह है कि हम सभी संभावित पदों (पुनरावृत्ति के बिना) का ट्रैक रखते हैं जो बिल्कुल kचरणों के बाद हो सकते हैं । हम प्रपत्र शुरू k = 0और प्रतिस्थापन कदम (का उपयोग कर दोहराने (` and )` modifiers) जब तक हम कदम के इनपुट संख्या तक पहुँचते हैं।

इस संगणना के दौरान हमारी स्ट्रिंग का रूप हमेशा होता है

(,[puzzle_state]y?,)+1*

पत्रों के कुछ क्रमपरिवर्तन के साथ कहां puzzle_stateहै abcd%efgh%ijkl%mnox। xखाली जगह के लिए खड़ा है, बाकी पत्र टाइल हैं। %पंक्ति के परिसीमनकर्ता हैं।

yराज्य वर्तमान चरण में उत्पन्न होता है ( kइसलिए) इस चरण में अन्य राज्यों को उत्पन्न करने के लिए इसका उपयोग नहीं किया जाना चाहिए।

1के चरणों की संख्या को छोड़ दिया है।

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

जोड़ा स्पष्टीकरण के साथ कोड:

initialize string
^
,abcd%efgh%ijkl%mnox,

while string changes
(`

for every old (y-less) state concatenate a new state with moving the empty tile to r/l/d/u if possible
right
(,[^,]*)x([^,%])([^,y]*),
$0$1$2x$3y,
left
(,[^,]*)([^,%])x([^,y]*),
$0$1x$2$3y,
down
(,[^,]*)x([^,]{4})([^,])([^,y]*),
$0$1$3$2x$4y,
up
(,[^,]*)([^,])([^,]{4})x([^,y]*),
$0$1x$3$2$4y,

if we should have made this step (there are 1's left) remove old states
,.{19},(?=.*1)

if we should not have made this step (no more 1's left) remove new states
,[^,]{20},(?=[^1]*$)

remove y markers
y

remove one 1 (decrease remaining step count)
1$


remove duplicates until string changes (with + modifier)
+`([^,]{19})(.*),\1,
$1$2    

end while
)`

remove non-a's, 1 a stays from each state
[^a]

change a's to 1's
a
1

10 बाइट्स ने @MartinButtner को धन्यवाद दिया।

— randomra
स्रोत

2

पायथन, 310 253 243 229 बाइट्स

@Randomra द्वारा सुझाए गए सुधार के साथ नवीनतम संस्करण:

s=set()
s.add(tuple(range(16)))
def e(a,b):s.add(t[:a]+(t[b],)+t[a+1:b]+(t[a],)+t[b+1:])
for k in range(input()):
 p,s=s,set()
 for t in p:j=t.index(0);j%4and e(j-1,j);j%4>2or e(j,j+1);j<4or e(j-4,j);j>11or e(j,j+4)
print len(s)

मेरा अपना संस्करण, जो लंबा था (243 बाइट्स), लेकिन पढ़ने में आसान:

s=set()
s.add(tuple(range(16)))
def e(a,b):s.add(t[:a]+(t[b],)+t[a+1:b]+(t[a],)+t[b+1:])
for k in range(input()):
 p,s=s,set()
 for t in p:
  j=t.index(0)
  if j%4:e(j-1,j)
  if j%4<3:e(j,j+1)
  if j>3:e(j-4,j)
  if j<12:e(j,j+4)
print len(s)

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

मेरे लैपटॉप पर N = 10 के लिए लगभग 0.03 सेकंड लेता है। रनिंग का समय बड़ी संख्या के लिए पर्याप्त रूप से बढ़ता है, उदाहरण के लिए एन = 20 के लिए लगभग 12 सेकंड।

— रेटो कोराडी
स्रोत

अलियासिंग s.addशायद कुछ पात्रों को बचाएगा।

— इसहाक

@isaacg मैंने समान कोड को एक फंक्शन में ले जाकर काफी बचाया। अब इसे देखते हुए, मुझे tतर्क के रूप में पारित करने की आवश्यकता नहीं है । इसके अलावा, मुझे लगता है कि अगर मेरे पास बेहतर पाइथन स्किल्स हैं, तो मुझे सुधार की सबसे अधिक संभावना है।

— रेटो कोराडी

3

आप ifसाइड-इफेक्ट वाले बयानों को शॉर्ट-सर्कुलेटिंग एक्सप्रेशन में बदल सकते हैं, जैसे j%4and e(j-1,j)कि आप उन्हें बूलियन ट्यूपर के रूप में एक पंक्ति में रख सकते हैं j%4and e(j-1,j),j%4>2or e(j,j+1),j<4or e(j-4,j),j>11or e(j,j+4):।

— यादृच्छिक

@randomra अच्छा लगता है, मैं कोशिश करूँगा कि कल। मैंने सोचा कि ifबयानों की श्रृंखला के बजाय सशर्त अभिव्यक्तियों का उपयोग करने का कुछ चतुर तरीका था । मुझे आश्चर्य है कि अगर दो तत्वों की अदला-बदली के साथ एक ट्यूलल बनाने का एक छोटा तरीका है।

— रेटो कोराडी

1

सूची में बदलना, गमागमन करना और वापस ट्यूपल में परिवर्तित करना थोड़ा कम है def e(a,b):*l,=t;l[a],l[b]=l[b],l[a];s.add(tuple(l)):।