হ্যানয়ের টাওয়ার কী তা আপনি যদি না জানেন তবে আমি এটি সংক্ষেপে ব্যাখ্যা করব: এখানে তিনটি রড এবং কয়েকটি ডিস্ক রয়েছে যার প্রতিটিটিরই আকার আলাদা। শুরুর দিকে সমস্ত ডিস্ক প্রথম টাওয়ারে রয়েছে, সাজানো ক্রমে: সবচেয়ে বড়টি নীচে এবং শীর্ষে সবচেয়ে ছোট। লক্ষ্যটি হ'ল সমস্ত ডিস্ক তৃতীয় রডের উপরে নিয়ে আসা। সহজ শোনাচ্ছে? এখানে ধরা আছে: আপনি অন্য ডিস্কের চেয়ে ছোট ডিস্কের উপরে একটি ডিস্ক রাখতে পারবেন না; এগুলিকে অন্য রডে নিয়ে যাওয়ার জন্য আপনি কেবল একবারে নিজের হাতে একটি ডিস্ক ধরে রাখতে পারেন এবং আপনি কেবল টেবিলের উপরে নয় রডগুলিতে ডিস্ক রাখতে পারেন, আপনি লুক্কায়িত জারজ।

আসকি উদাহরণ সমাধান:

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


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


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


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

চ্যালেঞ্জ

এ, বি এবং সি নামে তিনটি রড রয়েছে (আপনি যদি এগুলিকে সহায়তা করেন তবে আপনি তাদেরকে 1,2 এবং 3 টি স্বাচ্ছন্দ্যেও কল করতে পারেন) শুরুতে সমস্ত এন ডিস্ক রড এ (1) এ থাকে।

আপনার চ্যালেঞ্জ হানুইয়ের টাওয়ারের জন্য একটি সমাধান যাচাই করা। আপনার এটি নিশ্চিত করতে হবে:

শেষ পর্যন্ত সমস্ত এন ডিস্ক রড সি (3) এ রয়েছে।
প্রদত্ত যে কোন ডিস্কের জন্য কোনও ডিস্কের নীচে ছোট ডিস্ক নেই।
খালি রড থেকে ডিস্ক নেওয়ার চেষ্টা করা বা ডিস্কগুলি অজানা রোধে স্থানান্তরিত করার মতো স্পষ্ট ত্রুটি নেই।

(সমাধানটি সর্বোত্তম হতে হবে না))

ইনপুট

আপনার প্রোগ্রাম দুটি ইনপুট পাবেন:

ডিস্কের সংখ্যা এন (একটি পূর্ণসংখ্যা)
যে পদক্ষেপগুলি নেওয়া হয়, এতে কয়েকটি টিপলস থাকে: (বর্তমানে শীর্ষে থাকা ডিস্কটি থেকে নেওয়া টাওয়ার), (এই ডিস্কটি নিয়ে যাওয়ার জন্য টাওয়ার) যেখানে প্রতিটি টিপল একটি চালকে বোঝায়। সেগুলি কীভাবে উপস্থাপিত হবে তা আপনি চয়ন করতে পারেন। উদাহরণস্বরূপ n = 2 এর জন্য সমাধানটি উপস্থাপনের নীচের পদ্ধতির মতো কিছু যা আমি উপরে ascii এ আঁকছি। (আমি পরীক্ষার ক্ষেত্রে প্রথমটি ব্যবহার করব, কারণ এটি চোখে সহজ):

"এ-> বি; এ-> সি; বি-> সি"

[( "একটি", "বি"), ( "একটি", "সি"), ( "বি", "সি")]

[(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"

মিথ্যা:

তৃতীয়টি @ মার্টিনএেন্ডার দ্বারা পরামর্শ দেওয়া হয়েছে, @ জোফান দ্বারা সপ্তম

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
সূত্র

এটি ঠিক আছে যদি 2nd ইনপুট আপনার পদ্ধতি ব্যবহার করে প্রতিনিধিত্ব করা যাবে, কিন্তু অক্ষর (অর্থাত পরিবর্তে সংখ্যার ব্যবহার A=1, B=2, C=3, ইত্যাদি)?

— আর কাপ,

1

আমি ইনপুট শূন্য করতে পারি?

— রোহান ঝুনঝুনওয়ালা

1

ফাঁকা বা অস্তিত্বহীন রড থেকে কোনও ডিস্ক নেওয়া হলে ত্রুটি নিক্ষেপ করা কি ঠিক আছে?

— আর কাপ,

1

আমরা কি ধরে নিতে পারি যে নন-মুভগুলি এর মতো হবে না A->A?

— মার্টিন ইন্ডার

2

@ কোবি আপনাকে moving discs to nonexistant rods.অবশ্যই অবশ্যই যাচাই করতে হবে হ্যাঁ, এটি একটিD

— এডসি 65

7

রেটিনা , 84 80 বাইট

^{-5 বাইটস মার্টিন ইন্ডারকে ধন্যবাদ}

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

এটি অনলাইন চেষ্টা করুন! (লাইন বাই লাইন পরীক্ষার জন্য আরও 5 বাইট)

কোডটি একটি সম্পূর্ণ গেম অনুকরণ করে।

ইনপুট হিসাবে দেওয়া হয় ACABCBACBABCAC~~~।
~~~তিনটি ডিস্ক মানে।
প্রথম চার লাইন খেলা বিন্যাসে ইনপুট রূপান্তর: ACABCBACBABCAC ~~~ ~~ ~ABC।
শুরুতে এ রডটিতে সমস্ত 3 টি ডিস্ক রয়েছে এবং বি এবং সি রড খালি রয়েছে।
এর পরে আমাদের দুটি পদক্ষেপের একটি লুপ রয়েছে:
- লাইনে প্রথম অক্ষর নিন, যা পরবর্তী উত্সের রডকে নির্দেশ করে। এই রডটি সন্ধান করুন এবং শেষ ডিস্কটি প্রবেশ করুন the চিঠিটি সরান এবং ডিস্কটিকে পুরোপুরি সরান (এটি তুলে নিন)।
  আউট উদাহরণে, প্রথম পদক্ষেপ পর, টেক্সট দেখতে কেমন হবে: ~CABCBACBABCAC ~~~ ~~ABC।
- দ্বিতীয় পর্যায়ে আমরা লক্ষ্য রডটি খুঁজে পাই এবং ডিস্কটি সেখানে স্থানান্তরিত করি। আমরা যাচাই যষ্টি খালি থাকে, বা উপরের একটি বড় ডিস্ক রয়েছে: ABCBACBABCAC ~~~ ~~AB ~C।
পরিশেষে আমরা নিশ্চিত করি যে এ এবং বি রডগুলি খালি রয়েছে - এর অর্থ সমস্ত ডিস্ক সি-তে রয়েছে (শেষ লাইনে একটি অতিরিক্ত স্থান রয়েছে)।

— কবি
সূত্র

বাহ, চিত্তাকর্ষক

— রোহান ঝুনঝুনওয়ালা

17

রেটিনা , 167 165 157 150 123 বাইট

এটি সম্পূর্ণরূপে চ্যালেঞ্জের মতো দেখাচ্ছে যা একক রেইগেক্সের সাথে সমাধান করা উচিত ... ("রেটিনা" বলে শিরোনাম থাকা সত্ত্বেও, এটি কেবল একটি ভ্যানিলা N

^(?=\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 এর ভারসাম্যমূলক গোষ্ঠীগুলির ভারী ব্যবহার করে। সম্পূর্ণ ব্যাখ্যার জন্য আমার স্ট্যাক ওভারফ্লোতে পোস্টটি দেখুন , তবে সংক্ষিপ্তসারটি হ'ল। নেট মধ্যে ক্যাপচারকারী গ্রুপগুলি হ'ল স্ট্যাকস, যেখানে প্রতিটি নতুন ক্যাপচার অন্য স্ট্রাস্টিংকে ঠেলে দেয় এবং যেখানে এই জাতীয় স্ট্যাক থেকে আবার পপ করাও সম্ভব। এটি আপনাকে স্ট্রিংয়ে বিভিন্ন পরিমাণ গণনা করতে দেয়। এই ক্ষেত্রে এটি আমাদের তিনটি রডকে সরাসরি তিনটি ভিন্ন ক্যাপচারিং গ্রুপ হিসাবে প্রয়োগ করতে দেয় যেখানে প্রতিটি ডিস্ক একটি ক্যাপচার দ্বারা প্রতিনিধিত্ব করা হয়।

রডগুলির মধ্যে ডিস্কগুলি প্রায় সরানোর জন্য আমরা (?<A-B>...)সিনট্যাক্সের একটি অদ্ভুত স্পর্শ ব্যবহার করি । সাধারণত, এটি স্ট্যাক থেকে একটি ক্যাপচারকে পপ করে Bএবং Aসেই পপ ক্যাপচার এবং এই গোষ্ঠীর সূচনার মধ্যবর্তী স্ট্রিংয়ের দিকে ধাক্কা দেয় । সুতরাং (?<A>a).(?<B-A>c)মিলেছে বিরুদ্ধে abcছেড়ে দিতেন Aখালি এবং Bসঙ্গে b(যেমন বিরোধিতা c)। তবে .NET ভেরিয়েবল-দৈর্ঘ্যের বর্ণমালার কারণে এটি ক্যাপচার (?<A>...)এবং (?<B-A>...)ওভারল্যাপ করা সম্ভব possible যে কারণেই হোক না কেন, যদি এটি হয় তবে দুটি গ্রুপের ছেদটি এগিয়ে চলেছে B। আমি এই উত্তরের ভারসাম্যপূর্ণ গ্রুপগুলিতে "উন্নত বিভাগে" এই আচরণটি বিশদ করেছি ।

রেজেক্সে। Rods A, Bএবং Cগ্রুপ মিলা 3, 4এবং 5Regex হবে। আসুন রডটি শুরু করে শুরু করি 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

প্রথমে সোর্স রড থেকে ডিস্ক নেওয়া:

(?=
  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। এটি কেবল তখনই ঘটতে পারে যদি ক) \Nকখনই মেলে না কারণ স্ট্যাক সম্পূর্ণ খালি বা খ) 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 বাইট

সংরক্ষিত 39 @Frozn কারণে অগণিত বাইট একটি পুরোনো ডিবাগ বৈশিষ্ট্য ঠাহর সেইসাথে কিছু চালাক golfing ঠাট।

গল্ফ সংস্করণ

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;}

প্রতিটি পদক্ষেপে ব্যাখ্যা এবং চমত্কার মুদ্রিত স্ট্যাকের সাথে নিরবচ্ছিন্ন

/*
 * 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!");
    }

}

অরোগল্ফড সংস্করণটির একটি বৈশিষ্ট্য রয়েছে যেখানে এটি স্ট্যাকগুলি প্রতিটি পদক্ষেপের মতো দেখতে কীভাবে মুদ্রণ করবে ...

[[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))?

— ফ্রোজেন

এটি স্ট্যাকগুলি প্রিন্ট করবে will ভালো লেগেছে [[২,১,০], [] []]

— রোহান ঝুনঝুনওয়ালা

ওফস @ ফ্রোজ এটি একটি ডিবাগ বৈশিষ্ট্য এখন অপসারণ করছে

— রোহান ঝুনঝুনওয়ালা

আমি জানি, কেবল সেখানে কেন ভাবছে :) আপনি এটির &&সাথে প্রতিস্থাপন করতে পারেন &।

— 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)। পাইথনের মতো, পার্শ্ববর্তী বন্ধনীগুলি alচ্ছিক। রডগুলি শূন্য-সূচকযুক্ত।

উদাহরণস্বরূপ, এই পরীক্ষার কেস:

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

হিসাবে দেওয়া হবে:

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

যদি সমাধানটি বৈধ হয়, তবে কিছু আউটপুট দেয় এবং 0 এর প্রস্থান কোড সহ প্রস্থান করে যদি এটি অবৈধ হয় তবে একটি ব্যতিক্রম ছোঁড়ে এবং 1 এর একটি প্রস্থান কোড সহ প্রস্থান করে IndexErrorযদি একটি অযৌক্তিক রডে চলে যাওয়া বা কোনও ডিস্ক ছাড়ার চেষ্টা করা হয় তবে একটি নিক্ষেপ করে যে রডটিতে কোনও ডিস্ক নেই, একটি ZeroDivisionErrorযদি একটি ডিস্ক একটি ছোট ডিস্কের উপরে স্থাপন করা হয়, বা NameErrorশেষে যদি প্রথম বা দ্বিতীয় রডগুলিতে ডিস্কগুলি থাকে।

@ কার্লকাস্টোরকে ধন্যবাদ 13 বাইট সংরক্ষিত!

@ এক্সনোরকে 8 টি বাইট সংরক্ষণ করা হয়েছে!

— তামা
সূত্র

1

প্রতিটি গাদা বাছাই করা চেকটি খুব জটিল বলে মনে হচ্ছে। আপনি কেবল যাচাই করতে পারবেন না যে সরানো ডিস্কটি যে স্তূপীর উপরে সঞ্চারিত হয়েছে তার উপরের ডিস্কের চেয়ে বড়?

— 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)])

আমার প্রোগ্রামে IndexError3 য় শর্তটি পূরণ না করা NameErrorহলে, দ্বিতীয় শর্তটি পূরণ না করা এবং False1 ম শর্তটি পূরণ না হলে আউটপুট দেয় । অন্যথায় আউটপুট True।

— আর কাপ
সূত্র

দুটি জিনিস: ভেরিয়েবলটি Yআপনার কোডে কখনই সংজ্ঞায়িত হয় না (আমার মনে হয় এটি জে হওয়া উচিত) এবং U[J]+=[Y,[U[K].pop()]][U[J]<[1]or U[K]<U[J]]3 টি অক্ষর দ্বারা সংক্ষিপ্ত হয়stmt1 if cond else stmt2

— জের্মানকু

@ জেরমেনকু ওয়েল, আমি যখন এই Yপরিবর্তনশীলটি ব্যবহার করি NameErrorযখনই দ্বিতীয় শর্তটি পূরণ হয় না raise আমি যদি পরিবর্তন Yকরতে চাই J, তবে NameErrorওঠানো হবে না। এই কারণে, আমি করতে পারবো না U[J]+=[Y,[U[K].pop()]][U[J]<[1]or U[K]<U[J]], কারণ এই একটি বাড়াতে হবে NameError সব সময় , তাই না শুধু যখন 2nd শর্ত পূরণ না করা হয়।

— আর কাপ,

ঠিক আছে, আপনার ব্যাখ্যার জন্য ধন্যবাদ!

— jermenkoo

5

ভিবিএ, 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) স্ট্রিং। আমন্ত্রণ স্প্রেডশীটে রয়েছে, = এইচ ([ডিস্কের সংখ্যা], [সরানোর স্ট্রিং])

অ্যারে এ বিভিন্ন ডিস্কের রড পজিশনটি ধরে রাখে। একটি পদক্ষেপ কেবল "থেকে" রড সংখ্যার প্রথম উপস্থিতিটিকে "থেকে" রড সংখ্যায় আপডেট করে। আপনি যদি প্রথমে একটি "টু" রড ডিস্কের মুখোমুখি হন বা "থেকে" রড ডিস্ক না পান তবে এটি একটি অবৈধ পদক্ষেপ। এ এর মোট "রড মান" L তে অনুষ্ঠিত হয়, যা 2N এ শেষ হওয়া দরকার। ত্রুটিগুলি E তে নেতিবাচক গণনা হিসাবে জমা হয়

অন্যান্য সমাধানগুলির সাথে মিল হিসাবে, একটি টাওয়ার থেকে একই টাওয়ারে একটি ডিস্ক "মুভিং" নিষিদ্ধ নয়। আমি এটি আরও 6 বাইট জন্য নিষেধ করতে পারে।

ফলাফল

প্রথম কলামে ফাংশন ফলাফল (শেষ এন = 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

পিএইচপি, 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 বা 2 উচ্চতার সংক্ষিপ্ততম পরীক্ষার ক্ষেত্রে 1 0 2 বা 2 0 1 0 2 1 2।
সত্যিকারের কেসগুলিতে ইকোস 1 এবং ভুয়া ক্ষেত্রে কিছুই নেই।
2 টি নোটিশ এবং 1 সতর্কতা দেয় যাতে এমন পরিবেশে চালিত হওয়া দরকার যা সেগুলি স্থির করে দেয়।

— user55641
সূত্র

1

জাভাস্ক্রিপ্ট (ES6), 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 টি যুক্তি সহ ফাংশন

আরগ 1, সংখ্যা, রিংয়ের সংখ্যা
আরগ 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 বাইট:

ভিবিএ, 234 217 213 196 বাইট

ফলাফল

পিএইচপি, 141 বাইট

জাভাস্ক্রিপ্ট (ES6), 108