भूलभुलैया से बचो!

20

आप इस 5x5 भूलभुलैया में फंस गए हैं - प्रत्येक कमरे को 1 से 25 तक लेबल किया गया है और निकास 1 कमरे में है।

यहाँ छवि विवरण दर्ज करें

आपको उस कक्ष के रूप में दिया जाता है जिस कक्ष में आप वर्तमान में हैं। आपका कार्य कमरे 1 तक पहुंचने के लिए आवश्यक सबसे छोटे अनुक्रम को स्थानांतरित करना है (उत्तर, पूर्व, दक्षिण, पश्चिम)।

जब तक आप वर्णों का उपयोग करते हैं, तब तक मूव्स किसी भी प्रारूप में आउटपुट हो सकते हैं (सूची, स्ट्रिंग, सरणी ...) n,w,e,s।

यहाँ सभी परीक्षण मामले हैं:

1 => empty string/list
2 => w
3 => ww
4 => swwnw
5 => wswwnw
6 => seenwnw
7 => nw
8 => wnw
9 => wwnw
10 => swwnwnw
11 => eenwnw
12 => enwnw
13 => nwnw
14 => wnwnw
15 => wwnwnw
16 => enenwnw
17 => nenwnw
18 => wnenwnw
19 => nwnwnw
20 => wnwnwnw
21 => nenenwnw
22 => enwnenwnw
23 => nwnenwnw
24 => wnwnenwnw
25 => nwnwnwnw

बाइट्स जीत में सबसे छोटा जवाब!

code-golf  kolmogorov-complexity 
— अरनॉड
स्रोत
3
कमरे का लेबलिंग / इनपुट कितना लचीला है? क्या हम 1-इंडेक्स के बजाय 0-इंडेक्स कर सकते हैं? क्या हम कमरे के नंबर को एक चरित्र के रूप में ले सकते हैं (सोच, जैसा कि बेस 36 में है)?
— चास ब्राउन
2
@Therandomguy नहीं, आपको इस विशिष्ट भूलभुलैया को संभालने की आवश्यकता है।
— अरनौद
6
चूंकि यह संभव है, मुझे लगता है कि सभी संभावित मामलों को परीक्षण मामलों में शामिल किया जाना चाहिए।
— जोनाथन फ्रेच
1
@UnrelatedString यह प्रश्न 1 इनपुट लेता है, और इसके इनपुट के आधार पर अलग-अलग पथ आउटपुट करता है। मेरा मानना ​​है कि यह आवश्यकता कोलमोगोरोव-जटिलता टैग के अनुकूल नहीं है ।
— tsh
2
किसी को भूलभुलैया में जवाब देने की आवश्यकता है ।
— ड्रेको 18s 15

जवाबों:

20

पायथन 2 , 64 बाइट्स

def f(n):d=0x1211252b5375>>2*n-4&3;print"nwes"[d];f(n+d*3+d%2-5)

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

एक फ़ंक्शन जो त्रुटि के साथ समाप्त करते हुए, प्रति पंक्ति एक दिशा प्रिंट करता है।

0x1211252b5375बेस 4 में निरंतर एन्कोडिंग 3 dसे प्रत्येक संख्या के रूप में हम प्रत्येक कमरे की संख्या से 3 दिशा में यात्रा करते हैं। निष्कर्षण अंक >>2*n-4&3भी n=1कोड को समाप्त करते समय एक नकारात्मक बदलाव त्रुटि देने के लिए डिज़ाइन किया गया है । हम कमरे नंबर अपडेट nके माध्यम से एक ऑफसेट उस दिशा की गणना के dरूप में d*3+d%2-5है, जो नक्शे:

d   d*3+d%2-5
0  -> -5
1  -> -1
2  ->  1
3  ->  5
— XNOR
स्रोत
1
मुझे यकीन नहीं है कि यदि यह मान्य है, तो फ़ंक्शन को पुन: प्रयोज्य किया जाना है, और आपको इस फ़ंक्शन को कॉल करने के बाद निष्पादन जारी रखने में सक्षम होने के लिए त्रुटि ट्रैपिंग ( try/ except) की आवश्यकता है ।
— आउटगॉल्फ
6

05AB1E , 30 29 बाइट्स

-1 बाइट प्राइम नंबर के साथ एक चमत्कारी संयोग के लिए धन्यवाद

[Ð#•θzƶ‰`Ó•4вsè<DˆØ·5-+}'‹™¯è

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

[                      }    # infinite loop:
 Ð                          #  triplicate the room number (initially, the input)
  #                         #  break if room number == 1
   •θzƶ‰`Ó•4в               #  compressed list 202232302231102210202010
             sè             #  use the room number to index into that list
               <            #  decrement
                Dˆ          #  add a copy to the global array
                  Ø         #  nth prime (-1 => 0, 0 => 2, 1 => 3, 2 => 5)
                   ·        #  double
                    5-      #  subtract 5
                      +     #  add that to the room number
'‹™                         # dictionary string "western"
   ¯                        # push the global array
    è                       # index (wraps around, so -1 => n, 0 => w, 1 => e, 2 => s)
— ग्रिमी
स्रोत
1
11खाली स्ट्रिंग के बजाय इनपुट के लिए यह आउटपुट (आसान फिक्स एक अग्रणी जोड़ने के लिए होगा õ?)। इसके अलावा, अच्छा जवाब!
— केविन क्रूज़सेन
1
@KevinCruijssen उस गलती को इंगित करने के लिए धन्यवाद! मुझे सिंगल-बाइट फिक्स मिला।
— ग्रिम्मी
5

रूबी , 72 62 बाइट्स

f=->n{n<2?'':' en  sw'[x=4*18139004[n]+6*4267088[n]-5]+f[n+x]}

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

कैसे?

यहाँ चाल प्रत्येक कक्ष के लिए अगले चरण का निर्माण करने के लिए 2 स्थिरांक का उपयोग करना है, फिर समस्या को पुन: हल करना है।

2 स्थिरांक 18139004 और 4267088 बाइनरी स्ट्रिंग्स हैं जो अगली चाल की दिशा देते हैं, प्रत्येक कोशिका के लिए दोनों में से एक बिट निकालकर, हम प्राप्त कर सकते हैं:

"n" = 4*0+6*0-5 = -5
"w" = 4*1+6*0-5 = -1
"e" = 4*0+6*1-5 = +1
"s" = 4*1+6*1-5 = +5

इधर-उधर शिफ्ट करने से ज्यादा आसान और सिंगल बाइनरी नंबर IMHO को मास्क करना है।

जब हमें दिशा मिलती है, तो हम स्ट्रिंग को "एन स्व" से संबंधित अक्षर निकालते हैं:

  1   5
  |   |
" en  sw"
   |   |
  -5  -1

और सेल पर पुनरावर्ती रूप से आगे बढ़ें [n + x]

— जीबी
स्रोत
3

पर्ल 5 ( -n), 94 बाइट्स

-5 बाइट्स ग्रिम के लिए धन्यवाद

@A=map/./g,__wwswsnwwseenwwenwnwnenwn;%H=(n,-5,s=>5,e,1,w,-1);$_+=$H{$,=$A[$_]},say$,until$_<2

TIO

— नहुएल फौलीउल
स्रोत
-8
— ग्रिम्मी
-2
— ग्रिम्मी
-5
— ग्रिम्मी
1
क्या आपका मतलब है कि मुझे इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए?
— ग्रिम्मी
1
हां, क्योंकि ऐसा लगता है कि आपने सबसे अधिक काम किया था, यह देखना दिलचस्प था कि हम हमेशा अंतरिक्ष को कैसे बचा सकते हैं
— नहुएल फौइउल
2

जावास्क्रिप्ट, 80 73 71 बाइट्स

चेस 'पायथन समाधान से अनुकूलित तो कृपया +1उसे भी।

f=n=>--n?(d=" wwswsnwwseenwwenwnwnenwn"[n])+f(n+~~{n:-4,s:6,e:2}[d]):``

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

1 बाइट ने अरनौल को धन्यवाद दिया ।

— झबरा
स्रोत
धन्यवाद, @Arnauld :) बस देखा था कि खुद को, भी।
— झबरा
2

चारकोल , 43 40 बाइट्स

ＮθＷ⊖θ«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι§nwesι≧⁺⁻⁺﹪ι²×³ι⁵θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। दोनों @ चासबोर्न और @ ज़्नोर के उत्तरों के आधार पर। स्पष्टीकरण:

Ｎθ

कमरे में इनपुट करें।

Ｗ⊖θ«

लूप चर iको कमरे की संख्या से कम पर सेट करें और गैर-शून्य होने पर दोहराएं।

«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι

संकुचित स्ट्रिंग से दिशा निकालें 0113130113220112010102010। (अग्रणी 0सिर्फ एक भराव अंक है।)

§nwesι

दिशा प्रिंट करें।

≧⁺⁻⁺﹪ι²×³ι⁵θ

नए कक्ष संख्या की गणना करने के लिए @ xnor के सूत्र का उपयोग करें।

— नील
स्रोत
2

जेली , 30 29 बाइट्स

“þ&ƊĿñ÷°e’b6Ḥ_5Ż⁸+ị¥ƬI‘ị“®ȯẹ»

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

प्रारंभिक सेल लेने और निर्देशों के साथ एक स्ट्रिंग वापस करने के लिए एक मोनोएडिक लिंक।

मुझे इस तथ्य से प्यार है कि जेली के शब्दकोश में 'केनेसॉ' (अटलांटा, जॉर्जिया के उत्तरपश्चिम का एक शहर) जैसा शब्द है, यहाँ इस्तेमाल किया जाता है क्योंकि इसमें साथ अनुक्रमण होता [5, 1, -5, -1] + 1है nesw!

व्याख्या

“þ...e’                    | Base-250 integer 1962789844189344852  
       b6                  | Convert to base 6 (2, 2, 5, 2, 5, 0, 2, 2, 5, 3, 3, 0, 2, 2, 3, 0, 2, 0, 2, 0, 3, 0, 2, 0)
         Ḥ                 | Double
          _5               | Subtract 5
            Ż              | Prepend 0
             ⁸  ¥Ƭ         | Using this as the right argument and the original link argument as the left argument, loop the following as a dyad until there is no change, collecting up results
              +            | - Add the left argument to:
               ị           |   - The left argument indexed into the right argument
                  I        | Differences between consecutive numbers
                   ‘       | Increment by 1
                    ị“®ȯẹ» | Index into "Kennesaw"
— निक केनेडी
स्रोत
2

PHP , 110 बाइट्स

एक समाधान जो चास ब्राउन के महान जवाब या xnor के महान जवाब का एक बंदरगाह नहीं है । मुझे पता है कि यह लंबा है लेकिन मैं एक अलग समाधान चाहता था!

for($n=$argn;$n>1;$n=ord($s[$n*2+1])%30)echo($s='0000w<w sEw"s)n w%w&s-e*e+n&w+w,e/n*w/n,w1n.e5n0w5n2')[$n*2];

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

मैंने एक मैपिंग स्ट्रिंग बनाई है जिसमें बोर्ड के प्रत्येक सेल के लिए 2 अक्षर हैं। प्रत्येक सेल के लिए पहला चरित्र एक चाल है (n / e / s / w) या 0दूसरा चरित्र ASCII कोड mod 30 एक और सेल नंबर लौटाएगा, जिसे हम सेल से बाहर निकलने तक ( cell < 2) में पुनरावृत्ति मोड में उसके कदम का पालन करना चाहिए ।

8 के इनपुट के लिए उदाहरण के लिए:

  • सेल के लिए 2 वर्ण 8हैं:w%
  • इसका मतलब है wसेल के लिए चाल के साथ प्रिंट और जारी रखना%
  • ASCII का कोड %37 है, जो मॉड 30 का 7 होगा, इसलिए अगली सेल का अनुसरण करना है 7।
  • सेल के लिए 2 वर्ण 7हैं: n (अंतिम वर्ण स्थान है, ASCII कोड = 32)
  • इसका मतलब है कि n32 मॉड 30 की सेल के लिए मूव्स को प्रिंट और जारी रखें 2।
  • सेल के लिए 2 वर्ण 2हैं: w<(अंतिम वर्ण ASCII कोड = 60)
  • इसका मतलब है कि w60 मॉड 30 की सेल के लिए मूव्स को प्रिंट और जारी रखें 0।
  • यदि सेल संख्या से कम है 2, तो लूप बंद हो जाता है!
  • अंतिम मुद्रित परिणाम: wnw

PHP , 75 बाइट्स

यह संस्करण ग्रिमी द्वारा लिखा गया है , यह मेरे मूल उत्तर से 35 बाइट्स छोटा है क्योंकि वह चालाक है! ग्रिम की टिप्पणी: "4 * 25 <256, इसलिए आपको प्रति सेल 1 बाइट की आवश्यकता है, न कि 2"

for($n=$argn;$n=ord("0\0~f;6o4R:s%ql&rup*@^tIDbx"[$n%25]);)echo news[$n%4];

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

PHP , 71 बाइट्स

इस बंदरगाह Arnauld के जवाब जिनमें से बंदरगाह है XNOR का जवाब है, लेकिन एक पाश के बजाय पुनरावर्ती समारोह के रूप में, के बाद से यह पता चला है PHP में छोटा होना।

for($n=$argn;--$n;$n+=$d*3+$d%2-4)echo nwes[$d=79459389361621/4**$n&3];

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

— Night2
स्रोत
2
4 * 25 <256, इसलिए आपको केवल प्रति सेल 1 बाइट की आवश्यकता है, 2 नहीं: इसे ऑनलाइन आज़माएं!
— ग्रैमी
1
@ अद्भुत, अद्भुत, मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना होगा, यह काफी अलग है।
— Night2
1
मैं ऐसा करने वाला नहीं हूं, इसलिए आप इसे अपने उत्तर में शामिल करें या इसे केवल एक टिप्पणी के रूप में छोड़ दें।
— ग्रिम्मी
1
@Grimy, अपने नाम के साथ अपना संस्करण जोड़ा। फिर भी धन्यवाद।
— नाइट 2
2

सी (क्लैंग) , 81 बाइट्स

v;f(p){p-1&&putchar(v="00wwswsnwwseenwwenwnwnenwn"[p])+f(p+=v%5?6-v%8:v%2?5:-5);}

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

@ Tommylee2k सुझाव -8 का धन्यवाद! + पुनरावर्ती कॉल

सी (क्लैंग) , 90 बाइट्स

v;f(p){for(char*l="00wwswsnwwseenwwenwnwnenwn";p-1;p+=v%5?6-v%8:v%2?5:-5)putchar(v=l[p]);}

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

सभी संपीड़ित समाधानों के समान नहीं।

— AZTECCO
स्रोत
1
छोटा किया जा सकता है:v;f(p){for(;p-1;p+=v%5?6-v%8:v%2?5:-5)putchar(v="00wwswsnwwseenwwenwnwnenwn"[p]);}
— Tommylee2k
1

05AB1E , 45 43 बाइट्स

õ?[Ð#.•DUo¢ê`Ω÷‰₂¡)R€ûK•¦sè©?Ž₁9₂в6-'€Ã®kè+

पोर्ट @ChasBrown के पायथन 2 का जवाब ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

õ?               # Output an empty string
                 # (to overwrite the implicit output if the input is 1)
[                # Start an infinite loop:
 Ð               #  Triplicate the top of the stack
                 #  (which is the (implicit) input in the first iteration)
  #              #  If it's exactly 1: stop the infinite loop
  .•DUo¢ê`Ω÷‰₂¡)R€ûK•
                 #  Push compressed string "a  wwswsnwwseenwwenwnwnenwn"
   ¦             #  Remove the first character
    sè           #  Swap to get the number, and use it to index into the string
      ©          #  Store it in variable `®` (without popping)
       ?         #  Print it without trailing newline
  Ž₁9            #  Push compressed integer 22449
     ₂в          #  Convert to base-26 as list: [1,7,5,11]
       6-        #  Subtract 6 from each: [-5,1,-1,5]
         '€Ã    '#  Push dictionary string "news"
            ®k   #  Get the index in this string of character `®`
              è  #  And use that to index into the integer-list
               + #  And add it to the originally triplicated integer

यह समझने के लिए मेरा (सभी चार वर्गों) का 05AB1E टिप देखें कि क्यों .•DUo¢ê`Ω÷‰₂¡)R€ûK•है "a wwswsnwwseenwwenwnwnenwn"; Ž₁9है 22449; Ž₁9₂вहै [1,7,5,11]; और '€Ãहै "news"।

— केविन क्रूज़सेन
स्रोत
1
यह सुविधाजनक शब्दकोश स्ट्रिंग अच्छी खबर रही होगी!
— नील
@ निएल निश्चित रूप से। :) हालांकि स्पष्ट रूप से शब्दकोश स्ट्रिंग westernबेहतर है। ; पी
— केविन क्रूज़सेन
1

बैश , 120 बाइट्स

S=__wwswsnwwseenwwenwnwnenwn
N=n-5w-1s05e01
for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }

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

मैं थोड़ी देर के लिए स्ट्रिंग को निबल्स के रूप में पैक करने की कोशिश कर रहा था, लेकिन डिकोडिंग को सहेजे गए संख्या से अधिक वर्णों की आवश्यकता होगी।

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

S=__wwswsnwwseenwwenwnwnenwn

स्ट्रिंग $ S प्रत्येक कमरे के लिए एक एकल वर्ण (n, w, s, e) रखता है, जिसमें से एक कमरे को बाहर निकलने की दिशा में ले जाने के लिए दिशा निर्देश दिया गया है, कमरे 0 और 1 को छोड़ दिया गया है।

N=n-5w-1s05e01

स्ट्रिंग $ N में प्रत्येक दिशा परिवर्तन (n: -5, w: -1, s: +5, e: +1) के लिए वर्तमान कक्ष संख्या से जोड़ने / घटाने का डेल्टा है।

for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }

कमांड लाइन ($ 1) पर दिए गए कमरे की संख्या के बराबर $ i से शुरू करें। सूचकांक $ i में स्ट्रिंग $ S से $ d तक वर्ण निर्दिष्ट करें। अगले कमरे में ले जाने के लिए $ n से डेल्टा मूल्य को पुनः प्राप्त करें, इसे $ j पर नियत करें।

$ D में लेने के लिए अगली दिशा प्रिंट करें।

$ J में / से $ i तक डेल्टा जोड़ें / घटाएँ।

जब तक हम कमरा # 2 नहीं छोड़ते तब तक लूप करें (जबकि $ i> 1)।

— spuck
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.