Nel gioco 2048, hai una griglia e puoi spostare gli elementi in quattro direzioni. Si muovono tutti in quella direzione il più lontano possibile. Per questa sfida, ti verrà data una stringa 2D quadrata imbottita (con nuove righe o un elenco di stringhe), in questo modo:

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

o

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

Le quattro operazioni sono left, right, upe down. Il risultato di ciascuno sull'input sopra:

Sinistra:

abcde   
fghij   
kl      
mnop    
qrst    
uv      
wxy     
z       

o

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

Giusto:

   abcde
   fghij
      kl
    mnop
    qrst
      uv
     wxy
       z

o

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

Su:

abocdiel
mf ghsjv
un rp k 
zq x  t 
 w    y 


        

o

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

Giù:

        


 b    e 
af c  j 
mn gd k 
uq rhitl
zwoxpsyv

o

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

Il tuo obiettivo è ruotare quale operazione viene eseguita ogni iterazione, eseguendola sui ntempi di input . Quindi, se il tuo ordine è URDL, e l'input dice di iniziare con D( 2, 0-indicizzato), e hai bisogno di 5operazioni, esegui D-L-U-R-D, quindi stampa.

Ingresso:

• Una stringa in un formato come sopra
  • Gli spazi finali non sono richiesti (ma probabilmente sono utili)
  • Sarà almeno 2x2
  • Conterrà solo ASCII e spazi stampabili (e newline per il formato di input)
  • Teoricamente dovresti supportare qualsiasi lunghezza, ma i vincoli di memoria vanno bene
• Un numero intero non negativo n, per il numero di operazioni che verranno eseguite
• Un numero intero 0-3o 1-4, o una lettera UDLR, che descrive l'operazione con cui iniziare.
  • Quindi il tuo programma deve poter iniziare o terminare con qualsiasi operazione
  • Puoi definirli in qualsiasi ordine per scopi iniziali, ma deve essere un ordine coerente, quindi Ua volte non può seguire Re talvolta anche seguire L.
• Le operazioni devono essere eseguite in modo non banale
  • È possibile eseguire più volte le operazioni nell'ordine LDRU(sinistra, giù, destra, su), ma non DLRUoppure UDLR(perché UDè uguale a D, ed LRè uguale a fare semplicemente R).

Produzione:

• La stringa dopo aver eseguito le quattro operazioni nvolte
• Il formato di output deve essere uguale al formato di input
• Gli spazi finali non sono richiesti (ma probabilmente sono utili)

Esempio:

Questo esempio usa l'ordine URDL.

Ingresso:

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       

Output per n = 0-5: (basta stampare il risultato finale)

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      


        

La mia implementazione carina e non rigata

Gelatina , 23 byte

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

Provalo online!

Sono un po 'insoddisfatto, ma MATL aveva bisogno di un po' di competizione. : P

Usa l'ordine URDL. ingressi:

• l'array di input come un array di linee imbottite
• il numero di ripetizioni
• lo spostamento da cui iniziare (1 = U, 2 = R, 3 = D, 4 = L)

Spiegazione

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 byte

(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è l'indice iniziale nelle direzioni che sono URDL.

Python 2 , 226 224 204 193 byte

^{-1 byte grazie 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)

Provalo online!

Funzione che rimuove tutti gli spazi di ciascun elemento nell'elenco e completa con spazi a sinistra o a destra.

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

Questo per trasporre (ruotare di 90º) quando l'ingresso è 0o 1( Uo D) e applicareg

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

MATL , 24 23 byte

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

Ordine è URDL, 1-based. Quindi 1è Ù ,2 isR` ecc.

Gli input sono: numero di volte, direzione iniziale, matrice di caratteri (usando ;come separatore di riga).

Provalo online!