Gravity Guyเป็นเกมที่ผู้ใช้เพียงคนเดียวป้อนเข้าเป็นคีย์เดียวที่พลิกทิศทางของแรงโน้มถ่วง กำหนดระดับศิลปะ ASCII ให้พิจารณาว่าเป็นไปได้หรือไม่ที่ Gravity Guy จะไปถึงจุดสิ้นสุด

กฎระเบียบ

• ทิศทางเริ่มต้นของแรงโน้มถ่วงลง
• คอลัมน์แรกของอินพุตจะมีเพียงหนึ่ง คอลัมน์เท่านั้น#ซึ่ง Gravity Guy เริ่มต้นจากด้านบน
• แต่ละซ้ำเขาย้ายตัวละครโดยตรงบนเขาทางด้านขวา
• ถ้าเขาเส้นทางถูกปิดกั้นและเขาเดินเข้าไป#ผู้เล่นสูญเสีย
• หลังจากเคลื่อนที่ผู้เล่นสามารถสลับแรงโน้มถ่วงจากบนลงล่างหรือขึ้นลง
• จากนั้น Gravity Guy จะตกไปสู่สิ่งต่อไป# (ในทิศทางของแรงโน้มถ่วงในปัจจุบัน)
• ถ้าไม่มี#จะตกไปและเขาตกจากตารางผู้เล่นสูญเสีย
• ถ้าแรงโน้มถ่วง Guy ย้ายออกทางด้านขวาของตารางการป้อนข้อมูลผู้เล่นที่ชนะ

ตัวอย่าง

หากนี่คือกริดอินพุต:

  ### 

#  # #
 ###  

Guy แรงโน้มถ่วงจะเริ่มต้นที่xและเป็นที่ตำแหน่งเหล่านี้หลังจากการทำซ้ำแต่ละครั้ง ^= สลับแรงโน้มถ่วงเป็นขึ้นและv= สลับแรงโน้มถ่วงเป็นลง

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

อย่างที่คุณเห็นการสลับแรงโน้มถ่วงในเวลานี้ Gravity Guy มาถึงจุดสิ้นสุดดังนั้นข้อมูลนี้จะส่งกลับค่าความจริง

ข้อมูลจำเพาะ

• กริดอินพุตสามารถอยู่ในรูปแบบ "กริด" ที่เหมาะสม (สตริงหลายบรรทัดมีช่องว่างอาร์เรย์ของสตริงบรรทัดอาร์เรย์ของอาร์เรย์ของอักขระ ฯลฯ )
• หากเป็นไปได้สำหรับผู้เล่นที่จะชนะในระดับให้ส่งออกtruthyค่า หากไม่ใช่ให้ส่งfalseyค่าออกมา
• ความกว้างและความสูงของกริดจะเป็น50อักขระมากที่สุด
• นี่คือcode-golfซึ่งอาจเป็นรหัสที่สั้นที่สุดในหน่วยไบต์!

กรณีทดสอบ

(แต่ละกรณีคั่นด้วย----------เส้นที่ว่างควรมีการเว้นวรรคด้วย)

จริง

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

----------


###

----------

   #####

####    

----------

 #####
 # # #

# # # 
 #####

----------

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

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

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

----------

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

----------

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


----------

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

----------

  ### 

#  # #
 ###  

----------

  ###  ###

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

----------

  #        
     #   # 
       #   
#   #     #
        #  
   #       
      #    
 #         

----------

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

----------

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

เท็จ

 ###
   #
####

----------


### ###

----------

    #   
 ### ###

#### ###
    #   

----------

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

----------

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

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

----------

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

หอยทาก 15 ไบต์

ลองออนไลน์หรือไม่

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

0. ^เป็นตัวเลือกที่ต้องใช้รูปแบบเริ่มต้นที่ด้านซ้ายบน

1. \ ​: พื้นที่จับคู่

2. n: หมุน 90 องศาในทิศทางใดทิศทางหนึ่ง

3. \ ,​: จับคู่พื้นที่ศูนย์หรือมากกว่านั้น

4. =\#ตรวจสอบว่ามี#ด้านหน้าของเรา

5. r: กำหนดทิศทางไปทางขวา

6. }+: ทำทั้งหมดก่อนหน้านี้หนึ่งครั้งหรือมากกว่า

7. ~ จับคู่เซลล์ที่อยู่นอกขอบเขตของกริด

Perl, 93 89 81 77 76 75 74 ไบต์

รวมถึง +2 สำหรับ -0p

เรียกใช้ด้วยรูปแบบการป้อนข้อมูล (ด้วยการเว้นวรรคบรรทัดทั้งหมดที่มีความยาวเท่ากัน) บน STDIN:

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 ไบต์จริงๆ แต่เวอร์ชันพื้นฐานของ commandline ไม่จำเป็นต้องมีการขึ้นบรรทัดใหม่เพื่อให้นับเป็น 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 ที่จะคืบหน้ามากพอที่ด้านซ้ายและขวาอยู่ด้านล่างซึ่งกันและกัน จากนั้น 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

ด้วยวิธีการที่ทำให้โปรแกรมเป็นเรื่องง่าย:

#!/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 ไบต์

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;
}

Pip , 85 68 62 59 + 1 = 60 ไบต์

ใช้-rแฟล็กเพื่ออ่านบรรทัดทั้งหมดของ stdin

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

ลองออนไลน์!

คำอธิบายสั้น ๆ

กลยุทธ์คือการค้นหาที่กว้างเป็นอันดับแรก เราโอนย้ายอินพุตและวนรอบบรรทัด (คอลัมน์) ทำให้รายการ y- ตำแหน่งที่ผู้เล่นสามารถเข้าถึงในคอลัมน์นั้นได้ ผลลัพธ์หลังจากคอลัมน์สุดท้ายคือรายการที่ไม่ว่างเปล่าหากผู้เล่นสามารถชนะหรือรายการเปล่า (ซึ่งพิมพ์เป็นเพียงบรรทัดใหม่ต่อท้าย) หากผู้เล่นแพ้

คำอธิบายแบบเต็ม

Built-in ตัวแปรที่ใช้ในโปรแกรมนี้: i == 0, ,l == []s == " "

ธงทำให้รายการของเส้นของการป้อนข้อมูลเข้าที่-r รหัสไปรษณีย์และลูปมากกว่าแต่ละคอลัมน์ (เอกภาพเมื่อนำไปใช้กับรายการของ iterables ทำหน้าที่เหมือนงูหลามtransposing อาเรย์ 2D เรียบร้อย) โปรดทราบว่าจะเป็นรายการไม่ใช่สตริงgFcZg{...}gcZzip(*g)c

ภายในวงคอลัมน์ที่เราตั้งค่าyไปยังรายการที่ว่างเปล่าโดยankingY ลูปมากกว่า ในการทำซ้ำในภายหลังจะเป็นรายการของพิกัด y ที่ผู้เล่นสามารถเข้าถึงได้ในคอลัมน์ก่อนหน้า ครั้งแรกที่ผ่านเราต้องการเริ่มต้นด้วยเพียง(มุมบนซ้าย) ตัวแปรจะถูกกำหนดค่าเริ่มต้นเป็น Scalar ไม่ใช่ List แต่ Pip จะวนซ้ำไปเรื่อย ๆlFxiii00[0]

สำหรับแต่ละตำแหน่งที่ถูกต้องในคอลัมน์สุดท้ายIc@xQsตรวจสอบว่ามีช่องว่างในตำแหน่งนั้นในคอลัมน์ปัจจุบันหรือไม่ ถ้าไม่ผู้เล่นเพิ่งวิ่งเข้าไปในกำแพงและเราจะพยายามต่อไปเป็นไปได้ ถ้าเป็นเช่นนั้นเราต้องการค้นหาตำแหน่งที่ผู้เล่นจะตกในคอลัมน์นี้สำหรับแต่ละทิศทางของแรงโน้มถ่วงและเพิ่มลงในรายการyโดยใช้ตัวดำเนินการ ack PushB

แรงโน้มถ่วงกำลังสูงขึ้น (ซ้ายในเวอร์ชั่น transposed):

(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จะเป็นรายการตำแหน่งที่ไม่ว่างเปล่า (ความจริง); ถ้าไม่มันจะเป็นรายการที่ว่างเปล่า (falsey)