Yerçekimi Guy sadece kullanıcı girişi yerçekimi yönünü çeviren tek bir anahtar olduğu bir oyundur. Bir ASCII sanat seviyesi göz önüne alındığında, Gravity Guy'ın sonuna ulaşmasının mümkün olup olmadığını belirleyin.

kurallar

• İlk yerçekimi yönü aşağı .
• Girdinin İlk sütun, her zaman yalnızca içerecektir tane # yerçekimi adam, başlar üstünde.
• Her yineleme, doğrudan sağındaki karaktere geçer .
• Onun varsa yolu tıkalı ve o giriyor #, oyuncu kaybeder .
• Hareket ettikten sonra, oyuncu isteğe bağlı olarak yerçekimini aşağıdan yukarıya veya yukarıdan aşağıya doğru değiştirebilir.
• Yerçekimi Guy o zaman bir sonrakine düşüyor# (geçerli ağırlık yönünde).
• Orada hayır ise #üzerine düşmesine ve o ızgara düşer , oyuncu kaybeder .
• Gravity Guy , giriş kılavuzunun sağından hareket ederse , oyuncu kazanır .

Örnek

Bu giriş ızgarasıysa:

  ### 

#  # #
 ###  

Yerçekimi Guy xher yinelemeden sonra başlar ve bu pozisyonlarda olmak. ^= yerçekimini yukarı kaydır ve v= yerçekimini aşağı indir.

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

Gördüğünüz gibi, yerçekimi bu zamanlarda değiştirerek Gravity Guy sona ulaşır, bu nedenle bu girdi bir gerçeği döndürür.

Özellikler

• Giriş ızgarası, uygun herhangi bir "ızgara" biçiminde olabilir (boşluklarla doldurulmuş çok satırlı dize, satır dizeleri dizisi, karakter dizileri dizisi, vb.).
• Eğer durum bu ise olası bir oyuncu seviyesi, çıkış bir kazanma için truthydeğer. Değilse, bir falseydeğer verin.
• Kılavuzun genişliği ve yüksekliği 50en fazla karakter olacaktır .
• Bu kod golf , bayt cinsinden en kısa kod kazanabilir!

Test Kılıfları

(her durumda ayrılan ----------boş satırlar da boşluklarla doldurulmalıdır)

Doğru

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

----------


###

----------

   #####

####    

----------

 #####
 # # #

# # # 
 #####

----------

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

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

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

----------

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

----------

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


----------

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

----------

  ### 

#  # #
 ###  

----------

  ###  ###

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

----------

  #        
     #   # 
       #   
#   #     #
        #  
   #       
      #    
 #         

----------

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

----------

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

Yanlış

 ###
   #
####

----------


### ###

----------

    #   
 ### ###

#### ###
    #   

----------

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

----------

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

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

----------

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

Salyangoz , 15 bayt

Online dene?

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

0. ^kalıbın sol üstte başlamasını gerektiren bir seçenektir.

1. \ ​: maç alanı

2. n: Her iki yönde 90 derece döndürün

3. \ ,​: alanı sıfır veya daha çok kez eşleştir

4. =\#Bir #önümüzde olup olmadığını kontrol edin

5. r: yönü sağa ayarla

6. }+: önceki bir veya daha fazla kez hepsini yap

7. ~ ızgara sınırlarının dışında olan bir hücreyi eşleştir

Perl, 93 89 81 77 76 75 74 bayt

İçin +2 içerir -0p

STDIN'de giriş deseni ile çalıştırın (tüm satırlar aynı uzunlukta yastıklı)

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

Bu dosya tabanlı sürümün son satırına ihtiyacı var, bu yüzden gerçekten 75 bayt. Ancak komut satırı tabanlı sürüm bu fazladan yeni satıra ihtiyaç duymaz, bu nedenle 74 bayt olarak sayılır:

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

Açıklama:

Bu wyerçekimi adam ulaşabileceği her pozisyonda bir dize inşa edecek . Böylece, ikinci-son truthy örneği için inşa edecek:

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

Yani yerçekimi adam bunu yapabilir ve eğer sadece bir w son sütunda bir varsa. Dize wher bir turdaki bir ulaşılabilir alanı değiştirerek yapılacaktır .

Her değiştirme şeklinde olacak

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

ki bu alandan önce önek ve sonradan posta eki gelmesini talep eder, ancak yalnızca w çok sayıda gelişmiş gruplamaya ihtiyaç duyulmadan .

$nSol ve sağ tarafların birbirinin tam altında olmasına yetecek kadar ilerleyen bir regex içerdiğini varsayalım . Sonra ilgili regexes:

/^( $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

Bunun dışında program kolaydır:

#!/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

JavaScript (ES6), 174 bayt

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

Yatay bir dizge dizisi alır ve çıkış noktalarının sayısını döndürür. Diziyi yerleştirmek bana 29 byte eder. 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;
}

Pip , 85 68 62 59 + 1 = 60 bayt

-rTüm stdin satırlarını okumak için bayrak kullanır .

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

Çevrimiçi deneyin!

Kısa açıklama

Strateji aslında geniş bir ilk arama. Girdiyi çeviririz ve oynatıcının o sütunda ulaşabileceği y konumlarının bir listesini tutarak satırların (sütunların) üzerinden döneriz. Son sütundan sonraki çıktı, oyuncu kazanabilirse boş olmayan bir liste veya oyuncu kaybederse boş bir liste (sadece yeni bir satırsonu olarak yazdırır).

Tam açıklama

Dahili bu programda kullanılan değişkenler: i == 0, l == [],s == " " .

-rBayrak içine girdi hatları bir listesini koyar g. Her sütun üzerinde FcZg{...}fermuarlar gve döngüler c. ( ZUnary, yinelemeler listesine uygulandığında zip(*g), düzgün bir şekilde 2B diziyi dönüştüren Python gibi davranır .)c Bir dize değil, bir liste olacağını .

Sütun döngüsünün içinde yboş listeye sıfırlayarak Ysıfırlarız l. Fxiüzerinden döngüler i. Daha sonraki yinelemelerde, ioyuncunun önceki sütunda ulaşabileceği y koordinatlarının bir listesi olacaktır. İlk kez, sadece 0(sol üst köşe) ile başlamak istiyoruz . Değişken 0bir Listeye değil , bir Skaler'e önceden başlatılmıştır [0], ancak Pip bunun üzerinde bir şekilde yinelemektedir.

Son sütundaki geçerli konumların her biri için, geçerli sütunda Ic@xQsbu konumda bir boşluk olup olmadığını kontrol eder. Aksi halde, oyuncu bir duvara çarptı ve bir sonraki olasılığı denemek için yola koyulduk. Öyleyse, oyuncunun her ağırlık yönü için bu sütunda düşeceği konumları bulmak yve Pusck Back operatörünü kullanarak bunları listeye eklemek istiyoruz .

Yerçekimi yukarı çıkıyor (değiştirilmiş sürümde solda):

(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 #

Yerçekimi aşağı gidiyor (doğru, değiştirilmiş sürümde):

(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 #

Eğer oyuncu ızgaradan belirli bir yöne düşerse, ilgili @?işlem #a'yı bulamaz ve sıfır verir. Bu geçerli bir indeks değildir ve bir sonraki yinelemede bazı uyarılar üretecektir - bununla birlikte -wbayrak olmadan görünmez . Amaçlarımız için, bu davalar esasen dikkate alınmamaktadır.

İç döngüden sonra, oluşturduğumuz konumların i:UQylistesini alır, ykopyaları elimine eder ve atar i. (Kopyaları ortadan kaldırmak gerekir, çünkü aksi halde liste üssel olarak balonlaşır.) Sonra bir sonraki sütuna gideriz. Tüm sütunlara göz attığımızda, eğer geçerli bir yol varsa, iboş bir konum listesi olacaktır (gerçek); değilse, boş bir liste (falsey) olacaktır.