क्षुद्रग्रह क्षेत्र को सफलतापूर्वक नेविगेट करना


36

परिचय

हर कोई जानता है कि क्षुद्रग्रह क्षेत्र को सफलतापूर्वक नेविगेट करने की संभावना लगभग 3,720 से 1. है, लेकिन आपकी चेतावनी के बावजूद, हान सोलो अभी भी अपनी किस्मत आजमाने के लिए तैयार है।

अपने कृत्रिम जीवन के लिए डरते हुए, आप जहाज की अजीब बोली में कोड को तय करते हैं ( पढ़ें: आपकी पसंदीदा कोड गोल्फ भाषा ), एक क्षुद्रग्रह परिहार कार्यक्रम जो तय करेगा कि क्षुद्रग्रह क्षेत्र ASCII भूलभुलैया में कौन सा रास्ता लेना है।

इनपुट

मिलेनियम फाल्कन में एक क्षुद्रग्रह क्षेत्र मानचित्रण कार्यक्रम है, जो इसके समान डेटा देता है:

|   #####           #########  |
| ######  #          ###   #   |
|   # #  #  #  ####   #        |
@              ##    ####       
|#   #   #       ###   ##      |
|##      ##      ####   #  #   |
|####           ##### #   ##   |

शीर्ष पंक्तियाँ फाल्कन की बची हुई हैं, नीचे की पंक्तियाँ फाल्कन के दाईं ओर हैं, और कॉलम यह दर्शाता है कि जहाज के सामने क्या है।

  • प्रत्येक #एक बाधा है।
  • प्रत्येक स्थान खाली स्थान है जिसमें जहाज उड़ सकता है।
  • इनपुट हमेशा 7 वर्ण ऊंचा होता है। यह क्षुद्रग्रह मानचित्रण चौड़ाई सीमा है।
  • इनपुट हमेशा 32 अक्षर लंबा होता है (30 ही क्षेत्र के लिए और 2 शुरू और अंत सीमा के लिए)। यह क्षुद्रग्रह मानचित्रण गहराई सीमा है। ऊर्ध्वाधर पट्टियाँ |मानचित्रण की शुरुआत और अंत को चिह्नित करती हैं।
  • @फाल्कन है। यह हमेशा मध्य पंक्ति (4 वीं पंक्ति) और इनपुट में पहला कॉलम होता है।
  • अंतिम स्तंभ पर ऊर्ध्वाधर सलाखों में छोड़ा गया स्थान वह स्थान है जहां जहाज को पहुंचना चाहिए। यह हमेशा मध्य पंक्ति (चौथी पंक्ति) और इनपुट में अंतिम कॉलम होता है।

इनपुट को मल्टी-लाइन स्ट्रिंग, स्ट्रिंग्स की एक सरणी, STDIN या फ़ंक्शन मापदंडों से लिया जा सकता है, या किसी फ़ाइल से पढ़ा जा सकता है।

संभव युद्धाभ्यास

आपको टीआईई-फाइटर्स द्वारा पीछा किया जाता है, इसलिए आपको हमेशा आगे बढ़ना चाहिए। इस प्रकार तीन तरीके हैं जिससे जहाज प्रत्येक कदम पर उड़ सकता है:

  • - आगे

  • / आगे और बाएँ मुड़ें

  • \ फॉरवर्ड करें और दाईं ओर मुड़ें

उदाहरण के लिए, ये मान्य पथ हैं:

@---

  --
 /  \ /
@    -

   -
  / \
 /   \
@     \

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

फाल्कन दुर्घटनाग्रस्त हो जाता है अगर एक कदम जहाज को उस स्थान पर ले जाता है जहां एक बाधा है। उदाहरण के लिए, इन चालों से दुर्घटनाएँ होती हैं:

@-#

@
 \
  #

  #
 /
@

ध्यान दें कि यह कोई दुर्घटना नहीं है:

@-#
  \
   -

उत्पादन

आपको उसी क्षुद्रग्रह क्षेत्र ASCII का उत्पादन करना चाहिए, जिसके अंत में एक वैध रास्ता है। फाल्कन को स्टार्ट स्पॉट के बजाय अंतिम स्थान पर मुद्रित किया जाना चाहिए।

उदाहरण के लिए, पहले दिए गए इनपुट उदाहरण के लिए एक वैध आउटपुट होगा:

|   #####           #########  |
| ######  #--------  ###   #   |
|   # #  #/ #  ####\  #        |
 ---------      ##  \ #### ----@
|#   #   #       ### \ ## /    |
|##      ##      #### \ #/ #   |
|####           ##### #-- ##   |

आपके मार्ग को केवल फाल्कन को क्रैश करने की आवश्यकता नहीं है। इसके लिए सबसे छोटा रास्ता संभव नहीं है।

आप यह मान सकते हैं कि हमेशा अंत तक कम से कम एक संभव रास्ता होगा।

आप STDOUT में, किसी फ़ाइल या किसी भी समकक्ष के रूप में लंबे समय तक क्षुद्रग्रह क्षेत्र में मुद्रित कर सकते हैं, जैसा कि वे इस पोस्ट में हैं (उदाहरण के लिए पथ के लिए निर्देशांक की सूची का आउटपुट मान्य नहीं है)।

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

  • एक सामान्य क्षुद्रग्रह क्षेत्र

    |   #####           #########  |
    | ######  #          ###   #   |
    |   # #  #  #  ####   #        |
    @              ##    ####       
    |#   #   #       ###   ##      |
    |##      ##      ####   #  #   |
    |####           ##### #   ##   |
    

    संभव उत्पादन

    |   #####           #########  |
    | ######  #--------  ###   #   |
    |   # #  #/ #  ####\  #        |
     ---------      ##  \ #### ----@
    |#   #   #       ### \ ## /    |
    |##      ##      #### \ #/ #   |
    |####           ##### #-- ##   |
    
  • अनियमित क्षुद्रग्रह क्षेत्र

    |# # # # # # # # # # # # # # # |
    | # # # # # # # # # # # # # # #|
    |# # # # # # # # # # # # # # # |
    @ # # # # # # # # # # # # # #   
    |# # # # # # # # # # # # # # # |
    | # # # # # # # # # # # # # # #|
    |# # # # # # # # # # # # # # # |
    

    संभव उत्पादन

    |# # # # # # # # # # # # # # # |
    | # # # # # # # # # # # # # # #|
    |# # # # # # # # # # # # # # # |
     -# #-# #-# #-# #-# #-# #-# #--@
    |#\#/#\#/#\#/#\#/#\#/#\#/#\#/# |
    | #-# #-# #-# #-# #-# #-# #-# #|
    |# # # # # # # # # # # # # # # |
    
  • डेथ स्टार का कोर

    |    #    #    #         #     |
    |         #    #    #          |
    |    #    #    #    #    #     |
    @    #    #    #    #    #      
    |    #    #         #    #     |
    |    #    #    #    #    #     |
    |    #         #    #    #     |
    

    संभव उत्पादन

    |    #    #    #   --    #     |
    |  ---    #    #  / #\   -     |
    | /  #\   #    # /  # \ /#\    |
     -   # \  #    #/   #  - # ----@
    |    #  \ # ----    #    #     |
    |    #   \#/   #    #    #     |
    |    #    -    #    #    #     |
    
  • मौत सितारा खाई

    |##############################|
    |##############################|
    |##############################|
    @                               
    |##############################|
    |##############################|
    |##############################|
    

    उत्पादन

    |##############################|
    |##############################|
    |##############################|
     ------------------------------@
    |##############################|
    |##############################|
    |##############################|
    
  • क्षुद्रग्रह गुहा

    |### ##########################|
    |## # ############### ## ######|
    |# ###  ######## ### ## # #####|
    @ ###### ###### ### ## ###      
    |########  ### ### ## #########|
    |########## # ### ## ##########|
    |###########              #####|
    

    संभव उत्पादन

    |###-##########################|
    |##/#\############### ##-######|
    |#/###--######## ### ##/#\#####|
     -######\###### ### ##/###-----@
    |########--### ### ##/#########|
    |##########\# ### ##/##########|
    |###########--------      #####|
    

स्कोरिंग

R2D2 दलदल में तैरने में व्यस्त है, इसलिए आपको अपने आप से फाल्कन के नियंत्रक को प्रोग्राम करना होगा, जो थकाऊ है। इसलिए सबसे छोटा कोड जीतता है


@DJMcMayhem: तकनीकी रूप से पहली पंक्ति "परिचय" है;)
एलेक्स ए।

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

@RetoKoradi मैं समझ सकता हूं कि यह सब स्पष्ट नहीं है, लेकिन मूल विचार यह है कि सभी चालें आपको एक चरित्र की चौड़ाई को दाईं ओर ले जाती हैं। पथ को निरंतर देखना पड़ता है, यही कारण है कि दाएं और बाएं मुड़ने के बाद पिछली / अगली चाल पिछले एक के ऊपर / नीचे एक पंक्ति है।
घातक

@ नापने वाले दोनों मान्य हैं, अगर मैं आपको सही ढंग से समझता हूं कि आपका उत्तर अच्छा होना चाहिए
घातक जूल

जवाबों:


11

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

f=([...s])=>(g=(i,l,c=k=" ")=>s[i]!=k&&s[i]!="@"?0:(i-130)?(s[i]=c,([..."/-\\"].some((c,j)=>!((--j&l&&j!=l)||!g(i+33*(l||j)+1,j,c)))||!(s[i]=k))):(s[i]="@",!console.log(s.join(""))))(99)

चल स्निपेट:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><textarea cols="33" rows="7" id="t"></textarea><br><button><b>Solve &gt;&gt;&gt;</b></button><hr><button id="1">Normal</button> <button id="2">Hyperregular</button> <button id="3">Death Star core</button> <button id="4">Death Star trench</button> <button id="5">Asteroid cave</button><script>f=(function($__0){var $__2,$__3,$__4,$__5;s = $__4 = $__0.split("");return (g = (function(i, l) {var c = arguments[2] !== (void 0) ? arguments[2] : k = " ";return s[i] != k && s[i] != "@" ? 0 : (i - 130) ? (s[i] = c, ("/-\\".split("").some((function(c, j) {return !((--j & l && j != l) || !g(i + 33 * (l || j) + 1, j, c));})) || !(s[i] = k))) : (s[i] = "@",$("#t").val(s.join("")));}))(99);});$("button").click(function() {this.id?$("#t").val(inputs[this.id]):f($("#t").val());});inputs = [,`|   #####           #########  |\n| ######  #          ###   #   |\n|   # #  #  #  ####   #        |\n@              ##    ####       \n|#   #   #       ###   ##      |\n|##      ##      ####   #  #   |\n|####           ##### #   ##   |`,`|# # # # # # # # # # # # # # # |\n| # # # # # # # # # # # # # # #|\n|# # # # # # # # # # # # # # # |\n@ # # # # # # # # # # # # # #   \n|# # # # # # # # # # # # # # # |\n| # # # # # # # # # # # # # # #|\n|# # # # # # # # # # # # # # # |`,`|    #    #    #         #     |\n|         #    #    #          |\n|    #    #    #    #    #     |\n@    #    #    #    #    #      \n|    #    #         #    #     |\n|    #    #    #    #    #     |\n|    #         #    #    #     |`,`|##############################|\n|##############################|\n|##############################|\n@                               \n|##############################|\n|##############################|\n|##############################|`,`|### ##########################|\n|## # ############### ## ######|\n|# ###  ######## ### ## # #####|\n@ ###### ###### ### ## ###      \n|########  ### ### ## #########|\n|########## # ### ## ##########|\n|###########              #####|`];$("#t").val(inputs[1]);</script

यह फ़ंक्शन नई कड़ियों के साथ एकल स्ट्रिंग को स्वीकार करता है। फ़ंक्शन ...ऑपरेटर का उपयोग करके स्ट्रिंग को एक सरणी में विभाजित करता है और (x,y)निर्देशांक के लिए सूचकांक प्राप्त करता है (33 * y) + x

फ़ंक्शन पुनरावर्ती रूप से चलता है, प्रत्येक स्थान के लिए विभिन्न संभावित चालों का परीक्षण करता है। जब यह एक बाधा का सामना करता है, तो यह एक मिथ्या मूल्य देता है, और जब यह अंतिम लक्ष्य स्थान पर पहुंचता है, तो यह वापस आ जाता है true। (गोल्फ कोड में, यह trueद्वारा बनाया गया है !console.log(...)।)

ध्यान दें कि यह कोड राइट-टर्न चालों के लंबे रन का उपयोग नहीं करता है, लेकिन उन्हें सीधे चाल के साथ पंचर करता है। यही है, यह नीचे दूसरा विकल्प करता है, पहला नहीं:

\                       \
 \   (<= not this!)      -   (<= yes this!)
  \                       \

यह कानूनी प्रतीत होता है, चूंकि -कानूनी तौर पर बारी से पहले या बाद में आ सकते हैं, इसलिए दोनों एक साथ क्यों नहीं? यह अंत में विशेष रूप से अजीब लग रहा है, जब अंतिम चाल है, \लेकिन इस रूप में प्रदर्शित किया जाता है @:

|  --#    #    #   ------#  -  |
| /  \    #    #  / #    \ / \ |
|/   #-   #    # /  #    #-   -|
     # \  #    #/   #    #     @
|    #  - # ----    #    #     |
|    #   \#/   #    #    #     |
|    #    -    #    #    #     |

मेरा पसंदीदा गंदा गोल्फ हैक यहाँ डिफ़ॉल्ट तर्क दुरुपयोग है c=k=" "। तर्क (i,l,c=" ")कहते थे, "स्ट्रिंग का उपयोग " "के लिए cहै, तो fएक तिहाई तर्क नहीं दिया जाता है"। हालांकि, ऐसा करने से c=k=" ", हम कहते हैं कि "यदि cआपूर्ति नहीं की जाती है, तो " "वैश्विक चर में kस्टोर करें और फिर उस मूल्य cको भी स्टोर करें "। चूंकि पुनरावृत्ति केवल एक तर्क से शुरू होती है, kहमेशा पहले फ़ंक्शन कॉल पर आरंभिक होती है।

सौम्य:

// `i` - index in the string we're working on
// `l` - move character for this space (`/`, `\`, or `-`)
search = (i,l,c)=>{

  // not an open space; nip this recursive branch
  if(s[i]!=" "&&s[i]!="@") { return 0; }

  // we made it! the 130th space is (31,3)
  if(i==130) {
      s[i]="@";
      console.log(s.join(""));
      return true;
  }

  // fill in space with move character or a blank
  // (the space is only to blank out the initial `@`)
  s[i] = c || " ";

  // iterate through the 3 options and recursively explore the map
  return ['/','-','\\'].some((c,j)=>{
    --j;
    // if last move was sideways, and this is the opposite move, skip it
    if(l && j && j!=l) { return 0; }

    // recursively call search function on space pointed to by this move or the last move
    return search(i+33*(l||j)+1, j, c);
  })

  // if the `some` call is false (i.e. all options fail for this space)
  // then blank out this space and return false
  || !(s[i]=" ");

}

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

7

सी (पूरा कार्यक्रम), 249 247 235 बाइट्स

यह एक पूर्ण प्रोग्राम है जो किसी फ़ाइल से इनपुट को पढ़ता है और परिणाम को स्टडआउट करने के लिए आउटपुट करता है। फ़ाइल का नाम प्रोग्राम के पैरामीटर के रूप में दिया गया है।

char f[7][33];g(i,j,c){return(i<0|i>6|f[i][j]%32?0:j<31?c%45-2?g(i,j+1,c)||g(i+1,j+1,92)||g(i-1,j+1,47):g(i+c/30-2,j+1,c)||g(i+c/30-2,j+1,45):1)?f[i][j]=j?j-31?c:64:32:0;}main(int p,char**v){read(open(v[1],0),f,231);g(3,0,45);puts(f);}

Ungolfed:

/* the field */
char f[7][33];

/* i - row
 * j - col
 * c - movement
 */
g(i,j,c)
{
    return
            /* if we're in bounds and not on an obstacle */
            (i >= 0 & i<7 & f[i][j] % 32 == 0 ?
                    /* if we haven't reached the end */
                    j < 31 ?
                            /* are we going straight ahead? */
                            c%45-2 ?
                                    /* try to go straight */
                                    g(i,j+1,c)
                                    /* try to turn right */
                                    || g(i+1,j+1,92)
                                    /* try to turn left */
                                    || g(i-1,j+1,47)
                            /* turning */
                            :
                                    /* try to keep turning */
                                    g(i+c/30-2,j+1,c)
                                    /* try to go straight */
                                    || g(i+c/30-2,j+1,45)
                    /* done */
                    :1 /* replace this with c==45 to better represent the last move being a turn */
            /* invalid move, fail */
            :0)
            /* add the correct movement to the field */
            ? f[i][j] = j ? j - 31 ? c : 64 : 32
            /* no path, much sads :( */
            :0;
}

main(int p,char*v[])
{
    /* read input file */
    read(open(v[1],0),f,231);

    /* calculate the path */
    g(3,0,45);

    /* print it out */
    puts(f);
}

आउटपुट:

$ ./a.out test.inp
|   #####           #########  |
| ######  #          ###   #   |
|   # #  #  #  ####   #      --|
 ------------- ##----####   /  @
|#   #   #    \ /### \ ##  /   |
|##      ##    - #### \ # /#   |
|####           ##### #---##   |

$ ./a.out test2.inp
|# # # # #-# # # # # #-# # # # |
| # # # #/#\# # # # #/#\# # # #|
|# # # #/# #\# # # #/# #\# # # |
 -# # #/# # #\# # #/# # #\# #  @
|#\# #/# # # #\# #/# # # #\# #/|
| #\#/# # # # #\#/# # # # #\#/#|
|# #-# # # # # #-# # # # # #-# |

$ ./a.out test3.inp
|    #    #    #   ------#     |
|    -    #    #  / #    \     |
|   /#\   #    # /  #    #\    |
 --- # \  #    #/   #    # \   @
|    #  \ #    /    #    #  \ /|
|    #   \#   /#    #    #   - |
|    #    ---- #    #    #     |

$ ./a.out test4.inp
|##############################|
|##############################|
|##############################|
 ------------------------------@
|##############################|
|##############################|
|##############################|

$ ./a.out test5.inp
|###-##########################|
|##/#\############### ##-######|
|#/###--######## ### ##/#\#####|
 -######\###### ### ##/###-----@
|########--### ### ##/#########|
|##########\# ### ##/##########|
|###########--------      #####|

ऐसा लगता है कि आप पहले टेस्ट में अंतिम अंक से चूक गए।
रेटो कोराडी

@RetoKoradi यह एक -द्वारा पीछा किया है \, लेकिन \द्वारा कवर किया गया है @। (मेरा कार्यक्रम यही काम करता है।)
अप्सिलर्स

1
@RetoKoradi इससे पहले के पुनरावृत्तियों ने उस मामले को बेहतर तरीके से संभाला। यह +4 बाइट्स है। मैंने देखा कि अप्सिलर्स के समाधान ने भी ऐसा ही व्यवहार किया था इसलिए मैंने अंतरिक्ष को बचाने का विकल्प चुना।
कोल कैमरून

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

3

आम लिस्प, 303 बाइट्स

इस चुनौती के साथ बहुत मज़ा आया, यह पहला कोडगुल्फ कार्य है जो मैंने किया था। मूल रूप से एक सरल पुनरावर्ती कार्य है जो अंतिम स्थिति तक पहुंचने तक हर व्यवहार्य चाल की कोशिश करता है।

Golfed / Minified

(let((s(open "i"))(n nil)(f(make-string 231)))(read-sequence f s)(labels((r(p s u d)(and(< 0 p 224)(find(aref f p)" @")(setf(aref f p)(cond((= 130 p)#\@)((or(unless d(r(- p 32)#\/ t n))(unless u(r(+ p 34)#\\ n t))(r(+ p(cond(u -32)(d 34)(t 1)))#\- n n))s)((return-from r)))))))(r 99 #\- n n)(princ f)))

एक फ़ाइल से इनपुट मैं काम कर निर्देशिका में पढ़ता है । मुझे पूरा यकीन है कि अभी भी सुधार की गुंजाइश है।

सादा कोड

(defun run-test (file)
  (let ((stream (open file)) ;;should use with-open-file for autoclose..
        (no nil) ;; alias for brevity
        (field (make-string 231)))
    (read-sequence field stream)
    (labels ((doit (pos sym going-up going-down)
               (and
                 (< 0 pos 224)
                 (find (aref field pos) " @")
                 (setf (aref field pos)
                       (cond
                         ((= 130 pos) #\@)
                         ((or
                            (unless going-down (doit (- pos 32) #\/ t no))
                            (unless going-up (doit (+ pos 34) #\\ no t))
                            (doit (+ pos (cond (going-up -32)
                                               (going-down 34)
                                               (t 1)))
                                  #\- no no))
                          sym)
                         ((return-from doit)))))))
      (doit 99 #\- no no)
      (princ field)
      nil)))

नमूना उत्पादन

|   #####       --  #########  |
| ######  #    /  \  ###   # - |
|   # #  #  # /####\  #     / \|
--   -       / ##   \####  /   @
|#\ /#\  #  /    ### \ ## /    |
|##-   \ ##/     #### \ #/ #   |
|####   ---     ##### #-- ##   |

|  --#    #    #   --    #-    |
| /  \    #    #  / #\   / \   |
|/   #\   #    # /  # \ /#  \  |
-    # \  #    #/   #  - #   \ @
|    #  \ # ----    #    #    -|
|    #   \#/   #    #    #     |
|    #    -    #    #    #     |

|# #-# # # # # #-# # # # # #-# |
| #/#\# # # # #/#\# # # # #/#\#|
|#/# #\# # # #/# #\# # # #/# #\|
--# # #\# # #/# # #\# # #/# #  @
|# # # #\# #/# # # #\# #/# # # |
| # # # #\#/# # # # #\#/# # # #|
|# # # # #-# # # # # #-# # # # |

2

एक्शनस्क्रिप्ट 3, 364 बाइट्स

मैंने इसे दो कार्यों में विभाजित किया है; सरणी को सरणी में बदलने के लिए एक, और उड़ान पथ की गणना करने के लिए एक पुनरावर्ती है।

function m(f){for(var i=0;i<f.length;i++){f[i]=f[i].split("");}n(f,0,3,0);return f;}function n(f,x,y,m){var P=f[y][x],X=x+1,A=y-1,B=y,C=y+1,T=true,F=false,E='-';if (y<0||y>6||P=='#'||P=='|')return F;if (x==31){f[y][x]='@';return T;}if(m<0&&y>0){B=A;C=9;E='/';}else if(m>0&&y<6){A=9;B=C;E='\\';}if (n(f,X,B,0)||n(f,X,A,-1)||n(f,X,C,1)){f[y][x]=E;return T;return F;}

एक नमूना क्षुद्रग्रह क्षेत्र के साथ एक कार्यक्रम में Ungolfed संस्करण:

package
{
    import flash.display.Sprite;

    public class AsteroidNavigator extends Sprite
    {
        var field:Array;
        public function AsteroidNavigator()
        {
            field = [
"|   #####           #########  |",
"| ######  #          ###   #   |",
"|   # #  #  #  ####   #        |",
"@              ##    ####       ",
"|#   #   #       ###   ##      |",
"|##      ##      ####   #  #   |",
"|####           ##### #   ##   |"];
            m(field);
            printField();
        }

        function m(f){
            for(var i=0;i<f.length;i++){
                f[i]=f[i].split("");\
            }
            n(f,0,3,0);
            return f;
        }

        private function n(field,x,y,m) {
            var C = field[y][x];
            if (x > 31 || C == '#' || C == '|') {
                return false;
            }
            if (x == 31 && y == 3) {
                field[y][x] = '@';
                return true;
            }
            if (m == 0) {
                if (n(x+1, y, 0) || ((y>0) && n(x+1, y-1, -1)) || ((y<6) && n(x+1, y+1, 1))) {
                field[y][x] = '-';
                return true;
                }
            } else if ((m<0) && (y>0)) {
                if ((n(x+1, y-1, -1) || n(x+1, y-1, 0))) {
                    field[y][x] = '/';
                    return true;
                }
            } else if ((m>0) && (y<6)) {
                if ((n(x+1, y+1, 1) || n(x+1, y+1, 0))) {
                    field[y][x] = '\\';
                    return true;
                }
            }
            return false;
        }

        private function printField() {
            var sb = "";
            for each (var row:Array in field) {
                sb += row.join("") + "\n";
            }
            trace(sb);
        }
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.