No jogo 2048, você tem uma grade e pode mover os elementos em quatro direções. Todos eles se movem nessa direção, na medida do possível. Para esse desafio, você receberá uma string 2D acolchoada e quadrada (com novas linhas ou uma lista de strings), assim:

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       

ou

['ab cd e ', ' f ghij ', '      kl', 'mno p   ', ' q r st ', 'u      v', ' w x  y ', 'z       ']

As quatro operações são left, right, up, e down. O resultado de cada um na entrada acima:

Esquerda:

abcde   
fghij   
kl      
mnop    
qrst    
uv      
wxy     
z       

ou

['abcde   ', 'fghij   ', 'kl      ', 'mnop    ', 'qrst    ', 'uv      ', 'wxy     ', 'z       ']

Certo:

   abcde
   fghij
      kl
    mnop
    qrst
      uv
     wxy
       z

ou

['   abcde', '   fghij', '      kl', '    mnop', '    qrst', '      uv', '     wxy', '       z']

Acima:

abocdiel
mf ghsjv
un rp k 
zq x  t 
 w    y 


        

ou

['abocdiel', 'mf ghsjv', 'un rp k ', 'zq x  t ', ' w    y ', '        ', '        ', '        ']

Baixa:

        


 b    e 
af c  j 
mn gd k 
uq rhitl
zwoxpsyv

ou

['        ', '        ', '        ', ' b    e ', 'af c  j ', 'mn gd k ', 'uq rhitl', 'zwoxpsyv']

Seu objetivo é rotacionar qual operação é executada a cada iteração, realizando-a nos ntempos de entrada . Portanto, se o seu pedido for URDLe a entrada indicar para começar com D( 2, indexado a 0) e você precisar de 5operações, execute D-L-U-R-De imprima.

Entrada:

• Uma string em um formato como acima
  • Os espaços à direita não são necessários (mas provavelmente são úteis)
  • Será pelo menos 2x2
  • Contém apenas ASCII e espaços imprimíveis (e novas linhas de acordo com seu formato de entrada)
  • Teoricamente, você deve suportar qualquer tamanho, mas as restrições de memória são aceitáveis
• Um número inteiro não negativo n, para o número de operações que serão executadas
• Um número inteiro 0-3ou 1-4, ou uma letra UDLR, descrevendo a operação para começar.
  • Portanto, seu programa deve poder iniciar ou terminar com qualquer operação
  • Você pode defini-los em qualquer ordem para fins iniciais, mas deve ser uma ordem consistente; portanto, Uàs vezes não pode ser seguido nem às Rvezes seguido L.
• As operações devem ser executadas de maneira não trivial
  • Você pode executar operações na ordem LDRU(esquerda, baixo, direita, cima) repetidamente, mas não DLRUou UDLR(porque UDé o mesmo que De LRé o mesmo que fazer R).

Resultado:

• A sequência após executar os quatro ntempos de operação
• O formato de saída deve ser o mesmo que o formato de entrada
• Os espaços à direita não são necessários (mas provavelmente são úteis)

Exemplo:

Este exemplo usa o pedido URDL.

Entrada:

10  (number of times operations are applied)
0   (starts with Up)

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       

Saídas para n = 0-5: (apenas imprima o resultado final)

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       
---------------
abocdiel
mf ghsjv
un rp k 
zq x  t 
 w    y 



---------------
abocdiel
 mfghsjv
   unrpk
    zqxt
      wy



---------------



      el
    dijv
   chspk
 bognrxt
amfuzqwy
---------------



el      
dijv    
chspk   
bognrxt 
amfuzqwy
---------------
eljvkxty
disprqw 
chgnz   
bofu    
am      


        

Minha implementação bonita e não destruída

Gelatina , 23 bytes

UZ
Ç¡=⁶$Þ€Ç$⁴¡ZU$⁵+⁴¤¡Y

Experimente online!

Estou um pouco insatisfeito, mas o MATL precisava de alguma competição. : P

Usa o pedido URDL. Entradas:

• a matriz de entrada como uma matriz de linhas preenchidas
• o número de repetições
• a mudança para começar (1 = U, 2 = R, 3 = D, 4 = L)

Explicação

UZ       Helper link. Argument: A (the 2D array)
U        Reverse each line and...
 Z       ...transpose. Rotates 90° CCW.

Ç¡=⁶$Þ€Ç$⁴¡ZU$⁵+⁴¤¡Y    Main link. Arguments: A, n (2D array, repetitions)
Ç                       Rotate 90° CCW...
 ¡                      ...m times. (m = which move to start on)

     Þ                  Sort...
      €                 ...each line of the array...
  =⁶                    ...based on the characters' equality to " ".
       Ç                Rotate 90° CCW.
        $               Combine the sort and rotate to one action.
         ⁴¡             Do that n times. (n = repetition count)

           Z            Transpose and...
            U           ...reverse each line. Rotates 90° CW.
             $          Combine the transpose and reverse to one action.
                  ¡     Do that...
              ⁵+⁴¤      ...m + n times.

                   Y    Join the array by newlines.

JavaScript (ES6), 168 bytes

(n,d,s,t=s.replace([RegExp(`( )([^]{${l=s.search`
`}})(\\w)`),/(.)(\b)( )/,RegExp(`(\\w)([^]{${l}})( )`),/( )(\b)(.)/][d%4],`$3$2$1`))=>n?t!=s?f(n,d,t):f(n-1,d+1,s):s

Ungolfed:

function gravity(count, direction, string) {
    let width = string.indexOf('\n');
    let up = new RegExp('( )([^]{' + width + '})(\\w)');
    let down = new RegExp('(\\w)([^]{' + width + '})( )');
    while (count--) {
        let regexp = [up, /(.)(\b)( )/, down, /( )(\b)(.)/][direction++ % 4];
        while (regexp.test(string)) string = string.replace(regexp, '$3$2$1');
    }
    return string;
}

dé o índice inicial nas direções que são URDL.

Python 2 , 226 224 204 193 bytes

^{-1 byte graças a Trelzevir}

x,s,n=input()
j=''.join
g=lambda x,i:[eval("j(_.split(' ')).%sjust(len(_))"%'lr'[i%2])for _ in x]
for i in([0,3,1,2]*n)[s:s+n]:x=[map(j,zip(*g(map(j,zip(*x)),i))),g(x,i)][i>1];print'\n'.join(x)

Experimente online!

Função que remove todos os espaços de cada elemento da lista e completa com espaços à esquerda ou à direita.

g=lambda x,i:[eval("''.join(_.split(' ')).%sjust(len(_))"%'lr'[i%2])for _ in x]

Isso para transpor (girar 90º) quando a entrada é 0ou 1( Uou D) e aplicarg

x=[map(''.join,zip(*g(map(''.join,zip(*x)),i))),g(x,i)][i>1]

MATL , 24 23 bytes

:+"@X!XJ_JXzJ32>S(c@_X!

Ordem é URDL, 1baseados. Então 1é ,2 isR` etc.

As entradas são: número de vezes, direção inicial, matriz de caracteres (usando ;como separador de linhas).

Experimente online!