हनोई सॉल्वर का टॉवर

Question

हनोई का टॉवर क्या है, इसके संदर्भ के लिए या तो Google इसे देखें या विकिपीडिया पृष्ठ पर देखें।

आपका कोड 2 चीजें करने में सक्षम होना चाहिए, और वे निम्नलिखित हैं:

• उपयोगकर्ता इनपुट स्वीकार करें जो हनोई टॉवर के शुरुआती बिंदु पर डिस्क की संख्या निर्दिष्ट करता है
• टॉवर पहेली के समाधान को दिखाने के लिए अपने चयन के एक फैशन में आउटपुट बनाएं (इसलिए जब तक यह किसी तरह तार्किक है)।

तार्किक आउटपुट का एक उदाहरण निम्नलिखित होगा (4 डिस्क प्रारंभ का उपयोग करके):

L1L2C1L1R-2R-1L1L2C1C-1R-2C1L1L2C1

Lबाईं खूंटी का Cप्रतिनिधित्व करता है, केंद्र खूंटी का Rप्रतिनिधित्व करता है और सही खूंटी का प्रतिनिधित्व करता है और संख्याएं उस खूंटी पर डिस्क को किस दिशा में और कितनी दूर तक ले जाती हैं। सकारात्मक संख्याएं खूंटी की संख्या को सबसे दाहिने खूंटी की ओर ले जाती हैं (क्योंकि डिस्क सबसे बाईं खूंटी पर शुरू होती हैं)।

हनोई के टावर के लिए नियम सरल कर रहे हैं:

• एक समय में केवल एक डिस्क को स्थानांतरित किया जा सकता है।
• प्रत्येक चाल में खूंटे में से एक से ऊपरी डिस्क लेना और इसे दूसरे खूंटे पर खिसकना होता है, जो उस खूंटे पर पहले से मौजूद हो सकता है।
• छोटी डिस्क के ऊपर कोई डिस्क नहीं रखी जा सकती है।

डिस्क बाईं ओर सबसे बड़े खूंटी पर शुरू होती है, सबसे नीचे, सबसे छोटी चोटी पर, स्वाभाविक रूप से।

Comments

क्या हमें मनमाने ढंग से बड़े टावरों को हल करने की आवश्यकता है, या क्या हम कुछ सीमाएं मान सकते हैं, जैसे 10, 100, 1k, 1Ms?

— उपयोगकर्ता अज्ञात

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

— कार्टर पपी

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

— उपयोगकर्ता अज्ञात

Answer 1

भूसी , 5 बाइट्स

↑≠⁰İr

इसे ऑनलाइन आज़माएं! आउटपुट में
प्रत्येक nचलती डिस्क nको अगले उपलब्ध खूंटी (चक्रीय रूप से लपेटते हुए) का प्रतिनिधित्व करता है ।

व्याख्या

   İr   The ruler sequence [0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, ...]
↑       Take while...
 ≠⁰     ... not equal to the input.

Answer 2

पायथन, 76 वर्ण

def S(n,a,b):
 if n:S(n-1,a,6-a-b);print n,a,b;S(n-1,6-a-b,b)
S(input(),1,3)

उदाहरण के लिए, N = 3 के लिए यह लौटाता है:

1 1 3  (move disk 1 from peg 1 to peg 3)
2 1 2  (move disk 2 from peg 1 to peg 2)
1 3 2  (move disk 1 from peg 3 to peg 2)
3 1 3  ...
1 2 1
2 2 3
1 1 3

Comments

मुझे पता है कि मैं खेल के लिए थोड़ा लेट हूँ लेकिन यह १३ चार्ट

— JayCe

Answer 3

पर्ल - 54 वर्ण

for(2..1<<<>){$_--;$x=$_&-$_;say(($_-$x)%3,($_+$x)%3)}

साथ perl -M5.010दौड़ें और स्टड पर डिस्क की संख्या दर्ज करें।

आउटपुट स्वरूप:

प्रति पंक्ति एक पंक्ति, पहला अंक खूंटी से है, दूसरा अंक खूंटी से है (0 से शुरू)

उदाहरण:

02 -- move from peg 0 to peg 2
01
21
02
10
12
02

Comments

ब्रेसेस को हटाकर 5 वर्णों को सहेजें। $x=--$_&-$_,say(($_-$x)%3,($_+$x)%3)for 2..1<<<>

— मारीनस

Answer 4

गोल्फस्क्रिप्ट ( 31 25 24 वर्ण)

])~{{~3%}%.{)3%}%2,@++}*

इल्मरी करोनन को धन्यवाद देने के साथ कि मेरे मूल trs / क्रमपरिवर्तन को 6 वर्णों से छोटा किया जा सकता है। दो क्रमपरिवर्तन के उत्पाद के रूप में उन्हें विघटित करके मैं एक और बचाने में कामयाब रहा।

ध्यान दें कि फैक्टरिंग 3%लंबाई को एक वर्ण से बढ़ाता है:

])~{{~}%.{)}%2,@++}*{3%}%

---

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

उदाहरण के लिए

$ golfscript hanoi.gs <<<"3"
01021201202101

Comments

इसमें कोई शक नहीं कि sed में समान तर्क और भी कम है, लेकिन मेरी sed क्षमताएं इसके ऊपर नहीं हैं।

— पीटर टेलर

आप इसे 25 वर्णों में कर सकते हैं:])~{.{3^3%}%2,@{2\-}%++}*

— इल्मरी करोनें

Answer 5

पर्ल, 75 79 चार्ट

पूरी तरह से कीथ रान्डेल का आउटपुट स्वरूप चुराना:

sub h{my($n,$p,$q)=@_;h($n,$p^$q^h($n,$p,$p^$q),$q*say"@_")if$n--}h pop,1,3

के लिए आमंत्रित -M5.010करें say।

(मुझे लगता है कि इसमें सुधार किया जा सकता है यदि आप इसे दबाने के बजाय फ़ंक्शन के रिटर्न मान का उपयोग करने का एक तरीका पा सकते हैं।)

Comments

[शेयर "बस say" सिफारिश का उपयोग करें ]

— जेबी

ठीक है - लेकिन मुझे अपने चार गिनती के मुकाबले 5.10 सुविधाओं को सक्षम करने की लागत को शामिल नहीं करना होगा?

— ब्रेडबॉक्स

आप - लेकिन यह मुफ़्त है। बस अपने कार्यक्रम को कैसे लागू करें, इस पर ध्यान दें ताकि पर्ल इनविटेशन स्पेसिफ़िकेशन में धाराप्रवाह न होने वाले लोग इसे वैसे भी शॉट दे सकें।

— जेबी

लिंक के लिए धन्यवाद; मैं उस तरह की चीज की तलाश में था।

— ब्रेडबॉक्स

Answer 6

SML, 63

fun f(0,_,_)=[]|f(n,s,t)=f(n-1,s,6-s-t)@[n,s,t]@f(n-1,6-s-t,t);

कॉल फ़ंक्शन के f(n,s,t)साथ:

• n डिस्क की संख्या
• प्रारंभिक बिंदु है
• t लक्ष्य बिंदु

Answer 7

बैश (64 वर्ण)

t(){ tr 2$1 $12 <<<$s;};for((i=$1;i--;))do s=`t 1`01`t 0`;done;t

गोल्फस्क्रिप्ट एक की लंबाई के दोगुने से अधिक होने के बावजूद इसे पोस्ट करना क्योंकि मुझे इसकी tसेवा करने का पुन: उपयोग पसंद है echo $s।

Answer 8

स्काला, 92 88 87 वर्ण

def?(n:Int,a:Int,b:Int){if(n>0){?(n-1,a,a^b)
print(n,a,b);?(n-1,a^b,b)}};?(readInt,1,3)

आउटपुट स्वरूप

डिस्क की संख्या कहें = 3 फिर,

(1,1,3)(2,1,2)(1,3,2)(3,1,3)(1,2,1)(2,2,3)(1,1,3) (disk number,from peg, to peg)
                                                   \---------------------------/       
                                                            Move 1              ... Move n

Comments

एक्सोर का अच्छा उपयोग।

— पीटर टेलर

Answer 9

C, 98 92 87 वर्ण

सबसे तुच्छ एल्गोरिथ्म लागू करता है।
आउटपुट उस रूप में है ab ab abजहां प्रत्येक जोड़ी का अर्थ है "शीर्ष डिस्क को खूंटी से खूंटी ख में स्थानांतरित करें"।
संपादित करें : चालें अब हेक्स में एन्कोडेड हैं - 0x12 का मतलब खूंटी 1 से खूंटी में स्थानांतरित होता है 2. कुछ चौकीदारों को बचाया।
EDIT : पैरामीटर के बजाय स्टड से संख्या पढ़ता है। छोटा।
उदाहरण:
% echo 3 | ./hanoi
13 12 32 13 21 23 13

n;
h(d){n--&&h(d^d%16*16,printf("%02x ",d,h(d^d/16))),n++;}
main(){scanf("%d",&n);h(19);}

Comments

क्या कोई व्यक्ति फ़ंक्शन h () के शरीर के वाक्यविन्यास की व्याख्या कर सकता है - विशेष रूप से इसकी पुनरावर्ती कॉल में स्पष्ट दो तर्क (d ^ d% 16 * 16 और printf (...)), और अंतिम ऑपरेशन स्पष्ट रूप से अंत में लटका हुआ है। मेरे ज्ञान के आधार पर, उस फ़ंक्शन में दो सिंटैक्स त्रुटियां हैं, लेकिन मुझे पहले से ही पता है कि यह (stdio सहित) बनाता है और सही तरीके से निष्पादित होता है।

— ग्रिफिन

फ़ंक्शन से अधिक पैरामीटर पारित करना संभव है। उनके मूल्य कहीं नहीं जाते हैं। h(x,printf(...))बस फोन करने के लिए एक रास्ता है printfसे पहले hकहा जाता है। अंतिम n++आंतरिक hरिटर्न के बाद बनाया गया है। इसका उपयोग प्रारंभिक को पूर्ववत करने के लिए किया जाता है n--।

— ugoren

धन्यवाद, यह समझ में आता है (n ++ का उद्देश्य स्पष्ट था)। अल्पविराम के बजाय n ++ से पहले अर्धविराम क्यों नहीं है, या इससे कोई फर्क पड़ता है?

— ग्रिफिन

@Griffin, वास्तव में ;यहाँ एक ही होगा। ,(उदाहरण के लिए अक्सर उपयोगी है if(x)a,b;की जगह if(x){a;b;}), लेकिन यहां कोई फायदा है।

— बदसूरत

Answer 10

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

2*Ṗọ2

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

0सबसे छोटी डिस्क को एक स्थान को दाईं ओर ले जाएं (यदि आवश्यक हो तो शुरुआत में वापस लपेटें)
1दूसरी-छोटी डिस्क को केवल अन्य कानूनी कॉलम में
2स्थानांतरित करें, तीसरे-सबसे छोटी डिस्क को केवल अन्य कानूनी कॉलम
आदि में ले जाएं ।

कलन विधि

हम हनोई समस्या के टावर्स के समाधान को पुन: देख सकते हैं; आकार के एक ढेर को स्थानांतरित करने के n से एक करने के लिए बी , आकार के एक ढेर को स्थानांतरित एन -1 से एक करने के लिए सी , तो आकार के डिस्क n से एक करने के लिए बी , तो आकार के एक ढेर को स्थानांतरित एन -1 से बी करने के लिए सी । यह निम्न स्वरूप का पैटर्न तैयार करता है (इस प्रोग्राम द्वारा उपयोग किए जाने वाले आउटपुट स्वरूप में):

0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2 …

हम देख सकते हैं कि OEIS पर यह क्रम A007814 है । अनुक्रम का एक अन्य संभावित परिभाषा "है कश्मीर वें (1-आधारित) अनुक्रम का तत्व नंबर के अंत में शून्य की संख्या है कश्मीर जब यह बाइनरी में लिखा है"। और यही कार्यक्रम यहां गणना कर रहा है।

व्याख्या

सबसे पहले, हम समाधान में चालों की संख्या की गणना करते हैं, 2 ^एन -1। यह वास्तव में एक अतिरिक्त चाल की गणना करने और बाद में इसे छोड़ने के लिए सबसे छोटा हो जाता है, इसलिए यह 2*कुछ की शक्ति के लिए 2 है। (अभी तक हमने जो एकमात्र इनपुट लिया है, वह कमांड लाइन तर्क है, ताकि डिफ़ॉल्ट रूप से उपयोग हो जाए।)

अगला, हम बेस बी में एक संख्या के अंत में शून्य की संख्या की गणना के लिए जेली के बिलिन का उपयोग करते हैं ; वह है । जैसा कि हम बाइनरी में गणना कर रहे हैं, यह है । हम सभी को यह करने की आवश्यकता है कि इस बिल में 1 से 2 ^एन -1 समावेशी संख्याओं को लागू किया जाए ।ọbọ2

जेली में संख्या की सीमा पर पुनरावृति करने के दो सरल तरीके हैं, €और Rइस समस्या पर मेरे पहले के प्रयासों में इनमें से एक का उपयोग किया गया था। हालांकि, इस मामले में, थोड़ा कम जाना संभव है: Ṗजब इनपुट के रूप में एक नंबर दिया जाता है, तो आप एक ऐसा पुनरावृत्ति करेंगे जो एक तत्व को छोटा करता है (सामान्य तौर पर, Ṗएक बिल्टिन का उपयोग सभी चीज़ों के किसी एक तत्व को संसाधित करने के लिए किया जाता है)। यही है हम इस मामले में क्या चाहते हैं (क्योंकि 2*एक भी कई elments उत्पन्न करता है), इसलिए लिंक करने के लिए इसे का उपयोग 2*और ọ2में 2*Ṗọ2हमें समस्या के लिए एक 5-बाइट समाधान देता है।

Answer 11

अवीक, 72 वर्ण

function t(n,a,b){if(n){t(n-1,a,a^b);print n,a,b;t(n-1,a^b,b)}}t($0,1,3)

आउटपुट प्रारूप कीथ रान्डेल के समान है ।

awk -f tower.awk <<< "3"    
1 1 1
2 1 1
1 1 1
3 1 3
1 1 1
2 1 3
1 1 3

Answer 12

बैश स्क्रिप्ट, 100 96 वर्ण

t(){ [[ $1<1 ]] && return
t $(($1-1)) $2 $(($2^$3))
echo $@
t $(($1-1)) $(($2^$3)) $3
}
t $1 1 3

आउटपुट प्रारूप कीथ रान्डेल के समान है ।

1 1 3
2 1 2
1 3 2
3 1 3
1 2 1
2 2 3
1 1 3

संपादित करें : याचिकाकर्ता की टिप्पणी द्वारा 4 वर्ण सहेजे गए ।

Comments

आप रिक्त स्थान जोड़ सकते हैं और गूंजने से कुछ वर्ण बचा सकते हैं$@

— पीटर टेलर

@PeterTaylor: अच्छी बात है। मुझे इसे अपडेट करने दें।

— प्रिंस जॉन वेस्ले

Answer 13

जे, 23 बाइट्स

द्विआधारी संख्या समाधान

2&(+/@:~:/\)@#:@i.@^~&2

यह समाधान इस वीडियो में वर्णित बाइनरी गिनती पद्धति का उपयोग करता है ।

जो कहना है, मैं द्विआधारी अंक को 1ऊपर से उत्पन्न करता हूं 2^n, फिर लंबाई 2 के infixes लेता हूं और प्रत्येक बिट की तुलना पिछले संख्या के संबंधित बिट से करता हूं, और जांचें कि क्या वे असमान हैं। असमान बिट्स की संख्या उस चाल के लिए आउटपुट है।

आउटपुट, उदाहरण के लिए, 3 डिस्क के लिए, जहां सबसे छोटी डिस्क को 1 लेबल दिया गया है:

1 2 1 3 1 2 1

1 मतलब "छोटी से छोटी डिस्क को एक खूंटी से खिसकाएँ, यदि आवश्यक हो तो पहले खूंटी पर वापस जाएँ"

n, अन्य सभी के लिए n, " nएक कानूनी खूंटी के लिए डिस्क ले जाएँ " (वहाँ हमेशा बिल्कुल एक होगा)

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

पुनरावर्ती समाधान

((],[,])$:@<:)`]@.(1=])

उपरोक्त समाधान के रूप में समान आउटपुट, लेकिन यहाँ तर्क समस्या की पुनरावर्ती प्रकृति को स्पष्ट करता है।

एक पेड़ के रूप में इसकी कल्पना करना भी इस बिंदु पर जोर देता है:

              4
             / \
            /   \
           /     \
          /       \
         /         \
        /           \
       /             \
      3               3      
     / \             / \    
    /   \           /   \
   /     \         /     \ 
  2       2       2       2  
 / \     / \     / \     / \
1   1   1   1   1   1   1   1

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

Comments

मूल प्रश्न के एक ही घंटे के भीतर 5 साल के बाद अपना जवाब प्रस्तुत करने का संयोग प्रकृति का है कि मैं 5 साल पहले प्रस्तुत इस प्रश्न के उत्तर की समीक्षा करने के लिए लौटा हूं ... वाह। +1

— कार्टर पपी

Answer 14

एपीएल (डायलॉग क्लासिक) , 19 बाइट्स

3|(-⍪0 1⍪2∘-)⍣⎕,⍨⍪⍬

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

आउटपुट {0,1,2} में एक 2-कॉलम मैट्रिक्स है - खूंटी से, खूंटी तक

Answer 15

के (ngn / k) , 23 बाइट्स

{3!x{-x,(,0 2),1+x}/()}

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

Answer 16

आर , 73 बाइट्स

मानचित्र पर आर डाल रहा है। [कीथ रान्डेल के उत्तर] से प्रेरित [1] सरलीकृत इनपुट के साथ, केवल अंत प्रिंट करें और 2 बाइट्स बचाने के लिए खूंटी शुरू करें। इसके अलावा 0-अनुक्रमित खूंटे।

f=function(n,s=0,e=2){if(n){f(n-1,s,3-s-e)
print(c(s,e))
f(n-1,3-s-e,e)}}

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

Answer 17

जावास्क्रिप्ट (ईएस 6), 45 बी

h=(n,f,a,t)=>n?h(--n,f,t,a)+f+t+h(n,a,f,t):''

जैसे कॉलिंग h(4, 'A', 'B', 'C')(सहायक खूंटी बी का उपयोग करके खूंटी ए से खूंटी सी तक 4 डिस्क ले जाना)

रिटर्न 'ABACBCABCACBABACBCBACABCABACBC'(खूंटी ए से खूंटी बी तक एक डिस्क को स्थानांतरित करें, खूंटी ए से खूंटी सी तक एक डिस्क को स्थानांतरित करें, खूंटी बी से खूंटी सी, आदि तक एक डिस्क को स्थानांतरित करें)

Comments

अच्छा लगा। मुझे आश्चर्य है कि क्या एफ, ए, टी मापदंडों को फ़ंक्शन परिभाषा में शामिल चूक होना चाहिए? अन्यथा प्रस्तुतियाँ अतिरिक्त आर्गन्स में मनमाना डेटा शामिल कर सकती हैं। मैं हालांकि एक नौसिखिया हूं, इसलिए किसी और अनुभवी को सलाह देनी चाहिए।

— जॉन रीस