Sfida

Ti viene data una rappresentazione in arte ASCII di personaggi su un piano come input con qualsiasi metodo ragionevole. Questo conterrà solo:

• [a-z]che rappresentano personaggi mobili. Ogni lettera apparirà sul tabellone al massimo una volta.
• # che rappresentano muri immobili
• . che rappresenta lo spazio vuoto

Per esempio:

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

Ti viene anche data una stringa che rappresenta i cambiamenti di gravità. Questo conterrà solo:

• > che rappresenta un cambiamento alla gravità verso destra
• < che rappresenta un cambiamento alla gravità verso sinistra
• ^ rappresenta un cambiamento alla gravità ascendente
• v che rappresenta un cambiamento alla gravità verso il basso

Per esempio:

v>^

Il tuo programma deve simulare ogni cambiamento di gravità in sequenza fino a quando tutti i personaggi smettono di muoversi (colpiscono un muro o un altro personaggio). I personaggi che "cadono dal bordo della mappa" vengono rimossi in modo permanente e i personaggi possono "impilarsi" uno sopra l'altro.

In questo esempio, all'inizio c'è gravità verso il basso ( v), quindi c, e, g, h, i, e jcadere sul fondo della mappa. Tutti gli altri personaggi scorrono verso il basso fino a colpire un muro, lasciando la mappa in questo modo:

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

Quindi, passiamo alla gravità a destra ( >), che ci lascia con questo: nota come le apile accanto al d.

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

Infine, simuliamo la gravità verso l'alto ( ^), durante la quale la ae la bcaduta cadono dalla mappa.

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

Il tuo compito è quello di produrre i rimanenti personaggi dopo i turni gravitazionali. Possono essere dati in qualsiasi ordine. Per questo esempio, è possibile generare qualsiasi permutazione didfq .

Casi test

Per la seguente mappa:

abcde
.....
##.##

v   =  abde
v>  =  <nothing>

Per la seguente mappa:

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

Modifica: salvato 18 byte grazie a @WashingtonGuedes.

Funziona ruotando la griglia di input quattro volte per ciascun carattere direzionale, ma nella direzione in cui il carattere direzionale corrisponde al carattere del loop facciamo la cosa di gravità sinistra. pseudocodice:

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

Lo stesso algortihm della risposta di @ Neil. La griglia viene ruotata quattro volte per ogni carattere direzionale, quando nella posizione destra viene applicato lo spostamento di gravità a sinistra su ogni riga.

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

(Abbiamo davvero bisogno di così tanti 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

Provalo online!

Come funziona

Definiamo una funzione left che fa la cosa di gravità verso sinistra.

Quindi, le altre direzioni vengono implementate facendo confusione con l'array in modo che la direzione desiderata sia rivolta a sinistra, quindi lo fanno left .

L'algoritmo di leftè qui:

• Procedere come segue fino a quando non è idempotente:
• Sostituisci ".X"con "X.", dove Xrappresenta una lettera.

L'intero programma è suddiviso nelle seguenti 6 sezioni:

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

Prima sezione

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

Seconda sezione

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

Terza sezione

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)

Quarta sezione

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

Quinta sezione

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)

Sesta sezione

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

Rubino, 306 byte

Funzione anonima. Tecnica piuttosto tortuosa che probabilmente potrebbe essere ottimizzata.

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