रोटेशन पहेली को हल करें


14

नोकिया के कुछ पुराने फोनों में, रोटेशन नामक पंद्रह पहेली की भिन्नता थी । इस भिन्नता में, एक समय में एक टाइल को खिसकाने के बजाय, आपने एक समय में एक दिशा में चार टाइल घुमाई।

इस खेल में, आप इस तरह एक बोर्ड के साथ शुरू करेंगे:

4 9 2
3 5 7
8 1 6

और निचले-बाएँ ब्लॉक को दो बार दक्षिणावर्त और ऊपरी-बाएँ ब्लॉक को एक बार क्लॉकवाइज़ में घुमाकर, आपको यह मिल जाएगा:

4 9 2
8 3 7
1 5 6

4 9 2
1 8 7
3 5 6

1 4 2
8 9 7
3 5 6

और 1टाइल शीर्ष-बाएं कोने में होगी जहां यह माना जाता है। आखिरकार, कुछ और चालों के बाद, आप समाप्त करेंगे:

1 2 3
4 5 6
7 8 9

जो "मूल" कॉन्फ़िगरेशन है।

आपका कार्य एक ऐसा प्रोग्राम बनाना है जो 1 से 9 तक की संख्याओं के 3x3 ग्रिड को इनपुट के रूप में लेगा (किसी भी प्रारूप में जिसे आप चुनते हैं) और आउटपुट के रूप में वापस ले जाते हैं, चाल का एक क्रम जो आपको बोर्ड को उसके मूल में वापस करने के लिए ले जाना चाहिए। कॉन्फ़िगरेशन (फिर से, आपके द्वारा चुने गए किसी भी प्रारूप में)। कानूनी चाल को [शीर्ष / तल] - [छोड़ दिया / सही] 4 टाइल्स के ब्लॉक [घड़ी की दिशा / वामावर्त] के रूप में परिभाषित किया गया है।

आपका प्रोग्राम सभी संभव 3x3 ग्रिड को हल करने में सक्षम होना चाहिए (सभी क्रमपरिवर्तन हल करने योग्य हैं)।

इस जीत के लिए सबसे छोटा कोड।


...and return as output a sequence of moves representing the moves you must take to return the board back to its originalक्या इसका मतलब "वापस 1 2 3\n4 5 6\n7 8 9" है? मुझे यकीन नहीं है कि इसे कैसे पढ़ा जाए।
भूमिगत

हां, मेरा मतलब है 1 2 3 4 5 6 7 8 9.
जो जेड

1
मुझे लगता है कि आपके उदाहरण में दूसरा और तीसरा बोर्ड 3 और 5 स्वैप होना चाहिए।
मार्टिन एंडर

@JoeZ। मैं यह घोषित करने के लिए इसे संशोधित करने का सुझाव दूंगा कि समाधान में एक खराब स्थिति का प्रदर्शन होना चाहिए।
HostileFork का कहना है कि

जवाबों:


7

गोल्फस्क्रिप्ट, 39/83 बाइट्स

# Optimized for size:

{.4rand.p.2/+>`{?1420344440`=}+$..$>}do

# Optimized for speed:

6,(7++:t;~{.(1=.@7=9=+4\-rand+..2/+@.@>:s^[3s=0s=2s=4s=1s=]+s|.)9<\t>|}do.$>30764`*

गति बनाम आकार

आकार-अनुकूलित संस्करण बेतरतीब ढंग से क्लॉकवाइज़ घुमाव चुनता है जब तक कि वांछित क्रमचय प्राप्त नहीं होता है। यह पर्याप्त है, क्योंकि एक वामावर्त घुमाव एक ही वर्ग के तीन लगातार दक्षिणावर्त घूमने के बराबर है।

गति-अनुकूलित संस्करण निम्न को छोड़कर समान करता है:

  1. यदि नंबर 1 ऊपरी बाएँ कोने में है, तो यह ऊपरी बाएँ वर्ग को और नहीं घुमाता है।

  2. यदि संख्या 9 निचले दाएं कोने में है, तो यह निचले दाएं वर्ग को कभी भी घुमाती नहीं है।

  3. 7 और 8 की अदला-बदली के लिए कदम हार्डकोड हैं, इसलिए दो स्थितियां हैं जो लूप को तोड़ने की अनुमति देती हैं।

एल्गोरिथ्म को बदलने के अलावा, गति-अनुकूलित संस्करण एक सरल तरीके से रोटेशन को प्राप्त करता है, जबकि आकार-ऑप्टिमेटेड संस्करण मैपिंग द्वारा गोल्फस्क्रिप्ट के अंतर्निहित सॉर्ट का उपयोग करता है। यह हर पुनरावृत्ति में राज्य को छाँटने के बजाय अंतिम अवस्था (तुलना के लिए) को हार्डकोड करता है।

गति-अनुकूलित संस्करण को कम पुनरावृत्तियों की आवश्यकता होती है और प्रत्येक पुनरावृत्ति अपने आप में बहुत तेज़ होती है।

मानक

मैंने संख्याओं के पदों को रैंडम करने और टेस्ट रन बनाने के लिए निम्न कोड का उपयोग किया है, जो कि संस्करण के अनुरूप लाइन को असुविधाजनक बनाते हैं:

[{[
    0:c;10,1>{;2 32?rand}$
    #{c):c;.4rand.2/+>`{?1420344440`=}+$..$>}do
    #6,(7++:t;{.(1=.@7=9=+4\-rand+..2/+@.@>:s^[3s=0s=2s=4s=1s=]+s|.)9<\t>|}do.$>30764`*
],c+}\~*]

$.0='Min: '\+puts .-1='Max: '\+puts ..{+}*\,/'Avg: '\+puts .,2/='Med: '\+

आउटपुट न्यूनतम और अधिकतम चरणों को दिखाता है जो संख्याओं को क्रमबद्ध करने के लिए उठाए गए थे, औसत और सभी रनों का औसत और साथ ही साथ सेकंड में बीता हुआ समय:

$ TIME='\n%e s' time golfscript rotation-test-size.gs <<< 100
Min: 4652
Max: 2187030
Avg: 346668
Med: 216888

21500.10 s
$
$ TIME='\n%e s' time golfscript rotation-test-speed.gs <<< 1000
Min: 26
Max: 23963
Avg: 3036
Med: 2150

202.62 s

मेरी मशीन (Intel Core i7-3770) पर, आकार-अनुकूलित संस्करण का औसत निष्पादन समय 3.58 मिनट था। गति-अनुकूलित संस्करण का औसत निष्पादन समय 0.20 सेकंड था। इस प्रकार, गति-अनुकूलित संस्करण लगभग 1075 गुना तेज है।

गति-अनुकूलित संस्करण 114 गुना कम घुमाव देता है। प्रत्येक घुमाव का प्रदर्शन 9.4 गुना धीमा है, जो मुख्य रूप से राज्य को अद्यतन करने के कारण है।

आई / ओ

आउटपुट में 3-बिट संख्याएँ होती हैं। MSB को वामावर्त घुमावों के लिए सेट किया जाता है, मध्य बिट को निचले वर्गों के लिए और LSB को सही वर्गों के लिए सेट किया जाता है। इस प्रकार, 0 (4) ऊपरी बाएँ वर्ग है, 1 (5) ऊपरी दाएँ एक, 2 (6) निचले बाएँ और 3 (7) निचले दाएँ एक।

गति-अनुकूलित संस्करण सभी घुमावों को एक पंक्ति में प्रिंट करता है। आकार-अनुकूलित संस्करण प्रति पंक्ति एक रोटेशन प्रिंट करता है, इसके बाद संख्याओं की अंतिम स्थिति होती है।

गति-अनुकूलित संस्करण के लिए, इनपुट को एक सरणी प्राप्त करना होता है जिसमें मूल्यांकन किए जाने पर 1 से 9 तक की संख्या होती है। आकार-अनुकूलित संस्करण के लिए, इनपुट को अंतिम न्यूलाइन के बिना एक स्ट्रिंग होना चाहिए; इसका मूल्यांकन नहीं किया जाता है।

उदाहरण चलता है:

$ echo -n '253169748' | golfscript rotation-size.gs
3
0
123456789
$ golfscript rotation-speed.gs <<< '[5 4 7 1 2 9 3 8 6]'
2210300121312212222212211121122211122221211111122211211222112230764

आकार-अनुकूलित कोड

{               #
  .             # Duplicate the state.
  4rand         # Push a randomly chosen integers between 0 and 3.
  .p            # Print that integer.
  .2/+          # Add 1 to it if it is grater than one. Possible results: 0, 1, 3, 4
  >`            # Slice the state at the above index.
  {             # Push a code block doing the following:
    ?           # Get the index of the element of the iteration in the sliced state.
    1420344440` # Push the string "14020344440".
    =           # Retrieve the element at the position of the computed index.
  }+            # Concatenate the code block with the sliced state.
  $             # Sort the state according to the above code block. See below.
  ..$>          # Push two copies of the state, sort the second and compare the arrays.
}do             # If the state is not sorted, repeat the loop.

राज्य का अद्यतन निम्न प्रकार से किया जाता है:

रोटेशन 2 1 जोड़ने के बाद पूर्णांक 3 पैदावार करता है। यदि राज्य "123456789" है, तो राज्य को पैदावार "456789" मिलती है।

"$" निष्पादित करने से ठीक पहले, स्टैक के सबसे ऊपरी तत्व हैं:

[ 1 2 3 4 5 6 7 8 9 ] { [ 4 5 6 7 8 9 ] ? "1420344440" = }

"$" एरे के प्रत्येक तत्व के लिए एक बार ब्लॉक को निष्पादित करता है, जो कि तत्व को स्वयं धकेलने के बाद सॉर्ट किया जाता है।

"1 [4 5 6 7 8 9]" में 1 का सूचकांक -1 (वर्तमान नहीं) है, इसलिए "1420344440" के अंतिम तत्व को धक्का दिया गया है। यह 48 की पैदावार देता है, चरित्र के अनुरूप ASCII कोड 0. 2 और 3 के लिए, 48 को भी धकेल दिया जाता है।

पूर्णांक 4, 5, 6, 7, 8 और 9 के लिए 49, 52, 50, 48, 51 और 52 हैं।

छँटाई के बाद, राज्य का पहला तत्व 48 से उपजने वाले तत्वों में से एक होगा; अंतिम उन 52 में से एक होगा। अंतर्निहित सॉर्ट सामान्य रूप से अस्थिर है, लेकिन मैंने अनुभवजन्य रूप से सत्यापित किया है कि यह इस विशेष मामले में स्थिर है।

परिणाम "[1 2 3 7 4 6 8 5 9]", जो निचले बाएं वर्ग के एक दक्षिणावर्त रोटेशन से मेल खाती है।

स्पीड-अनुकूलित कोड

6,(7++:t;       # Save [ 1 2 3 4 5 7 ] in variable “t” and discard it.
~               # Interpret the input string.
{               #
  :s            # Duplicate the current state.
  (1=           # Unshift the first element and push 1 if it is equal to 1 and 0 otherwise.
  .@            # Duplicate the boolean and rotate the unshifted array on top of it.
  7=9=          # Push 1 if the eighth element of “s” is equal to 9 and 0 otherwise.
  +4\-          # Add the booleans and subtract their sum from 4.
  rand          # Push a randomly chosen integers between 0 and the result from above.
  +.            # Add this integer to the first boolean and duplicate it for the output.
  .2/+          # Add 1 to the result if it is grater than one. Possible results: 0, 1, 3, 4
  @.            # Rotate the state on top of the stack and duplicate it.
  @>:s          # Slice the state at the integer from above and save the result in “s”.
  ^             # Compute the symmetric difference of state and sliced state.
  [             # Apply a clockwise rotation to the sliced array:
    3s=         # The fourth element becomes the first.
    0s=         # The first element becomes the second.
    2s=         # The third element remains the same.
    4s=         # The fifth element becomes the fourth.
    1s=         # The second element becomes the fifth.
  ]             # Collect the results into an array.
  +             # Concatenate with array of elements preceding the slice.
  s|            # Perform set union to add the remaining elements of “s”.
  .             # Duplicate the updated state.
  )9<           # Pop the last element; push 0 if it is equal to 9 and 1 otherwise.
  \t            # Swap the popped state on top and push [ 1 2 3 4 5 7 ].
  >             # Push 0 if the state begins with [ 1 2 3 4 5 6 ] and 1 otherwise.
  |             # Take the logical OR of the booleans.
}do             # If the resulting boolean is 1, repeat the loop.
.$              # Duplicate the state and sort it.
>30764`*        # If the state was not sorted, 7 and 8 are swapped, so push "30764".

निरीक्षण करें कि शेष 7 तत्वों के पदों में फेरबदल किए बिना, रोटेशन 3, 0, 7, 6 और 4, तत्वों को 7 और 8 की स्थिति में स्वैप करते हैं।


गति के लिए अनुकूलित? यह गोल्फस्क्रिप्ट है ...
ʇǝɥʇıʇǝɥʇuss

1
@Synthetica: फिर भी, यह सबसे तेज़ समाधान है जिसे अब तक पोस्ट किया गया है।
डेनिस

4

नम्पी के साथ अजगर - 158

from numpy import*
A=input()
while any(A.flat>range(1,10)):i,j,k=random.randint(0,2,3);A[i:i+2,j:j+2]=rot90(A[i:i+2,j:j+2],1+2*k);print"tb"[i]+"lr"[j]+"wc"[k]

इनपुट निम्न प्रारूप का होना चाहिए:

array([[1,2,5],[4,3,6],[7,8,9]])

प्रत्येक उत्पादन लाइन एक कदम की तरह तार में इनकोडिंग है trwया blcऔर इस प्रकार पढ़ा जाए:

  • t: ऊपर
  • b: तल
  • l: बाएं
  • r: सही
  • c: दक्षिणावर्त
  • w: काउंटर-क्लॉकवाइज (विद्दिशिन्स)

यह प्रोग्राम लक्ष्य कॉन्फ़िगरेशन तक पहुंचने तक यादृच्छिक चालें करता है। इस अनुमान के तहत कि हर कदम में 1/9 की स्वतंत्र संभावना है! लक्ष्य विन्यास को हिट करने के लिए, एक समाधान से पहले घुमाव की संख्या 9 के एक औसत (यानी, औसत संख्या) के साथ तेजी से वितरित की जाती है! ⁵ 3.6 · 10≈। यह एक छोटे प्रयोग (20 रन) के अनुसार है।

¹ ९! कॉन्फ़िगरेशन की कुल संख्या होने के नाते।


2
तो अनिवार्य रूप से यह एक चाल को प्राप्त करने तक यादृच्छिक चाल की कोशिश करता है?
जो जेड

मेरे लिये कार्य करता है। यद्यपि मुझे समाधान के पहुंचने से पहले अपेक्षित रोटेशन की संख्या में दिलचस्पी होगी।
जो जेड

@ जोज़:। मेरी पोस्ट को संपादित देखें।
१०

वह तो कमाल है।
काइल कानोस

4

C ++ सबसे छोटी चाल का हल - चौड़ाई पहले (1847 वर्ण)

थोड़ा और सोचा जाने के बाद, मुझे लगता है कि मैंने यह बहुत कुशलता से और अधिक समझदारी से किया है। यह समाधान, जबकि यह निश्चित रूप से इस गोल्फ को नहीं जीत रहा है, अब तक केवल एक ही है जो कि कम से कम चक्कर लगाने की कोशिश करेगा जो बोर्ड को हल करेगा। अब तक, यह नौ या उससे कम चालों में मेरे द्वारा फेंके गए हर यादृच्छिक बोर्ड को हल करता है। यह मेरे पिछले एक से भी बेहतर प्रदर्शन करता है और उम्मीद है, नीचे डेनिस की टिप्पणियों को संबोधित करता है।

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

अब, यह विभिन्न बोर्ड राज्यों पर पहली सरल खोज है। इसके अलावा, जैसा कि यह पता चला है, मेरी कुंजी सेट को बदलना चाहती है (वर्तमान में बेस -9 में संख्याओं के सेट के रूप में संग्रहीत है, जिनमें से प्रत्येक बीएस द्वारा गणना की जाती है: बोर्ड के बेस -9 प्रतिनिधित्व के रूप में कुंजी) एक बिटसेट पर 9 होने! बिट्स की जरूरत है लगता है; हालांकि मुझे यह पता चला कि "तथ्यात्मक संख्या प्रणाली" में एक कुंजी की गणना कैसे की जाती है, जिसे बिटसेट में परीक्षण / टॉगल करने के लिए गणना करने के लिए इस्तेमाल किया जा सकता था।

तो, नवीनतम समाधान है:

#include <iostream>
#include <list>
#include <set>
#include <vector>
using namespace std;
struct BS{
#define LPB(i) for(int*i=b;i-b<9;i++)
struct ROP{int t, d;};
typedef vector<ROP> SV;
typedef unsigned int KEY;
typedef set<KEY> KH;
BS(const int*d){const int*x=d;int*y=b;for(;x-d<9;x++,y++)*y=*x;}
BS(){LPB(i)*i=i-b+1;}
bool solved(){LPB(i)if(i-b+1!=*i)return 0;return 1;}
void rot(int t, int d){return rot((ROP){t,d});}
void rot(ROP r){rotb(r);s.push_back(r);}
bool undo(){if (s.empty())return false;ROP &u=s.back();u.d*=-1;rotb(u);s.pop_back();return true;}
SV &sol(){return s;}
KEY key(){KEY rv=0;LPB(i){rv*=9;rv+=*i-1;}return rv;}
int b[9];
SV s;
void rotb(ROP r){int c=r.t<2?r.t:r.t+1;int bi=(r.d>0?3:4)+c;const int*ri=r.d>0?(const int[]){0,1,4}:(const int[]){1,0,3};for(int i=0;i<3;i++)swap(b[bi],b[c+ri[i]]);}
};
ostream &operator<<(ostream &o, BS::ROP r){static const char *s[]={"tl","tr","bl","br"};o<<s[r.t]<<(r.d<0?"w":"c");return o;}
struct DKH{
~DKH(){for(HV::iterator i=h.begin();i<h.end();++i)if(*i!=NULL)delete *i;}
void add(int d,BS b){h.resize(d+1);if(h[d]==NULL)h[d]=new BS::KH();h[d]->insert(b.key());}
bool exists(BS &b){BS::KEY k=b.key();size_t d=min(b.sol().size(),h.size()-1);do if (h[d]->find(k)!=h[d]->end())return true;while(d--!=0);return false;}
typedef vector<BS::KH *> HV;HV h;
};
static bool solve(BS &b)
{
const BS::ROP v[8]={{0,-1},{0,1},{1,-1},{1,1},{2,-1},{2,1},{3,-1},{3,1}};
DKH h;h.add(0,b);
list<BS> q;q.push_back(b);
while (!q.empty())
{
BS qb=q.front();q.pop_front();
if (qb.solved()){b=qb;return true;}
int d=qb.sol().size()+1;
for (int m=0;m<8;++m){qb.rot(v[m]);if (!h.exists(qb)){h.add(d,qb);q.push_back(qb);}qb.undo();}
}
return false;
}
int main()
{
BS b((const int[]){4,9,2,3,5,7,8,1,6});
if (solve(b)){BS::SV s=b.sol();for(BS::SV::iterator i=s.begin();i!=s.end();++i)cout<<*i<<" ";cout<<endl;}
}

1
आपका कोड C के बजाय C ++ जैसा दिखता है
user12205

@ace, वास्तव में यह सही है।
ड्रीमवर्यर

यदि किसी और के पास जी ++ के साथ इसे संकलित करने के मुद्दे हैं, तो मुझे ध्वज को स्थापित int[]करने const int[]और स्थापित करने के सभी उदाहरणों को बदलना होगा -fpermissive
डेनिस

@ डेनिस, इस बारे में क्षमा करें, मैंने इसे दो अलग-अलग जी ++ संकलक के साथ संकलित किया है और न ही ऐसा लगता है। लेकिन, मैं देख सकता हूं कि एक नया, सख्त, संस्करण कैसे होगा। धन्यवाद।
ड्रीमवर्यर

अब अच्छी तरह से संकलित है और यह बहुत तेज़ है। प्रश्न से हटाए गए टिप्पणी को संबोधित करना: कुछ क्रमपरिवर्तन हैं जिनमें 11 चरणों की आवश्यकता होती है। 978654321 उनमें से एक है।
डेनिस

1

CJam - 39

l{4mr_o_1>+_@m<_[Z0Y4X]\f=\5>+m>__$>}g;

एक और यादृच्छिक सॉल्वर :)
यह एक स्ट्रिंग लेता है जैसे 492357816 और 0 से 3 तक अंकों की एक लंबी (लंबी) श्रृंखला को आउटपुट करता है, प्रत्येक ब्लॉक के एक दक्षिणावर्त रोटेशन का प्रतिनिधित्व करता है: 0 = टॉप-लेफ्ट, 1 = टॉप-राइट, 2 = बॉटम -टेफ्ट, 3 = नीचे-दाएं।

संक्षिप्त विवरण:

4mr0 से 3 से एक यादृच्छिक संख्या उत्पन्न करता है
_1>+वेतन वृद्धि संख्या अगर यह के 1 से अधिक (ताकि हम 0, 1, 3 या 4 के साथ अंत - 4 ब्लॉक के शुरू करने से अनुक्रमित)
m<स्ट्रिंग बाईं ओर (जैसे 492,357,816 के रूप में घूमता है -> ब्लॉक को पहली स्थिति में घुमाने के लिए 923578164, ब्लॉक रोटेशन नहीं) ब्लॉक रोटेशन को नियंत्रित
[Z0Y4X]\f=करता है जो पहले 5 वर्णों को प्रभावित करता है, जैसे कि 12345 -> 41352;
X = 1, Y = 2, Z = 3 इसलिए [Z0Y4X] वास्तव में [3 0 2 4 1] है और वे 0 घुमाए गए टाइलों के 0-आधारित इंडेक्स हैं
5>, बाकी स्ट्रिंग स्ट्रिंग
m>(संशोधित) स्ट्रिंग वापस घुमाता है सही
__$>जाँच अगर स्ट्रिंग छँटाई है (यह रोक की स्थिति है)


1

गणितज्ञ, १०४ वर्ण

हम कार्य को क्रमबद्ध करने वाले समूहों की भाषा में व्याख्या कर सकते हैं। चार घुमाव सिर्फ चार क्रमपरिवर्तन हैं जो सममित समूह S 9 उत्पन्न करते हैं , और कार्य केवल जनरेटरों के उत्पाद के रूप में क्रमपरिवर्तन लिखना है। Mathematica के पास ऐसा करने के लिए एक अंतर्निहित फ़ंक्शन है।

i={1,2,5,4};GroupElementToWord[PermutationGroup[Cycles/@({i}+#&/@i-1)],Input[]~FindPermutation~Range@9]

उदाहरण:

इनपुट:

{4, 9, 2, 8, 3, 7, 1, 5, 6}

आउटपुट:

{-2, -3, -4, 2, 4, 1, 4, -1, -2, 3, 2, -4, 3, 4, -3, -3, -4, -4, -2, -2, -3, -2, 3, -1}
  • 1: ऊपर-नीचे दक्षिणावर्त
  • 2: टॉप-राइट क्लॉकवाइज
  • 3: नीचे-दाएं दक्षिणावर्त
  • 4: नीचे-बाएँ दक्षिणावर्त
  • -1: शीर्ष-वाम वामावर्त
  • -2: टॉप-राइट काउंटरलॉक वाइज
  • -3: नीचे-दाएं वामावर्त
  • -4: नीचे-बाएँ वामावर्त
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.