Thử thách

Bạn được cung cấp một biểu diễn nghệ thuật ASCII của các ký tự trên một mặt phẳng làm đầu vào theo bất kỳ phương thức hợp lý nào. Điều này sẽ chỉ chứa:

• [a-z]đại diện cho các nhân vật di chuyển. Mỗi chữ cái sẽ xuất hiện trên bảng nhiều nhất một lần.
• # đại diện cho những bức tường bất động
• . đại diện cho không gian trống

Ví dụ:

abcdef.gh#..
.......ij.#.
#..#.......#
...#.#...###
.#.......#q#
.........###

Bạn cũng được cung cấp một chuỗi đại diện cho những thay đổi trong trọng lực. Điều này sẽ chỉ chứa:

• > đại diện cho một sự thay đổi đối với trọng lực phải
• < đại diện cho một sự thay đổi đối với trọng lực bên trái
• ^ đại diện cho một sự thay đổi để trọng lực đi lên
• v đại diện cho một sự thay đổi để trọng lực đi xuống

Ví dụ:

v>^

Chương trình của bạn phải mô phỏng từng thay đổi về trọng lực cho đến khi tất cả các nhân vật ngừng di chuyển (họ va vào tường hoặc nhân vật khác). Các ký tự "rơi ra khỏi rìa bản đồ" sẽ bị xóa vĩnh viễn và các ký tự có thể "xếp chồng" lên nhau.

Trong ví dụ này, khi bắt đầu có lực hấp dẫn giảm ( v), vì vậy c, e, g, h, i, và jrơi ra khỏi đáy của bản đồ. Tất cả các nhân vật khác trượt xuống dưới cho đến khi va vào tường, rời khỏi bản đồ như thế này:

.........#..
a..d......#.
#..#.f.....#
.b.#.#...###
.#.......#q#
.........###

Sau đó, chúng ta chuyển sang trọng lực phải ( >), điều này cho chúng ta điều này: Lưu ý cách các angăn xếp bên cạnh d.

.........#..
........ad#.
#..#......f#
..b#.#...###
.#.......#q#
.........###

Cuối cùng, chúng tôi mô phỏng trọng lực hướng lên ( ^), trong đó avà brơi ra khỏi bản đồ.

.........#..
.........d#.
#..#......f#
...#.#...###
.#.......#q#
.........###

Nhiệm vụ của bạn là xuất các ký tự còn lại sau khi dịch chuyển trọng lực. Họ có thể được đưa ra theo thứ tự bất kỳ. Trong ví dụ này, bạn có thể xuất bất kỳ hoán vị nào dfq.

Tủ thử

Đối với bản đồ sau:

abcde
.....
##.##

v   =  abde
v>  =  <nothing>

Đối với bản đồ sau:

######
#....#
abcdef
#.gh..
######

>   = <nothing>
<   = gh
^>  = bcde
v<  = bghef

JavaScript (ES6), 251 233 byte

(m,d,r=`replace`)=>[...d].map(c=>[...`<^>v`].map(d=>m=[...(m=(c==d?m[r](/[.\w]+/g,s=>s[r](/\./g,``)+s[r](/\w/g,``))[r](/^\w+/gm,s=>s[r](/./g,`.`)):m).split`
`)[0]].map((_,i)=>m.map(s=>s[i]).join``).reverse().join`
`))&&m[r](/\W/g,``)

Chỉnh sửa: Đã lưu 18 byte nhờ @WashingtonGuedes.

Hoạt động bằng cách xoay lưới đầu vào bốn lần cho mỗi ký tự định hướng, nhưng theo hướng mà ký tự định hướng khớp với ký tự vòng lặp, chúng tôi thực hiện điều trọng lực bên trái. Mã giả:

function slideleft(map) {
    map = map.replace(/[.\w+]/g, match=>movedotstoend(match));
    map = map.replace(/^\w+/gm, match=>changetodots(match));
}
function rotate(map) {
    return joinrows(reverse([for each (column of rows(map)[0])
            joinrow([for each (row of rows(map)) row[column]])
           ]));
}
function gravity(map, directions) {
    for each (direction of directions) {
        for each (angle of '<^>v') {
            if (direction == angle) map = slideleft(map);
            map = rotate(map);
        }
    }
    return letters(map);
}

JavaScript (ES6), 199

Cùng một câu trả lời của câu trả lời của @ Neil. Lưới được xoay bốn lần cho mỗi ký tự định hướng, khi ở vị trí bên phải, sự dịch chuyển trọng lực sang trái được áp dụng cho mỗi hàng.

x=>y=>(x=>{for(d of y){R='';for(e of'^>v<')x=[...x[0]].map((c,i)=>e!=d?x.map(r=>r[i]).join``:x.map(r=>(c=r[i])<'.'?(q+=p+c,p=''):c>'.'&&q?(q+=c,R+=c):p+='.',q=p='')&&q+p).reverse();}})(x.split`
`)||R

F=x=>y=>(x=>{for(d of y){R='';for(e of'^>v<')x=[...x[0]].map((c,i)=>e!=d?x.map(r=>r[i]).join``:x.map(r=>(c=r[i])<'.'?(q+=p+c,p=''):c>'.'&&q?(q+=c,R+=c):p+='.',q=p='')&&q+p).reverse();}})(x.split`
`)||R

// Less golfed

U=(x,y)=>
{
  x = x.split`\n`;
  for(d of y)
  {
    R = '';
    for(e of '^>v<')
      x = [...x[0]].map( 
        (c,i) => e != d
        ? x.map( r => r[i] ).join`` // basic rotation
        : x.map( // rotation with gravity shift
          r=> (c=r[i])<'.' ? (q+=p+c,p='') : c>'.'&&q?(q+=c,R+=c) : p+='.', q=p=''
        ) && q+p
      ).reverse();
  }
  return R
}

console.log=x=>O.textContent+=x+'\n'

;[
  ['abcdef.gh#..\n.......ij.#.\n#..#.......#\n...#.#...###\n.#.......#q#\n.........###',
   [['v>^','dfq']]
  ],
  ['abcde\n.....\n##.##',[['v','abde'],['v>','']]],
  ['######\n#....#\nabcdef\n#.gh..\n######',[['>',''],['<','gh'],['^>','bcde'],['v<','befgh']]]
].forEach(t => {
  var i=t[0]
  console.log(i)
  t[1].forEach(([d,k])=>{
    var r=F(i)(d),ok=[...r].sort().join``==k
    console.log((ok?'OK ':'KO ')+d+' : '+r+(ok?'':' (expected '+k+')'))
  })
  console.log('')
})

<pre id=O></pre>

Bình thường, 143 byte

(Chúng ta có thực sự cần nhiều byte không?)

JhQKeQMe.u:N+"\."H+H"."G;DybVkI}NG=gkN;D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;VJVNI}HGpH

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Chúng tôi xác định một chức năng leftmà điều trọng lực bên trái.

Sau đó, các hướng khác được thực hiện bằng cách làm rối với mảng sao cho hướng mong muốn được chuyển sang trái, sau đó thực hiện left.

Thuật toán của leftđây là:

• Làm như sau cho đến khi idempotent:
• Thay thế ".X"bằng "X.", nơi Xđại diện cho một chữ cái.

Toàn bộ chương trình được chia thành 6 phần sau:

JhQKeQ
Me.u:N+"\."H+H"."G;
DybVkI}NG=gkN;
D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;
VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;
VJVNI}HGpH

Phần đầu tiên

JhQKeQ     Q auto-initialized to evaluate(input())
JhQ        J = Q[0]
   KeQ     K = Q[len(Q)-1]

Phần thứ hai

Me.u:N+"\."H+H"."G;   @memoized
M                 ;   def g(G,H):
  .u             G      repeat_until_idempotent(start:G, as N):
    :Nxxxxxxyyyyy         return N.replace(xxxxxx,yyyyy)
      +"\."H                               "\."+H
            +H"."                                 H+"."

Phần thứ ba

DybVkI}NG=gkN;    @memoized
Dyb          ;    def y(b):
   Vk               for N in k:     --TAKES GLOBAL VARIABLE k
     I}NG             if N in G:    --G pre-initialized to "abcde...z"
         =gkN           k = g(k,N)

Phần thứ tư

D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;  @memoized
D'b                                ;  def single_quote(b):
   VlJ                       )          for N in range(len(J)): --TAKES GLOBAL VARIABLE J
      =k@JN                               k = J[N] --SETS GLOBAL VARIABLE k
           yk                             y(k) --returns nothing, but MODIFIES GLOBAL VARIABLE k
             Vk                           for H in k:
               I}HG      )                  if H in G:
                   =:kH\.                     k = k.replace(H,".")
                          .?                else:
                            B                 break
                              =XJNk     J[N] = k --MODIFIES GLOBAL VARIABLE J

Phần thứ năm

VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;
VK                                                       ; for N in K:
  IqN\<  )                                                   if N == '<':
       'J                                                      single-quote(J)
          IqN\v          )                                   if N == 'v':
               =C_J                                            J = transpose(reverse(J))
                   'J                                          single-quote(J)
                     =_CJ                                      J = reverse(transpose(J))
                          IqN\>            )                 if N == '>':
                               =C_CJ                           J = transpose(reverse(transpose(J)))
                                    'J                         single-quote(J)
                                      =C_CJ                    J = transpose(reverse(transpose(J)))
                                            IqN\^            if N == '^':
                                                 =CJ           J = transpose(J)
                                                    'J         single-quote(J)
                                                      =CJ      J = transpose(J)

Phần thứ sáu

VJVNI}HGpH
VJ           for N in J:
  VN           for H in N:
    I}HG         if H in G: --G = "abc...z"
        pH         print(H)

Ruby, 306 byte

Chức năng ẩn danh. Kỹ thuật khá mạch có thể được tối ưu hóa.

->s,d{w=[];x=y=0;m={}
s.chars.map{|c|c>?!?(c<?A?c<?.?w<<[x,y]:0:m[c]=[x,y]
x+=1):(x=0;y+=1)}
d.chars.map{|c|q=[c<?=?-1:c<?A?1:0,c>?a?1:c>?A?-1:0];e=1
(n=m.clone.each{|k,v|z=[v[0]+q[0],v[1]+q[1]]
w.index(z)||m.value?(z)?0:m[k]=z}
m.reject!{|k,v|i,j=v;i<0||i>=x||j<0||j>y}
e=(m!=n ?1:p))while e}
m.keys.join}