यदि आप नहीं जानते कि हनोई का टॉवर क्या है, तो मैं इसे संक्षेप में समझाता हूँ: तीन छड़ें हैं और कुछ डिस्क जिनमें से प्रत्येक का आकार अलग है। शुरुआत में सभी डिस्क पहले टॉवर पर हैं, क्रमबद्ध क्रम में: सबसे बड़ा सबसे नीचे है, सबसे ऊपर सबसे छोटा। लक्ष्य सभी डिस्क को तीसरी रॉड पर लाना है। आसान लगता है? यहाँ पकड़ है: आप एक डिस्क के ऊपर एक डिस्क नहीं रख सकते हैं जो अन्य डिस्क से छोटा है; आप उन्हें एक रॉड पर ले जाने के लिए एक समय में केवल एक डिस्क को अपने हाथ में पकड़ सकते हैं और आप केवल डिस्क को रॉड पर रख सकते हैं, न कि टेबल पर, आप कमीनों को डरपोक बनाते हैं।

एससीआई उदाहरण समाधान:

  A      B      C
  |      |      |      
 _|_     |      |      
__|__    |      |


  A      B      C
  |      |      |      
  |      |      |      
__|__   _|_     |


  A      B      C
  |      |      |      
  |      |      |      
  |     _|_   __|__


  A      B      C
  |      |      |      
  |      |     _|_     
  |      |    __|__

चुनौती

तीन छड़ें हैं जिन्हें ए, बी और सी कहा जाता है (आप उन्हें 1,2 और 3 को सम्मानजनक रूप से कॉल भी कर सकते हैं यदि वह मदद करता है) शुरुआत में सभी एन डिस्क रॉड ए (1) पर हैं।

आपकी चुनौती हनोई के टॉवर के लिए एक समाधान को सत्यापित करना है। आपको यह सुनिश्चित करने की आवश्यकता होगी कि:

अंत में सभी एन डिस्क रॉड सी (3) पर हैं।
किसी भी राज्य में किसी भी डिस्क के लिए इसके नीचे कोई छोटी डिस्क नहीं है।
खाली रॉड से डिस्क ले जाने की कोशिश करने या किसी भी तरह की कोई भी त्रुटि नहीं होने जैसी कोई स्पष्ट त्रुटि नहीं है।

(समाधान का इष्टतम होना आवश्यक नहीं है।)

इनपुट

आपके कार्यक्रम को दो इनपुट प्राप्त होंगे:

डिस्क की संख्या n (पूर्णांक)
जो चालें ली जाती हैं, जिसमें टुपल्स का एक सेट शामिल होगा: (टॉवर वर्तमान में ऊपर से डिस्क को ऊपर ले जाने के लिए), (टॉवर इस डिस्क को लेने के लिए) जहां प्रत्येक ट्यूपल एक चाल को संदर्भित करता है। आप चुन सकते हैं कि उनका प्रतिनिधित्व कैसे किया जाता है। उदाहरण के लिए n = 2 के लिए समाधान का प्रतिनिधित्व करने के निम्नलिखित तरीकों की तरह कुछ है जो मैंने ऊपर एएससीआई में खींचा है। (मैं परीक्षण मामलों में पहले एक का उपयोग करूंगा, क्योंकि यह आंखों पर आसान है):

"ए-> बी; ए-> सी; बी-> सी"

[( 'ए', 'बी'), ( 'ए', 'सी'), ( "बी", "सी")]

[(1,2), (1,3), (2,3)]

"ABACBC"

[1,2,1,3,2,3]

उत्पादन

सच्चाई, अगर स्थितियाँ "चुनौती" के तहत मिल सकती हैं।
झूठे, अगर वे नहीं करते हैं।

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

सच:

n=1, "A->C"

n=1, "A->B ; B->C"

n=2, "A->B ; A->C ; B->C"

n=2, "A->C ; C->B ; A->C ; B->C"

n=2, "A->C ; A->B ; C->B ; B->A ; B->C ; A->C"

n=3, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"

n=4, "A->B ; A->C ; B->C ; A->B ; C->A ; C->B ; A->B ; A->C ; B->C ; B->A ; C->A ; B->C ; A->B ; A->C ; B->C"

असत्य:

3rd @MartinEnder द्वारा सुझाया गया, @Joffan द्वारा 7 वां

n=1, "A->B"

n=1, "C->A"

n=2, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"

n=2, "A->B ; A->C ; C->B"

n=2, "A->C ; A->B ; C->B ; B->A"

n=2, "A->C ; A->C"

n=3, "A->B ; A->D; A->C ; D->C ; A->C"

n=3, "A->C ; A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"

n=3, "A->C ; A->B ; C->B ; A->B ; B->C ; B->A ; B->C ; A->C"

n=3, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; C->B"

n=4, "A->B ; A->C ; B->C ; A->B ; C->A ; C->B ; A->B ; A->C ; B->C ; B->A ; C->A ; B->C ; A->B ; A->C"

n=4, "A->B ; A->B ; A->B ; A->C ; B->C ; B->C ; B->C"

यह कोड-गोल्फ है , सबसे छोटा समाधान जीतता है। मानक नियम और खामियां लागू होती हैं। कोई बैटरी शामिल नहीं है।

code-golf stack

— KarlKastor
स्रोत

यह भी ठीक है अगर 2 इनपुट अपने विधि का उपयोग किया जा सकता है, लेकिन पत्र (यानी के बजाय नंबर का उपयोग कर A=1, B=2, C=3, आदि)?

— आर। काप।

1

क्या मैं इनपुट्स को शून्य कर सकता हूं?

— रोहन झुनझुनवाला

1

क्या यह ठीक है अगर डिस्क को खाली या बिना किसी छड़ी के ले जाने पर कोई त्रुटि होती है?

— आर। कप

1

क्या हम मान सकते हैं कि जैसे गैर-चालें नहीं होंगी A->A?

— मार्टिन एंडर

2

@ कोबी को आपको moving discs to nonexistant rods.हां के लिए जांचना होगा , यह एकD

— edc65

7

रेटिना , 84 80 बाइट्स

^{मार्टिन बायर को -5 बाइट्स धन्यवाद}

~
 ~$'
$
ABC
{`^(.)(.*)( ~+)\1
$3$2$1
}`^(\W+)(\w)(.*)(?<=\1~+|\w)\2
$3$1$2
^AB

इसे ऑनलाइन आज़माएं! (लाइन-दर-लाइन परीक्षणों के लिए 5 बाइट्स)

कोड एक पूर्ण गेम का अनुकरण करता है।

इनपुट के रूप में दिया गया है ACABCBACBABCAC~~~।
~~~तीन डिस्क का मतलब है।
पहले चार लाइनें इनपुट को गेम फॉर्मेट में बदल देती हैं ACABCBACBABCAC ~~~ ~~ ~ABC:।
शुरुआत में ए रॉड में सभी 3 डिस्क हैं, और बी और सी रॉड खाली हैं।
अगला हमारे पास दो चरणों का एक लूप है:
- लाइन में पहला अक्षर लें, जो अगले स्रोत रॉड को इंगित करता है। इस रॉड को ढूंढें, और अंतिम डिस्क को अंदर ले जाएं। पत्र को हटा दें और डिस्क को स्टार्क पर ले जाएं (इसे उठाएं)।
  बाहर उदाहरण में, पहला कदम के बाद, पाठ तरह दिखेगा: ~CABCBACBABCAC ~~~ ~~ABC।
- दूसरे चरण में हम लक्ष्य रॉड ढूंढते हैं, और डिस्क को वहां स्थानांतरित करते हैं। हम मानते हैं कि रॉड खाली है, या शीर्ष पर एक बड़ी डिस्क है ABCBACBABCAC ~~~ ~~AB ~C:।
अंत में हम पुष्टि करते हैं कि ए और बी रॉड खाली हैं - इसका मतलब है कि सभी डिस्क सी में हैं (अंतिम पंक्ति में एक अतिरिक्त स्थान है)।

— कोबी
स्रोत

वाह, प्रभावशाली

— रोहन झुनझुनवाला

17

रेटिना , 167 165 157 150 123 बाइट्स

यह पूरी तरह से एक चुनौती की तरह दिखता है जिसे एक एकल रेगेक्स के साथ हल किया जाना चाहिए ... (हेडर "रेटिना" कहने के बावजूद, यह सिर्फ एक वैनिला .NET रेगेक्स है, जो वैध इनपुट से मेल खाता है)।

^(?=\D*((?=(?<3>1+))1)+)((?=A(?<1-3>.+)|B(?<1-4>.+)|C(?<1-5>.+)).(?=A.*(?!\3)(\1)|B.*(?!\4)(\1)|C.*(?!\5)(\1)).)+(?!\3|\4)1

इनपुट प्रारूप फॉर्म के निर्देशों की सूची है AB, इसके बाद nअंक का उपयोग करते हुए एकात्मक में 1। कोई विभाजक नहीं हैं। आउटपुट है1 वैध है और 0अमान्य है।

इसे ऑनलाइन आज़माएं!(पहले दो अक्षर एक लाइनफीड-सेपरेटेड टेस्ट सूट को सक्षम करते हैं।)

वैकल्पिक समाधान, एक ही बाइट गिनती:

^(?=\D*((?=(?<3>1+))1)+)((?=A(?<1-3>.+)|B(?<1-4>.+)|C(?<1-5>.+)).(?=A.*(?!\3)(\1)|B.*(?!\4)(\1)|C.*(?!\5)(\1)).)+(?<-5>1)+$

संभवतः इसका उपयोग करके छोटा किया जा सकता है 1, 11और 111इसके बजाय A,B और Cलेकिन मैं बाद में उस पर गौर करना होगा। यह कार्यक्रम को कई चरणों में विभाजित करने के लिए भी छोटा हो सकता है, लेकिन इसमें चुनौती कहां है? ;)

व्याख्या

यह समाधान .NET के संतुलन समूहों का भारी उपयोग करता है। पूर्ण विवरण के लिए लिए स्टैक ओवरफ्लो पर मेरी पोस्ट देखें , लेकिन यह है कि .NET में कैप्चरिंग समूह स्टैक हैं, जहां प्रत्येक नई कैप्चर एक और विकल्प को धक्का देती है और जहां इस तरह के स्टैक से फिर से पॉप करना संभव है। यह आपको एक स्ट्रिंग में विभिन्न मात्राओं को गिनने देता है। इस मामले में यह हमें तीन छड़ को सीधे तीन अलग-अलग कैप्चरिंग समूहों के रूप में लागू करने देता है, जहां प्रत्येक डिस्क को कैप्चर द्वारा दर्शाया जाता है।

छड़ के बीच डिस्क को स्थानांतरित करने के लिए हम (?<A-B>...)सिंटैक्स के एक अजीब quirk का उपयोग करते हैं। आम तौर पर, यह स्टैक से कैप्चर करता है और उस पॉप्ड कैप्चर और इस समूह की शुरुआत के बीच Bस्टैक Aको स्टैक पर धकेलता है । तो (?<A>a).(?<B-A>c)मैच के खिलाफ खाली और साथ abcछोड़ दिया जाएगा (के रूप में विरोध )। हालाँकि, .NET वैरिएबल-लंबाई लुकबाइंड्स के कारण इसे कैप्चर करना और ओवरलैप करना संभव है। जो भी कारण के लिए, अगर ऐसा है, तो दो समूहों के चौराहे पर धकेल दिया जाता है । मैंने इस उत्तर में समूहों को संतुलित करने पर "उन्नत अनुभाग" में इस व्यवहार को विस्तृत किया है ।ABbc(?<A>...)(?<B-A>...)B

रेगेक्स पर। छड़ A, Bऔर Cसमूहों के अनुरूप 3, 4और 5रेगेक्स में। चलो रॉड को इनिशियलाइज़ करके शुरू करते हैं A:

^                 # Ensure that we start at the beginning of the input.
(?=               # Lookahead so that we don't actually move the cursor.
  \D*             # Skip all the instructions by matching non-digit characters.
  (               # For each 1 at the end of the input...
    (?=(?<3>1+))  # ...push the remainder of the string (including that 1)
                  # onto stack 3.
  1)+
)

इसलिए जैसे यदि इनपुट समाप्त होता है 111, तो समूह 3 / रॉडA अब कैप्चर की सूची [111, 11, 1](शीर्ष दाईं ओर) होगा।

कोड के अगले बिट में निम्नलिखित संरचना है:

(
  (?=A...|B...|C...).
  (?=A...|B...|C...).
)+

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

सबसे पहले, स्रोत की छड़ से एक डिस्क निकालकर:

(?=
  A(?<1-3>.+)
|
  B(?<1-4>.+)
|
  C(?<1-5>.+)
)

यह ऊपर वर्णित अजीब समूह-प्रतिच्छेदन व्यवहार का उपयोग करता है। उस समूह पर ध्यान दें 3, 4और 5हमेशा स्ट्रिंग के 1अंत में एस के सबस्ट्रिंग को पकड़ेंगे जिसकी लंबाई डिस्क के आकार से मेल खाती है। अब हम (?<1-N>.+)स्टैक पर टॉप डिस्क को पॉप करने के लिए उपयोग करते हैं Nऔर .+स्टैक पर मैच के साथ इस विकल्प के चौराहे को धक्का देते हैं 1। चूँकि .+हमेशा आवश्यक रूप से पूरे कैप्चर को कवर किया जाता हैN , हम जानते हैं कि यह बस कैप्चर को स्थानांतरित करता है।

इसके बाद, हम इस डिस्क को स्टैक 1पर दूसरी रॉड के अनुरूप बनाते हैं:

(?=
  A.*(?!\3)(\1)
|
  B.*(?!\4)(\1)
|
  C.*(?!\5)(\1)
)

ध्यान दें कि हमें स्टैक को साफ करने की आवश्यकता नहीं है 1, हम बस डिस्क को वहीं छोड़ सकते हैं, क्योंकि हम स्टैक का उपयोग करने से पहले एक नया शीर्ष डाल देंगे। इसका मतलब है कि हम (?<A-B>...)वाक्यविन्यास से बच सकते हैं और बस स्ट्रिंग की नकल कर सकते हैं (\1)। यह सुनिश्चित करने के लिए कि यह कदम वैध है हम नकारात्मक लुकहेड का उपयोग करते हैं (?!\N)। यह सुनिश्चित करता है कि, उस स्थिति से जहां हम वर्तमान डिस्क से मेल खाना चाहते हैं, पहले से ही स्टैक पर डिस्क का मिलान करना असंभव है N। यह केवल तभी हो सकता है जब या तो a) \Nकभी मेल नहीं खाएगा क्योंकि स्टैक पूरी तरह से खाली है या b) the disc on top of stackएनis larger than the one we're trying to match with \ 1` है।

अंत में, जो कुछ बचा है वह सुनिश्चित कर रहा है कि क) हमने सभी निर्देशों और बी) छड़ों का मिलान किया है Aऔर Bखाली हैं, ताकि सभी डिस्क चालू हो जाएं C।

(?!\3|\4)1

हम तो बस है कि न तो जाँच \3और न ही \4(क्योंकि किसी भी वास्तविक डिस्क जो केवल मामला है अगर दोनों खाली हैं मिलान कर सकते हैं होगा से मेल खाते हैं) और हम तो एक मिलान कर सकते हैं कि 1इतना है कि हम किसी भी निर्देश का लोप नहीं किया है।

— मार्टिन एंडर
स्रोत

14

जावा "केवल" 311 272 263 261 260 259 256 बाइट्स

बचा हुआ ~~३ ९~~ @Frozn के कारण अनगिनत बाइट्स एक पुराने डिबग सुविधा देख और साथ ही कुछ चालाक गोल्फ चाल।

गोल्फ संस्करण

int i(int n,int[]m){int j=0,k=0,i=n;Stack<Integer>t,s[]=new Stack[3];for(;j<3;)s[j++]=new Stack();for(;i-->0;)s[0].push(i);for(;k<m.length;k+=2)if((t=s[m[k+1]]).size()>0&&s[m[k]].peek()>t.peek())return 0;else t.push(s[m[k]].pop());return s[2].size()<n?0:1;}

प्रत्येक चरण में स्पष्टीकरण और बहुत मुद्रित ढेर के साथ ungolfed

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package codegolf;

/**
 *
 * @author rohan
 */
import java.util.Arrays;
import java.util.Stack;
public class CodeGolf {
    //golfed version
    int i(int n,int[]m){int j=0,k=0,i=n;Stack<Integer>[] s=new Stack[3];for(;j<3;j++)s[j]=new Stack();for(;i-->0;)s[0].push(i);for(;k<m.length;System.out.println(Arrays.toString(s)),k+=2)if(!s[m[k+1]].isEmpty()&&s[m[k]].peek()>s[m[k+1]].peek())return 0;else s[m[k+1]].push(s[m[k]].pop());return s[2].size()==n?1:0;}
    /** Ungolfed
        * 0 as falsy 1 as truthy
        * @param n the number of disks
        * @param m represents the zero indexed stacks in the form of [from,to,from,to]
        * @return 0 or 1 if the puzzle got solved, bad moves result in an exception
        */
    int h(int n, int[] m) {
        //declarations
        int j = 0, k = 0, i = n;
        //create the poles
        Stack<Integer>[] s = new Stack[3];
        for (; j < 3; j++) {
            s[j] = new Stack();
        }
        //set up the first tower using the "downto operator
        for (; i-- > 0;) {
            s[0].push(i);
        }
    //go through and perform all the moves
        for (; k < m.length; System.out.println(Arrays.toString(s)), k += 2) {
            if (!s[m[k + 1]].isEmpty() && s[m[k]].peek() > s[m[k + 1]].peek()) {
                return 0;//bad move
            } else {
                s[m[k + 1]].push(s[m[k]].pop());
            }
        }
        return s[2].size() == n ? 1 : 0;// check if all the disks are done
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    //test case
        System.out.println( new CodeGolf().h(3,new int[]{0,2,0,1,2,1,0,2,1,0,1,2,0,2})==1?"Good!":"Bad!");
    }

}

Ungolfed संस्करण में एक विशेषता है जहां यह पता लगाएगा कि स्टैक प्रत्येक चरण में कैसा दिखता है ...

[[2, 1], [], [0]]
[[2], [1], [0]]
[[2], [1, 0], []]
[[], [1, 0], [2]]
[[0], [1], [2]]
[[0], [], [2, 1]]
[[], [], [2, 1, 0]]
Good!

— रोहन झुनझुनवाला
स्रोत

क्या करता System.out.println(Arrays.toString(s))है?

— फ्रोज़न

यह बहुत सुंदर प्रिंट होगा। जैसे [[2,1,0], [] []]

— रोहन झुनझुनवाला

व्हॉट्स @Frozn जो अब एक डिबग फीचर को हटा रहा था

— रोहन झुनझुनवाला

मैं जानता हूँ कि, बस सोच क्यों यह नहीं है :) आप भी जगह ले सकता है &&के साथ &।

— फ्रोज़न

@ फ़िरोज़ा मैं उस दुख को प्रतिस्थापित नहीं कर सकता क्योंकि मैं शॉर्ट सर्किट व्यवहार पर भरोसा कर रहा था ताकि खाली स्टैक पर झांकने की कोशिश न करूँ। 39 बाइट में कमी के लिए धन्यवाद

— रोहन झुनझुनवाला

9

अजगर 2, 186 167 158 135 127 115 110 102 बाइट्स

n,m=input()
x=[range(n),[],[]]
for a,b in m:p=x[a].pop();e=x[b];e and 1/(p>e[-1]);e+=p,
if x[0]+x[1]:_

निम्न प्रारूप में STDIN पर इनपुट लेता है:

(1,[(0,1),(1,2)])

यही है, डिस्क की संख्या का पायथन ट्यूपल और ट्यूपल्स की पायथन सूची (from_rod,to_rod)। पाइथन की तरह, आसपास के कोष्ठक वैकल्पिक हैं। छड़ें शून्य-अनुक्रमित हैं।

उदाहरण के लिए, यह परीक्षण मामला:

n=2; "A->B ; A->C ; B->C"

के रूप में दिया जाएगा:

(2,[(0,1),(0,2),(1,2)])

यदि समाधान मान्य है, तो कुछ भी नहीं निकलता है और 0. के बाहर निकलने के कोड के साथ बाहर निकलता है। यदि यह अमान्य है, तो एक अपवाद को फेंकता है और 1 के बाहर निकलने के कोड के साथ बाहर निकलता है। IndexErrorअगर कोई भी नॉनएक्सिस्टेंट रॉड पर जा रहा है या एक डिस्क को हटाने की कोशिश कर रहा है , तो फेंकता है रॉड जिसमें इस पर कोई डिस्क नहीं है, ZeroDivisionErrorयदि एक डिस्क को एक छोटी डिस्क के शीर्ष पर रखा जाता है, या NameErrorयदि अंत में पहली या दूसरी छड़ पर छोड़ दिया जाता है।

13 बाइट्स @KarlKastor की बदौलत बची!

@Xnor के लिए धन्यवाद 8 बाइट्स सहेजे गए!

— तांबा
स्रोत

1

प्रत्येक ढेर की छंटाई की गई जांच बहुत जटिल लगती है। क्या आप यह जांच नहीं कर सकते कि स्थानांतरित डिस्क ढेर के शीर्ष डिस्क की तुलना में बड़ी है जिसे उसने स्थानांतरित किया है?

— xnor

@xnor धन्यवाद, यह काम करना चाहिए। अब इसे जोड़ना।

— कॉपर

5

पायथन 2.7, 173 158 138 130 127 123 बाइट्स:

r=range;a,b=input();U=[r(a,0,-1),[],[]]
for K,J in b:U[J]+=[U[K].pop()]if U[J]<[1]or U[K]<U[J]else Y
print U[-1]==r(a,0,-1)

स्टेप के माध्यम से इनपुट को उस प्रारूप में ले जाता है, (<Number of Discs>,<Moves>)जहां <Moves>एक सरणी के रूप में दिया जाता है जिसमें प्रत्येक चाल के अनुरूप ट्यूपल्स होते हैं, जिसमें प्रत्येक में अल्पविराम से अलग पूर्णांकों की एक जोड़ी होती है। उदाहरण के लिए, परीक्षण का मामला:

n=3, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"

पद में दिया जाएगा के रूप में दिया जाएगा:

(3,[(0,2),(0,1),(2,1),(0,2),(1,0),(1,2),(0,2)])

मेरे कार्यक्रम के लिए। IndexErrorअगर 3rd कंडीशन पूरी नहीं हुई है तो आउटपुट मिलता है , NameErrorअगर 2nd कंडीशन पूरी नहीं हुई है, और Falseअगर 1st कंडीशन पूरी नहीं हुई है। अन्यथा आउटपुट True।

— आर। कप
स्रोत

दो चीजें: चर Yको आपके कोड में कभी भी परिभाषित नहीं किया जाता है (मुझे लगता है कि इसे J होना चाहिए) और U[J]+=[Y,[U[K].pop()]][U[J]<[1]or U[K]<U[J]]3 अक्षरों से छोटा हैstmt1 if cond else stmt2

— the jermenkoo

@jermenkoo खैर, मैं उस Yवैरिएबल का उपयोग करता हूं, जैसे कि NameErrorजब भी 2 की स्थिति पूरी नहीं होती है , तब उसे उठाना पड़ता है । अगर मैं बदलने के Yलिए था J, तो NameErrorनहीं उठाया जाएगा। इस कारण से, मैं यह भी नहीं कर सकता U[J]+=[Y,[U[K].pop()]][U[J]<[1]or U[K]<U[J]]क्योंकि यह NameError सभी समय को बढ़ाएगा , न कि जब दूसरी स्थिति पूरी नहीं होगी।

— आर। कप

ठीक है, आपके स्पष्टीकरण के लिए धन्यवाद!

— jermenkoo

5

VBA, 234 217 213 196 बाइट्स

Function H(N,S)
ReDim A(N)
While P<Len(S)
P=P+2:F=1*Mid(S,P-1,1):T=1*Mid(S,P,1)
E=E+(T>2):L=L+T-F
For i=1 To N
If A(i)=F Then A(i)=T:Exit For
E=E+(A(i)=T)+(i=N)
Next
Wend
H=L+9*E=2*N
End Function

चाल के लिए इनपुट प्रारूप एक स्ट्रिंग है जिसमें अंकों की संख्या (012) होती है। फैलाव स्प्रेडशीट में है, = एच ([डिस्क की संख्या], [चाल स्ट्रिंग])

सरणी A विभिन्न डिस्क की रॉड स्थिति रखती है। एक चाल बस "से" रॉड नंबर की पहली घटना को "टू" रॉड नंबर में अपडेट कर रही है। यदि आप पहले "टू" रॉड डिस्क का सामना करते हैं, या नहीं "फ्रॉम" रॉड डिस्क, तो यह एक अमान्य कदम है। ए का कुल "रॉड वैल्यू" एल में आयोजित किया जाता है, जिसे 2 एन पर समाप्त होने की आवश्यकता होती है। ई में नकारात्मक गणना के रूप में त्रुटियां जमा होती हैं।

अन्य समाधानों के साथ आम तौर पर, एक टॉवर से उसी टॉवर में डिस्क को "हिलाना" मना नहीं है। मैं इसे अन्य 6 बाइट्स के लिए मना कर सकता था।

परिणाम

पहले कॉलम में फ़ंक्शन परिणाम (अंतिम n = 3 मामला एक अतिरिक्त रॉड का उपयोग करके मेरा जोड़ है)।

TRUE    1   02
TRUE    1   0112
TRUE    2   010212
TRUE    2   02210212
TRUE    2   020121101202
TRUE    3   02012102101202
TRUE    4   010212012021010212102012010212

FALSE   1   01
FALSE   1   20
FALSE   2   02012102101202
FALSE   2   010221
FALSE   2   02012110
FALSE   2   0202
FALSE   3   0202012102101202
FALSE   3   0201210112101202
FALSE   3   02012102101221
FALSE   3   0103023212
FALSE   4   0102120120210102121020120102
FALSE   4   01010102121212

— Joffan
स्रोत

2

php, 141 बाइट्स

<?php $a=$argv;for($t=[$f=range($a[++$i],1),[],[]];($r=array_pop($t[$a[++$i]]))&&$r<(end($t[$a[++$i]])?:$r+1);)$t[$a[$i]][]=$r;echo$t[2]==$f;

कमांड लाइन स्क्रिप्ट, इनपुट को ऊंचाई के रूप में लेती है फिर सरणी अनुक्रमित की एक श्रृंखला (0 अनुक्रमित) जैसे 1 0 2 या 2 0 1 1 2 2 1 1 या 2 ऊंचाई के सबसे छोटे परीक्षण मामलों के लिए।
सच्चे मामलों पर इकोस 1 और झूठे लोगों पर कुछ भी नहीं।
2 नोटिस और 1 चेतावनी देता है ताकि ऐसे माहौल में चलाया जाए जो उन लोगों को चुप करा दे।

— user55641
स्रोत

1

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

n=>s=>!s.some(([x,y])=>s[y][s[y].push(v=s[x].pop())-2]<v|!v,s=[[...Array(s=n)].map(_=>s--),[],[]])&s[2][n-1]

इनपुट प्रारूप: 2 तर्कों के साथ कार्य करते हैं

arg 1, संख्यात्मक, अंगूठियों की संख्या
arg 2, स्ट्रिंग्स की सरणी, प्रत्येक स्ट्रिंग 2 वर्ण '0', '1', '2'

आउटपुट: यदि 1 ठीक है, तो 0, यदि अमान्य है, तो अपवाद यदि कोई रॉड नहीं है

कम गोल्फ और समझाया

n=>a=>(
  // rods status, rod 0 full with an array n..1, rod 1 & 2 empty arrays
  s = [ [...Array(t=n)].map(_=>t--), [], [] ],
  // for each step in solution, evaluate function and stop if returns true
  err = a.some( ([x,y]) => {
    v = s[x].pop(); // pull disc from source rod
    // exception is s[x] is not defined
    if (!v) return 1; // error source rod is empty
    l = s[y].push(v); // push disc on dest rod, get number of discs in l
    // exception is s[y] is not defined
    if(s[y][l-2] < v) return 1; // error if undelying disc is smaller
  }),
  err ? 0 // return 0 if invalid move
  : s[2][n-1]; // il all moves valid, ok if the rod 2 has all the discs
)

टेस्ट नोट: मेरे फ़ंक्शन द्वारा अपेक्षित इनपुट के प्रश्न में दिए गए इनपुट प्रारूप को परिवर्तित करने के लिए टेस्ट फ़ंक्शन की पहली पंक्ति की आवश्यकता होती है

F=
n=>s=>!s.some(([x,y])=>s[y][s[y].push(v=s[x].pop())-2]<v|!v,s=[[...Array(s=n)].map(_=>s--),[],[]])&s[2][n-1]

Out=x=>O.textContent+=x+'\n'

Test=s=>s.split`\n`.map(r=>[+(r=r.match(/\d+|.->./g)).shift(),r.map(x=>(parseInt(x[0],36)-10)+''+(parseInt(x[3],36)-10))])
.forEach(([n,s],i)=>{
  var r
  try {
    r = F(+n)(s);
  } 
  catch (e) {
    r = 'Error invalid rod';
  }
  Out(++i+' n:'+n+' '+s+' -> '+r)
})

Out('OK')
Test(`n=1, "A->C"
n=1, "A->B ; B->C"
n=2, "A->B ; A->C ; B->C"
n=2, "A->C ; C->B ; A->C ; B->C"
n=2, "A->C ; A->B ; C->B ; B->A ; B->C ; A->C"
n=3, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"
n=4, "A->B ; A->C ; B->C ; A->B ; C->A ; C->B ; A->B ; A->C ; B->C ; B->A ; C->A ; B->C ; A->B ; A->C ; B->C"`)

Out('\nFail')
Test( `n=1, "A->B"
n=1, "C->A"
n=2, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"
n=2, "A->B ; A->C ; C->B"
n=2, "A->C ; A->B ; C->B ; B->A"
n=2, "A->C ; A->C"
n=3, "A->B ; A->D; A->C ; D->C ; A->C"
n=3, "A->C ; A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; A->C"
n=3, "A->C ; A->B ; C->B ; A->B ; B->C ; B->A ; B->C ; A->C"
n=3, "A->C ; A->B ; C->B ; A->C ; B->A ; B->C ; C->B"
n=4, "A->B ; A->C ; B->C ; A->B ; C->A ; C->B ; A->B ; A->C ; B->C ; B->A ; C->A ; B->C ; A->B ; A->C"
n=4, "A->B ; A->B ; A->B ; A->C ; B->C ; B->C ; B->C"`)

<pre id=O></pre>

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

— edc65
स्रोत

हनोई समाधान का एक टॉवर सत्यापित करें

एससीआई उदाहरण समाधान:

चुनौती

इनपुट

उत्पादन

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

सच:

असत्य:

रेटिना , 84 80 बाइट्स

रेटिना , 167 165 157 150 123 बाइट्स

व्याख्या

जावा "केवल" 311 272 263 261 260 259 256 बाइट्स

अजगर 2, 186 167 158 135 127 115 110 102 बाइट्स

पायथन 2.7, 173 158 138 130 127 123 बाइट्स:

VBA, 234 217 213 196 बाइट्स

परिणाम

php, 141 बाइट्स

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