Tantangan

Anda diberi representasi ASCII-art karakter di pesawat sebagai input dengan metode apa pun yang masuk akal. Ini hanya akan berisi:

• [a-z]mewakili karakter yang dapat dipindahkan. Setiap huruf akan muncul di papan paling banyak satu kali.
• # mewakili dinding tak bergerak
• . mewakili ruang kosong

Sebagai contoh:

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

Anda juga diberi string yang mewakili perubahan gravitasi. Ini hanya akan berisi:

• > mewakili perubahan gravitasi ke kanan
• < mewakili perubahan gravitasi ke kiri
• ^ mewakili perubahan gravitasi ke atas
• v mewakili perubahan gravitasi ke bawah

Sebagai contoh:

v>^

Program Anda harus mensimulasikan setiap perubahan gravitasi secara berurutan sampai semua karakter berhenti bergerak (mereka menabrak dinding, atau karakter lain). Karakter yang "jatuh dari tepi peta" dihapus secara permanen, dan karakter dapat "menumpuk" di atas satu sama lain.

Dalam contoh ini, di awal ada gravitasi ke bawah ( v), jadi c, e, g, h, i, dan jjatuh dari bawah peta. Semua karakter lain meluncur ke bawah hingga menabrak dinding, meninggalkan peta seperti ini:

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

Lalu, kita beralih ke gravitasi ke kanan ( >), yang meninggalkan kita dengan ini: Perhatikan bagaimana atumpukan di sebelah d.

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

Akhirnya, kami mensimulasikan gravitasi ke atas ( ^), di mana adan bjatuhnya peta.

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

Tugas Anda adalah menampilkan karakter yang tersisa setelah perubahan gravitasi. Mereka dapat diberikan dalam urutan apa pun. Untuk contoh ini, Anda dapat menampilkan permutasi dari dfq.

Testcases

Untuk peta berikut:

abcde
.....
##.##

v   =  abde
v>  =  <nothing>

Untuk peta berikut:

######
#....#
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,``)

Sunting: Disimpan 18 byte berkat @WashingtonGuedes.

Bekerja dengan memutar kisi-kisi input empat kali untuk setiap karakter directional, tetapi pada arah di mana karakter directional cocok dengan karakter loop, kita melakukan hal gravitasi kiri. Kodesemu:

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

Algortihm yang sama dari jawaban @ Neil. Grid diputar empat kali untuk setiap karakter directional, ketika di posisi yang tepat gravitasi bergeser ke kiri diterapkan ke setiap baris.

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>

Pyth, 143 byte

(Apakah kita benar-benar membutuhkan banyak byte?)

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

Cobalah online!

Bagaimana itu bekerja

Kami mendefinisikan fungsi leftyang melakukan gravitasi kiri.

Kemudian, arah lain diimplementasikan dengan mengacaukan array sehingga arah yang diinginkan adalah ke kiri, lalu lakukan left.

Algoritma leftada di sini:

• Lakukan hal berikut hingga idempoten:
• Ganti ".X"dengan "X.", di mana Xmerupakan surat.

Seluruh program dibagi menjadi 6 bagian berikut:

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

Bagian pertama

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

Bagian kedua

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+"."

Bagian ketiga

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)

Bagian keempat

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

Bagian kelima

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)

Bagian keenam

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

Fungsi anonim. Teknik yang cukup berputar yang mungkin bisa dioptimalkan.

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