Meydan okuma

Herhangi bir makul yöntemle girdi olarak size bir düzlemdeki karakterlerin ASCII-art gösterimi verilir. Bu sadece şunları içerir:

• [a-z]hareketli karakterleri temsil eder. Her harf tahtada en fazla bir kez görünecektir.
• # taşınmaz duvarları temsil eden
• . boş alanı temsil eden

Örneğin:

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

Ayrıca, yerçekimi değişikliklerini temsil eden bir dize verilir. Bu sadece şunları içerir:

• > sağa doğru çekimde bir değişikliği temsil eder
• < sola doğru çekimde bir değişikliği temsil eder
• ^ yukarı doğru yerçekimi değişikliğini temsil eden
• v aşağı doğru yerçekimi değişikliğini temsil eden

Örneğin:

v>^

Programınız, yerçekimindeki her değişikliği, tüm karakterler hareket etmeyi durdurana kadar (bir duvara veya başka bir karaktere çarpana kadar) simüle etmelidir. "Haritanın kenarından düşen" karakterler kalıcı olarak kaldırılır ve karakterler üst üste "istiflenebilir".

Bu örnekte, başında (aşağı doğru yerçekimi yoktur v), bu yüzden c, e, g, h, i, ve jharitanın altını düşer. Diğer tüm karakterler bir duvara çarpana kadar aşağı kayar ve haritayı şu şekilde bırakır:

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

Sonra, sağ taraftaki yerçekimine ( >) ilerliyoruz , bu da bizi bununla bırakıyor: aYığınların yanındaki nasıl olduğuna dikkat edin d.

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

Son olarak, yukarı doğru yerçekimi (taklit ^), sırasında ave bharita düşer.

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

Göreviniz, yerçekimi kaydırmalarından sonra kalan karakterleri çıktılamaktır. Herhangi bir sırayla verilebilirler. Bu örnek için, herhangi bir permütasyon çıktısı verebilirsiniz dfq.

testcases

Aşağıdaki harita için:

abcde
.....
##.##

v   =  abde
v>  =  <nothing>

Aşağıdaki harita için:

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

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

JavaScript (ES6), 251 233 bayt

(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,``)

Düzenleme: @WashingtonGuedes sayesinde 18 bayt kaydedildi.

Her bir yönlü karakter için giriş ızgarasını dört kez döndürerek çalışır, ancak yönlü karakterin döngü karakteriyle eşleştiği yönde sol yerçekimi işlemini yaparız. pseudocode:

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

@ Neil'in cevabı ile aynı algoritma. Izgara, her yönlü karakter için dört kez döndürülür, sağ konumda her satıra sola yerçekimi kayması uygulanır.

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 bayt

(Bu kadar bayt gerçekten ihtiyacımız var mı?)

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

Çevrimiçi deneyin!

Nasıl çalışır

leftSola doğru yerçekimi şeyi yapan bir fonksiyon tanımlarız .

Ardından, istenen yönler sola doğru olacak şekilde dizi ile karıştırılarak uygulanır left.

Algoritması leftburada:

• İdempotent olana kadar aşağıdakileri yapın:
• Değiştir ".X"ile "X."nerede, Xbir mektup temsil eder.

Tüm program aşağıdaki 6 bölüme ayrılmıştır:

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

Birinci kısım

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

İkinci bölüm

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

Üçüncü bölüm

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)

Dördüncü bölüm

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

Beşinci bölü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)

Altıncı bölüm

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

Yakut, 306 bayt

Anonim işlev. Muhtemelen optimize edilebilen oldukça dolaşım tekniği.

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