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

नियम

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

उदाहरण

यदि यह इनपुट ग्रिड था:

  ### 

#  # #
 ###

ग्रेविटी गाइ xप्रत्येक पुनरावृत्ति के बाद इन पदों पर और शुरू होगी । ^= गुरुत्वाकर्षण को ऊपर vस्विच करें और = गुरुत्वाकर्षण को नीचे स्विच करें।

v                        ^                               v
-------------------------------------------------------------
  ###   |    ###   |    ###   |    ###   |    ###   |    ### 
x       |          |    x     |     x    |      x   |        
#  #    |  #x #    |  #  #    |  #  #    |  #  #    |  #  # x
 ### #  |   ### #  |   ### #  |   ### #  |   ### #  |   ### #

जैसा कि आप देख सकते हैं, इन समय पर गुरुत्वाकर्षण स्विच करने से ग्रेविटी गाइ अंत तक पहुंच जाती है, इसलिए यह इनपुट एक सत्य मान लौटाएगा।

विशेष विवरण

इनपुट ग्रिड किसी भी उपयुक्त "ग्रिड" प्रारूप में हो सकता है (रिक्त स्थान के साथ बहुस्तरीय स्ट्रिंग पैड, लाइन स्ट्रिंग्स की सरणी, वर्णों के सरणी का सरणी, आदि)।
यदि खिलाड़ी के लिए स्तर जीतना संभव है, तो एक truthyमूल्य का उत्पादन करें । यदि नहीं, तो एक आउटपुट दें falsey।
ग्रिड की चौड़ाई और ऊंचाई 50वर्णों पर होगी ।
यह कोड-गोल्फ है , बाइट्स जीतने में सबसे छोटा कोड हो सकता है!

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

(प्रत्येक मामले से अलग ----------, रिक्त स्थानों के साथ किसी भी खाली लाइनों को भी गद्देदार किया जाना चाहिए)

सच

 #########   ########      ######     ######    
          #  #       #    #      #   #      #   
###    #   # #    #   #  #       #  #        #  
  #    ##  # #    ##  # #     # #  #      ##    
  #    #   # #    #   # #    #     #     #######
  #       #  #       #  #     ###  #          # 
  #    ##    #    ##     #       #  #         # 
  #    #          #              #        #   # 
  #    ####################################   # 
  #                                           # 
  ############################################# 

----------


###

----------

   #####

####    

----------

 #####
 # # #

# # # 
 #####

----------

   ############   

######      ######

   ############   

----------

  ###   ###  
     # #     
####  #  ####
    #   #    
     # #     
      #      

----------

    ######  
   #        
 ##         
     #######
###     #   
   #    #   
    #####   


----------

    #####   
   #    #   
 ##     #   
     #######
###         
   #        
    ######  

----------

  ### 

#  # #
 ###  

----------

  ###  ###

###     ##
   #    # 
    ##### 

----------

  #        
     #   # 
       #   
#   #     #
        #  
   #       
      #    
 #         

----------

    ##### ####   
   #     #    #  
  #   # #  ##  # 
             #  #
#####  ####   #  
               # 
     #########   

----------

 ########################### 
 #   #   #   #     #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ###########################

असत्य

 ###
   #
####

----------


### ###

----------

    #   
 ### ###

#### ###
    #   

----------

  ###     ###  
     # # #     
####  # #  ####
    #     #    
     #   #     
      # #      
       #       

----------

  ####### 
  #     # 
 ## ##### 

### ######
  #     # 
  ####### 

----------

 ########################### 
 #   #   #   #  #  #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ###########################

code-golf ascii-art decision-problem

— user81655
स्रोत

क्या हमें स्तंभ को स्तंभ स्वरूप में अनुमति दी गई है?

— नील

@ नील आप एक ट्रांसपोज़्ड / घुमाए गए सरणी का मतलब है? मैं नहीं कह रहा हूँ, क्योंकि यह इनपुट बदल रहा है। लेकिन अगर आपकी भाषा में एक विशेष columnप्रकार है, तो मुझे लगता है कि उपयोग करना ठीक होगा।

— user81655

क्या #पहले कॉलम में पहली पंक्ति में होना संभव है ?

— फेर्सुम

@ Faersum नहीं, आप मान सकते हैं कि ग्रिड में ग्रेविटी गाइ के लिए "स्टैंड" में जगह शामिल होगी।

— user81655

शर्म की बात है; ट्रांसपोज़िशन मेरे बाइट की गिनती को 20% तक बढ़ा देता है।

— नील

19

घोंघे , 15 बाइट्स

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

^
\ n\ ,=\#r}+~

०। ^एक विकल्प है जिसके लिए बाईं ओर शीर्ष पर शुरू करने के लिए पैटर्न की आवश्यकता होती है।

\ : मैच स्पेस
n: किसी भी दिशा में 90 डिग्री मुड़ें
\ ,: मैच स्पेस जीरो या अधिक बार
=\#जाँच करें कि #हमारे सामने एक है
r: दिशा को दाईं ओर सेट करें
}+: पूर्ववर्ती एक या अधिक बार सभी करें
~ एक सेल से मेल खाता है जो ग्रिड सीमा से बाहर है

— feersum
स्रोत

यह ट्रू टेस्ट के अधिकांश मामलों के लिए 0 देता है

— बैसड्रॉन्ग कंबरवुबबवब

@ क्या आपने रिक्त स्थानों को रिक्त स्थान पर रखा है?

— मार्टिन एंडर

@ मार्टिनबटनर ने सीधे कुछ इनपुट्स की नकल की, ऐसा करने से वास्तव में कुछ रिक्त स्थान हटा दिए गए। रिक्त स्थान जोड़ने के बाद यह वास्तव में काम करता है

— बैसड्रॉप कंबरवुबवब

5

चूंकि किसी ने अभी तक यह नहीं कहा है: यह बहुत बढ़िया है!

— DLosc

9

पर्ल, 93 89 81 77 76 75 74 बाइट्स

के लिए +2 शामिल है -0p

एसटीडीआईएन पर इनपुट पैटर्न के साथ चलाएं (सभी लाइनों के साथ समान लंबाई में पैडेड):

gravity.pl < gravity.txt

gravity.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w

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

perl -0pe '/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w' < gravity.txt

स्पष्टीकरण:

यह एक स्ट्रिंग का निर्माण करेगा जिसमें wप्रत्येक स्थिति में गुरुत्वाकर्षण व्यक्ति पहुंच सकता है। तो दूसरे से अंतिम सत्य उदाहरण के लिए इसका निर्माण होगा:

     #########   
    ##### ####   
   #wwwww#wwww#  
  #w  # #w ##ww# 
wwwww wwwwwww#ww#
#####  ####  w#ww
     wwwwwwwwww# 
     #########

तो गुरुत्वाकर्षण आदमी इसे बना सकता है अगर और केवल अगर wअंतिम कॉलम में है। wप्रत्येक दौर में एक पहुंच स्थान की जगह से स्ट्रिंग का निर्माण किया जाएगा ।

प्रत्येक प्रतिस्थापन फॉर्म का होगा

s/prefix \K space postfix/ w | $& /e

जो मांग करेगा कि अंतरिक्ष उपसर्ग से पहले है और उसके बाद उपसर्ग है लेकिन wउन्नत समूह की आवश्यकता के बिना केवल स्थान को बदलें ।

मान लें $nकि एक regex है जो सिर्फ इतनी प्रगति करेगा कि बाएं और दाएं पक्ष एक दूसरे के बिल्कुल नीचे हैं। फिर प्रासंगिक संदर्भ हैं:

/^( $n)*\K $n#/       From the first position drop down as long as you
                      encounter spaces until you encounter a #. 
                      This puts gravity guy on his starting platform

/#$n\K( $n)*\b /      A space immediately below a # and if you (optionally)
                      go down further from there (as as the descent is
                      over spaces) you get to a space that follows a word
                      boundary. The only way to get a word boundary is if 
                      there is a w in front of that space. This selects the
                      position gravity guy ends up on if starting from that
                      w and gravity is up
/w([w ]$n)*\K $n#/    A w followed by a space (or w) and if you go down from
                      there as long as it is over spaces (or w) you finally
                      end up on a space directly above a #. This handles the
                      gravity down case. The test uses "space or w" instead
                      of just space to handle this case:

                       #
                      ww
                      #x  
                       #

                      Position x is currently a space and must be replaced by a
                      w but the gravity up regex has already put a w directly
                      after the w gravity guy takes off from. So for gravity
                      down we must handle w as if it is still a space. This
                      is not needed for gravity up because regex always matches
                      starting at the earliest possible character, so 
                      gravity up matches before gravity down

इस तरह से कार्यक्रम आसान है:

#!/usr/bin/perl -0p   Slurp all of STDIN into $_, at the end print $_

/\n/                  Match the first newline (needed to measure the row
                      length)
$n=".{@-}"            $n effectively becomes rowlength-1 times ".". This
                      will be the regex that goes one step down a column

s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es

                     This is the 3 regexes shown above combined. The s 
                     modifier is needed so the . in $n also matches newline

    &&redo           Keep looping as long as w's keep getting added

$_=m;w\n;            Check if the last column contains a w: He made it!
                     The \n; at the end is not written. These 2 bytes sneakily
                     come from the -p option for the ; and the -e option
                     for the \n

— टन हास्पेल
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 174 बाइट्स

a=>[...a[0]].map((_,i)=>[...t].map(x=>s[x]<'#'&&g(s.indexOf('#',x),-1)&&g(s.lastIndexOf('#',x),1),s=a.map(s=>s[i]),t=new Set),t=new Set([0]),g=(i,d)=>i<0||t.add(i+d))&&t.size

तार का एक क्षैतिज सरणी लेता है और निकास बिंदुओं की संख्या लौटाता है। सरणी को स्थानांतरित करने से मुझे 29 बाइट का खर्च आता है। Ungolfed:

function gravity(array) {
    var set = new Set;
    set.add(0); // starting point
    for (var i = 0; i < array[0].length; i++) {
        var s = array.map(s => s[i]); // transpose array
        var old = set;
        set = new Set;
        for (var x of old) {
            if (s[x] == '#') continue; // hit wall
            var j = s.indexOf('#', x); // try downward gravity
            if (j >= 0) set.add(j - 1);
            j = s.lastIndexOf('#', x); // try upward gravity
            if (j >= 0) set.add(j + 1);
        }
    }
    return set.size;
}

— नील
स्रोत

3

पिप , 85 68 62 59 + 1 = 60 बाइट्स

स्टड की -rसभी पंक्तियों को पढ़ने के लिए ध्वज का उपयोग करता है ।

FcZg{YlFxiIc@xQsyPB(Jc@<x@?`# *$`)+1PB(c@>x@?'#)+x-1i:UQy}i

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

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

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

पूरी व्याख्या

में निर्मित इस कार्यक्रम में इस्तेमाल किया चर: i == 0, l == [], s == " "।

-rझंडा इनपुट की तर्ज में की एक सूची रखता है g। FcZg{...}ज़िप gऔर प्रत्येक स्तंभ पर छोरों c। (अनुपयोगी Z, जब इसे पुनरावृत्तियों की सूची में लागू किया जाता है, तो पायथन की तरह कार्य करता है zip(*g), बड़े करीने से 2 डी सरणी का आदान-प्रदान करता है ।) ध्यान दें कि cएक सूची होगी, न कि एक स्ट्रिंग।

कॉलम लूप के अंदर, हम एंकिंग yद्वारा खाली सूची पर रीसेट करते हैं । खत्म हो जाता है । बाद के पुनरावृत्तियों में, उस y-निर्देशांक की एक सूची होगी जो खिलाड़ी पिछले कॉलम में पहुंचने में सक्षम था। पहली बार के माध्यम से, हम सिर्फ (ऊपरी बाएं कोने) से शुरू करना चाहते हैं । वैरिएबल को स्कैलर के लिए प्रीइंस्टीच्यूट किया जाता है , लिस्ट में नहीं , लेकिन पिप इस पर ठीक तरह से ठीक करता है।YlFxiii00[0]

अंतिम स्तंभ में प्रत्येक मान्य स्थिति के लिए, यह Ic@xQsजाँच करता है कि वर्तमान स्तंभ में उस स्थिति में कोई स्थान है या नहीं। यदि नहीं, तो खिलाड़ी बस एक दीवार में भाग गया और हम अगली संभावना का प्रयास करने के लिए आगे बढ़ते हैं। यदि ऐसा है, तो हम उन स्थानों को ढूंढना चाहते हैं जो खिलाड़ी गुरुत्वाकर्षण की प्रत्येक दिशा के लिए इस कॉलम में गिरेंगे, और ush ack ऑपरेटर yका उपयोग करके उन्हें सूची में जोड़ देंगे ।PB

गुरुत्वाकर्षण ऊपर जा रहा है (बाएं, ट्रांसपोज़्ड संस्करण में):

(Jc@<x@?`# *$`)+1
  c@<x             Slice everything left of x in the column
 J                 Join into a string so we can do a regex search on it
      @?`# *$`     Find index of the last # in this string
(             )+1  The player's index is the space below/to the right of this #

गुरुत्वाकर्षण नीचे जा रहा है (दाएं, ट्रांसपोज़्ड संस्करण में):

(c@>x@?'#)+x-1
 c@>x              Slice everything right of x in the column
     @?'#          Find index of the first # in this list (no need to join into string)
(        )+x       Translate to index number in entire column
            -1     The player's index is the space above/to the left of this #

यदि खिलाड़ी किसी विशेष दिशा में ग्रिड से गिरता है, तो संबंधित @?ऑपरेशन को एक नहीं मिलेगा #और शून्य देगा। यह एक वैध सूचकांक नहीं है और अगले पुनरावृत्ति में कुछ चेतावनी उत्पन्न करेगा - जो, हालांकि, -wध्वज के बिना दिखाई नहीं देते हैं । हमारे उद्देश्यों के लिए, इन मामलों को अनिवार्य रूप से विचार से समाप्त कर दिया गया है।

इनर लूप के बाद, हमारे द्वारा बनाए गए पदों i:UQyकी सूची लेता है y, डुप्लिकेट को समाप्त करता है, और इसे असाइन करता है i। (डुप्लिकेट को समाप्त करना आवश्यक है क्योंकि अन्यथा सूची तेजी से गुब्बारे।) हम फिर अगले कॉलम पर जाते हैं। जब हमने सभी स्तंभों के माध्यम से लूप किया है, अगर एक वैध रास्ता था, तो iपदों की एक गैर-रिक्त सूची होगी (सत्य); यदि नहीं, तो यह एक खाली सूची (गलत) होगी।

— DLosc
स्रोत

क्या गुरुत्वाकर्षण पुरुष इसे बना सकता है?