मैं तुम्हें प्यास से मरते हुए देखना चाहता हूं


12

आप दो शहरों के बीच रेगिस्तान को पार करते हुए एक यात्री हैं। आप बिना रुके पर्याप्त पानी नहीं ले जा सकते। यह एक क्लासिक पहेली का रूपांतर है।

नियम

एक रेगिस्तान इस तरह दिखता है: ज्यादातर खाली जगह का एक WxH ग्रिड। चिन्हित स्थान वह जगह Sहै जहाँ आप शुरू करते हैं, Eवह स्थान है जहाँ आप समाप्त करना चाहते हैं, और एन के साथ चिह्नित एक वर्ग पानी की एन इकाइयों को धारण करता है। वर्गों को एक .पकड़ शून्य पानी के साथ चिह्नित किया गया है ।

.....................................
........S............................
.....................................
.........7...........................
.....................................
.......................3.............
.....5...............................
................................2....
.....................................
.....................................
.....................................
...............................E.....
.....................................
....................7................
.....................................
.....................................

आप 5 यूनिट पानी के साथ S पर शुरू करते हैं।

आप अधिकतम 5 यूनिट पानी ले जा सकते हैं।

प्रत्येक तुम बारी

  1. एक वर्ग ऊपर, नीचे, बाएँ, या दाएँ,
  2. 1 यूनिट पानी का उपभोग करें जिसे आप ले जा रहे हैं,
  3. लेने या ड्रॉप पानी की इकाइयों में से कुछ संख्या।

एक बारी इस प्रकार notated है: (direction)(+|-)(units of water), +यह संकेत करता है कि आप पानी उठा रहे हैं, -कि आप इसे छोड़ रहे हैं।

उदाहरण बदल जाता है:

D+0        Move Down
R+0        Move Right
D+2        Move Down, pick up two units of water.
U-1        Move Up, drop one unit of water.

यदि आप उपरोक्त उदाहरण में S से शुरू होने वाली इन चालों को करते हैं, तो रेगिस्तान बाद में इस तरह दिखता है।

.....................................
........S............................
.........1...........................
.........5...........................
.....................................
.......................3.............
.....5...............................
................................2....
.....................................
.....................................
.....................................
...............................E.....
.....................................
....................7................
.....................................
.....................................

आप अपने वर्ग पर पहले से ही अधिक पानी नहीं उठा सकते हैं। जब आप पानी उठाते हैं, तो टाइल की गिनती से इकाइयों की संख्या घटाएं।

आप अधिकतम 5 इकाइयों को रखने के लिए केवल पानी उठा सकते हैं।

कोई भी टाइल 9 यूनिट से अधिक नहीं रख सकती है, सिवाय इसके कि अनंत यूनिट रखती है।

आप केवल उतना पानी गिरा सकते हैं जितना आप वर्तमान में पकड़ रहे हैं।

जमीन पर पानी अपरिवर्तित रहता है जब तक आप इसे फिर से नहीं उठाते।

यदि आप S पर लौटते हैं तो आप पानी की किसी भी मात्रा को बिना गिराए उठा सकते हैं।

यदि आप ई तक पहुंचते हैं तो आप जीत जाते हैं । यदि आप E पर पानी की अंतिम इकाई का उपभोग करते हैं तो भी आप जीत जाते हैं।

यदि, आपकी बारी के बाद, आपके पास शून्य पानी है और आप ई पर नहीं हैं, तो आप मर जाते हैं

इनपुट और आउटपुट

आपके कार्यक्रम को STDINउपरोक्त प्रारूप में ASCII कला के रूप में मनमाने आकार का एक प्रारंभिक मानचित्र प्राप्त होगा । आप मान सकते हैं कि यह आयताकार है अर्थात सभी रेखाएँ समान लंबाई की हैं, ठीक एक Sऔर एक Eवर्ग है, सभी रेखाएँ समाप्त हो गई हैं \n, और पूरा STDIN इस रेगेक्स के अनुरूप होगा:/^[SE1-9\.\n]+$/

आपका कार्यक्रम STDOUT को निम्नलिखित आउटपुट लिखेगा:

  1. चाल की सूची,
  2. नक्शे की अंतिम स्थिति।

आप किसी भी सुविधाजनक प्रारूप में चालों की सूची को आउटपुट कर सकते हैं।

नक्शे की अंतिम स्थिति इनपुट के रूप में उसी प्रारूप में मुद्रित की जाएगी, सिवाय इसके कि यह आपके द्वारा देखे गए मार्ग को अतिरिक्त रूप से उस मार्ग को दिखाएगा, जिसके साथ सभी विज़िट की गई टाइलों को चिह्नित करके #, यदि उस टाइल में पानी नहीं है और वह S या E नहीं है (यानी यह .) है।

उदाहरण इनपुट:

.....S.
.......
.......
E......
....8..

उदाहरण जीतने के उत्पादन:

D+0
D+0
D+0
D+0
L+5
L+0
L+0
L+0
L+0
U+0
.....S.
.....#.
.....#.
E....#.
####3#.

Nontriviality

जब आप अपना कोड पोस्ट करते हैं, तो एक नमूना मानचित्र इनपुट पोस्ट करें जो आपका कोड एक समाधान ढूंढता है जिसके लिए निम्नलिखित गैर-तुच्छ परिस्थितियों को संतुष्ट करता है:

  • S और E कम से कम 10 चालों के हैं।
  • कोई भी वर्ग जिसमें शुरू में पानी की एन इकाइयाँ होती हैं, को एक एन-चौड़ाई सीमा से घिरा होना चाहिए जिसमें सभी वर्ग हैं .(कोई पानी नहीं, या पूरी तरह से नहीं)

उदाहरण

........2.
..........
..........
S.1..2....
..........
..........
........1.
..3.......
.........E

यदि आप किसी टाइल पर पानी की मात्रा बढ़ाते हैं, तो उपरोक्त तुच्छ हो जाता है।

आवश्यकताएँ

संभवत: आपका कार्यक्रम समाधान खोजने से पहले कई असफल प्रयासों का सामना करेगा, यदि कोई हो।

  1. आपके कार्यक्रम को अंततः किसी भी हल करने योग्य इनपुट को हल करना होगा।
  2. मैं आपको मरते हुए देखना चाहता हूं - आपका कार्यक्रम मार्ग की चालों और अंतिम नक्शे को एक- एक करके हर समाधान का असफल प्रयास करने के लिए तैयार करेगा।
  3. यदि आप एक विजेता समाधान का सामना करते हैं, तो उसके लिए पूर्ण आउटपुट प्रिंट करें और समाप्त करें।
  4. समाधान मिलने तक दौड़ें, लेकिन दो बार एक ही समाधान का प्रयास न करें - सभी मौतें अलग-अलग मार्गों से होनी चाहिए।
  5. यह एक परीक्षण इनपुट का उपयोग करें:

(यह कुछ midpoint पर एक पानी कैश ड्रॉप करने के लिए कम से कम एक कदम की आवश्यकता है)।

 S........
 .........
 .........
 ........E

सबसे छोटा कोड जो एक गैर-तुच्छ प्रदर्शन इनपुट के साथ पोस्ट किया जाता है जिसे वह जीतता है।


यह निर्दिष्ट करने के लिए स्पष्ट किया जाना चाहिए कि क्या प्रोग्राम को किसी भी हल करने योग्य मानचित्र को हल करने में सक्षम होना चाहिए, या क्या उसे केवल एक मानचित्र पर काम करना है। मैं निश्चित रूप से पूर्व को प्रोत्साहित करता हूँ; एक नक्शे के मामले में, इसकी गणना करने की तुलना में समाधान को हार्डकोड करना आसान होगा।

स्पष्टता के लिए संपादित। हां, यदि आपके पास शून्य से अधिक पानी है, तो आप जीत सकते हैं और हां आपके कार्यक्रम को सभी हल करने योग्य इनपुट को हल करना होगा।
spraff

एक ए * जैसे एल्गोरिथ्म का उपयोग करने के लिए आपको रोकना क्या है और प्रत्येक टाइल पर 5 इकाइयों का एक रास्ता छोड़ना जो आप क्रमिक रूप से जाते हैं और यदि आप बिना पानी के टाइल पर कदम रखते हैं तो शुरुआत में वापस जाएं?
ब्लू

कुछ भी तो नहीं। आगे बढ़ें।
स्पैर्फ

'कैरी ऑल वॉटर एस' की रणनीति से काम करना चाहिए, हालांकि यह बहुत थकाऊ होगा। एस।,।,।,।, ई। ई .... ई पर विचार करें जहां, और ई वास्तव में डॉट्स हैं। अल्पविराम वह होता है जहाँ आप अपने रास्ते को रोक कर रखते हैं, और 'e' वह जगह है जहाँ आपको पहले पानी के लिए 1 पानी को स्थानांतरित करने के लिए E. 4 चरणों के लिए 5 पानी की आवश्यकता होती है (E + 0 E-1 W +) 0 डब्ल्यू + 4)। 1 पानी को दूसरे अल्पविराम में स्थानांतरित करने के लिए 16 कदम। ई को 1 पानी छोड़ने के लिए 52 से तीसरे, 160 से चौथे, 484 और एस। 1926 चरणों में वापस पाने के लिए और आप ई पर ले रहे हैं 5 पानी, 5 और ई, 1931 चरणों तक चलाने के लिए। पथ के प्रत्येक दो चरण प्रभावी रूप से आपकी समाधान लंबाई को त्रिगुणित करते हैं।
स्पर्स

जवाबों:


12

पर्ल, 299 + 1 = 300 254 + 1 = 255 बाइट्स

यह लगभग निश्चित रूप से गोल्फ भाषाओं में से एक द्वारा पीटा जाएगा जब लोग मेरे एल्गोरिथ्म को देखेंगे :-)

-n(1 बाइट पेनल्टी) के साथ चलाएं ।

पिछले संस्करण ने कल्पना के साथ काफी अनुपालन नहीं किया, क्योंकि इसने मानचित्र पर अतिरिक्त पानी छोड़ दिया और इसे मानचित्र के अंतिम संस्करण में नहीं दिखाया; उस स्थिति से निपटने के लिए एल्गोरिथ्म को बदलते समय, मैं इसे प्रक्रिया में थोड़ा छोटा करने में कामयाब रहा।

push@a,[split//];($s,$t)=(length$`,$.)if/S/;($e,$f)=(length$`,$.)if/E/}{$_.=$s<$e?($s++,R):$s>$e?($s--,L):$t<$f?($t++,D):($t--,U);$\=reverse$";$".=y/LRUD/RLDU/r.Y.reverse.($"=~y/Y/X/r);$a[$t-1][$s]=~y/./#/;$\.=$s-$e||$t-$f?redo:$_;print map{join'',@$_}@a

उदाहरण (मैंने स्क्रॉल करने और संरचना दिखाने की आवश्यकता से बचने के लिए आउटपुट में लाइन-ब्रेक जोड़ा है):

इ.....
# .....
# .....
# .....
##### एस
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUXDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUUXDDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUXDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUUUDDDRRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUXDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUUDDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLUYDRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLLYRRRR
 LXR LLXRR LXR LLLXRRR LXR LLXRR LXR LLLLYRRR
 LXR LLXRR LXR LLLYRRR LXR केवल LYR LLLLRUUU

कार्यक्रम के द्वारा प्रयोग किया अंकन में, आंदोलन के माध्यम से प्रस्तुत किया जाता है L, R, U, और Dछोड़ दिया करने के लिए, ऊपर, सही क्रमश: नीचे। डिफ़ॉल्ट रूप से, आप प्रत्येक चाल के बाद 1 यूनिट पानी उठाते हैं, लेकिन इसे एक पात्र जोड़कर संशोधित किया जा सकता है:

  • X: 1 को चुनने के बजाय 2 यूनिट पानी छोड़ें
  • Y: 1 यूनिट पानी की बजाए 1 बूंद को गिराएं
  • (अर्थात स्थान): पानी पर पूरी तरह से फिर से भरना (केवल एक चाल के बाद उत्पादन S; कार्यक्रम भी एक प्रमुख स्थान के साथ आउटपुट है, जो समझ में आता है क्योंकि आप पानी पर पूर्ण शुरू करते हैं)

जैसा कि आप देख सकते हैं, बिना किसी अतिरिक्त पूल का उपयोग किए इस (बल्कि बंजर) नक्शे को पार करना संभव है। वास्तव में, इन नियमों के तहत कोई भी दूरी प्राप्त करना संभव है , बिना किसी पूर्वनिर्मित पानी की मदद के किसी भी नक्शे पर । इस प्रकार, यह एल्गोरिथ्म किसी भी पूर्वनिर्मित पानी को नजरअंदाज करता है, जिसका अर्थ है कि मुझे इसे संभालने की कोशिश में बाइट्स को बर्बाद नहीं करना है। इसका मतलब यह भी है कि आप बॉट को मरते हुए नहीं देख रहे हैं, क्षमा करें। यह उस सीमा से आगे कभी नहीं बढ़ता है जिसमें यह जानता है कि यह जीवित रहने की गारंटी है।

इसका कारण यह है कि हम दोनों को Xऔर Y(यह सुनिश्चित करने के लिए कि हमें Xरणनीति के अधिकांश समय Yमें कभी-कभी अतिरिक्त कोड दोनों की आवश्यकता है ) यह है कि उत्पादन के लिए मानचित्र के अंतिम संस्करण के लिए कल्पना की आवश्यकता होती है। इसे लागू करने का सबसे आसान तरीका है कि नक्शे को पूरी तरह से अछूता छोड़ दें (शुरुआत में खाली वर्गों के माध्यम से हमारे रास्ते के अलावा), विशेष रूप से एक वर्ग के रूप में जो 9पानी के साथ शुरू हुआ 10(एएससीआईआई कला को तोड़ने के साथ ) समाप्त हो जाएगा अगर यह रास्ते में हो। और हम केवल इस्तेमाल कियाX, और इस प्रकार हमें कुछ समाधान खोजने की आवश्यकता है जो नक्शे पर अतिरिक्त पानी छोड़ने से बचते हैं। यहाँ एल्गोरिथ्म मार्ग पर प्रत्येक वर्ग पर पानी की 1 अतिरिक्त इकाई को "स्वाभाविक रूप से" गिरा देगा; जैसे कि, हम प्रत्येक चौक पर जाते हैं, हम X के बजाय Y के उपयोग के माध्यम से 1 से गिराए गए पानी की मात्रा को कम कर देते हैं, ताकि हमारी अंतिम यात्रा के दौरान, हम वर्ग को उसके मूल मात्रा में पानी के बजाय वापस छोड़ दें जब हमने शुरुआत की थी तब से थोड़ा गीला था।

मैं इसे एक बड़े मानचित्र पर चलाने की सलाह देता हूं, क्योंकि इसमें O (2 ^ n) प्रदर्शन होता है (हालांकि बॉट कभी भी प्यास से मरता नहीं है, यह सोचना कठिन है कि यह इस तरह की रणनीति का उपयोग करके भूख से मर जाएगा।)

पठनीय संस्करण:

# implicit with -n: read a line of input into $_
push @a, [split //]; #/ split $_ into characters, store at the end of @a
($s,$t) = (length$`,$.) if /S/; # if we see S, store its coordinates
($e,$f) = (length$`,$.) if /E/  # if we see E, store its coordinates
}{ # Due to -n, loop back to start if there are more lines.

# From here onwards, $" stores the partial solution this iteration;
#                    $\ stores the partial solution last iteration;
#                    $_ stores the path from ($s,$t) to S.
# At the start of the program, $" is a space, $\ and $_ are empty.

$_ .=  # Work out the next step on the path:
  $s < $e ? ($s++,R) # if too far left, move right, record that in $_;
: $s > $e ? ($s--,L) # if too far right, move left, record that in $_;
: $t < $f ? ($t++,D) # if too far up,    move down, record that in $_;
: ($t--,U);          # in other cases we must be too far down.
$\ = reverse $";     # Store last iteration; $" is constructed backwards.
$" .=                # Extend $" by appending
  y/LRUD/RLDU/r .    # the path from ($s, $t) back to S;
  Y .                # a literal 'Y';
  reverse .          # $/ backwards (i.e. the path from S to ($s, $t);
  ($"=~y/Y/X/r);     # a copy of $" with all 'Y' changed to 'X'.
$a[$t-1][$s] =~      # At the current path coordinate,
  y/./#/;            # replace any '.' with '#'.
$\ .=                # Start appending to $\;
  $s-$e||$t-$f?redo  # if we're not at E, abort that and jump back to {{,
: $_;                # otherwise append $_ (the path from S to E).
print map            # For each element of some array
  {join'',@$_}       # output its concatenated elements
  @a                 # specifying that array as @a.
# Implicitly: print $\ (which specifies the sort of newline print uses).

एक सर्पिल में दुनिया को भरने वाली बाढ़ निकास की तलाश करने के लिए दिशा-निर्देशों के अपने ब्लॉक से कम कोड होगी?
स्पियर

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

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