Un tablero de ajedrez chino se ve así (basado en esta pregunta , pero esta vez tiene un tamaño fijo):

            G
           . G
          G G G
         G G . G
B B B B . . Y G . Y . Y Y
 B B B . . G . . . Y Y Y
  B . B . . . . . Y . Y
   B . . . . . . . . Y
    . . . . . . . . .
   . P . . . . . O O .
  P P . . . . . . . O O
 P P P . . . R . . O O .
P P P P . . R . . O O O O
         R . R R
          R R R
           R .
            R

Cada carácter no espacial en este ejemplo se puede reemplazar por cualquier carácter ASCII que no se pueda imprimir en la entrada, mientras que los espacios nunca se cambian. Tenga en cuenta que no se garantiza que sea un acuerdo válido en el corrector chino (ya que puede no tener exactamente 7 tipos diferentes de caracteres).

Su tarea es rotarlo por un múltiplo de 60 grados.

Este es el ejemplo anterior girado 60 grados en sentido horario:

            B
           B B
          B B B
         B . B B
P P P . . . B . . G G . G
 P P P P . . . . . G G G
  P P . . . . . G Y . G
   P . . . . . . . G G
    . . . . . . . . .
   R . . . . . . . . Y
  R . R R . . . . Y Y .
 R R R . . . O . . . Y Y
R . R R . . . O . Y Y Y Y
         O O O .
          O O O
           O .
            O

La entrada es un entero no negativo y un tablero de ajedrez chino. Su programa (o función) debe rotarlo por el entero * 60 grados. Usted decide si gira en sentido horario o antihorario, siempre que sea consistente. Tanto la entrada como la salida no deben tener espacios iniciales o finales adicionales.

Este es el código de golf. El código más corto gana.

CJam, 61 59 43 40 38 36 bytes

{{_N/eeSf.*:sW%zsS-\{_' >{;(}&+}/}*}

Esta es una función anónima que espera una cadena y un número entero en la pila.

Gracias a @ jimmy23013 por jugar golf en 19 bytes.

Pruébelo en línea en el intérprete de CJam .

Idea

Podemos asignar un orden a los caracteres imprimibles de los cuadros de ajedrez al leerlos hacia el este y luego hacia el sur.

De esta manera, el tablero de ajedrez original y rotado

            G                                  B            
           . G                                B B           
          G G G                              B B B          
         G G . G                            B . B B         
B B B B . . Y G . Y . Y Y          P P P . . . B . . G G . G
 B B B . . G . . . Y Y Y            P P P P . . . . . G G G 
  B . B . . . . . Y . Y              P P . . . . . G Y . G  
   B . . . . . . . . Y                P . . . . . . . G G   
    . . . . . . . . .                  . . . . . . . . .    
   . P . . . . . O O .                R . . . . . . . . Y   
  P P . . . . . . . O O              R . R R . . . . Y Y .  
 P P P . . . R . . O O .            R R R . . . O . . . Y Y 
P P P P . . R . . O O O O          R . R R . . . O . Y Y Y Y
         R . R R                            O O O .         
          R R R                              O O O          
           R .                                O .           
            R                                  O            

volverse

G.GGGGGG.GBBBB..YG.Y.YYBBB..G...YYYB.B.....Y.YB........Y..........P.....OO.PP.......OOPPP...R..OO.PPPP..R..OOOOR.RRRRRR.R

y

BBBBBBB.BBPPP...B..GG.GPPPP.....GGGPP.....GY.GP.......GG.........R........YR.RR....YY.RRR...O...YYR.RR...O.YYYYOOO.OOOO.O

respectivamente.

Podemos encontrar la segunda secuencia en el primer tablero de ajedrez leyendo sus caracteres hacia el noreste, luego hacia el sureste.

Para lograr esto en código, comenzamos anteponiendo n - 1 espacios a la n ^º fila del tablero de ajedrez (que se muestra a la izquierda). Luego, invertimos el orden de las filas (que se muestran a la derecha).

            G                                                       R        
            . G                                                   R .        
            G G G                                               R R R        
            G G . G                                           R . R R        
    B B B B . . Y G . Y . Y Y                       P P P P . . R . . O O O O
      B B B . . G . . . Y Y Y                       P P P . . . R . . O O .  
        B . B . . . . . Y . Y                       P P . . . . . . . O O    
          B . . . . . . . . Y                       . P . . . . . O O .      
            . . . . . . . . .                       . . . . . . . . .        
            . P . . . . . O O .                   B . . . . . . . . Y        
            P P . . . . . . . O O               B . B . . . . . Y . Y        
            P P P . . . R . . O O .           B B B . . G . . . Y Y Y        
            P P P P . . R . . O O O O       B B B B . . Y G . Y . Y Y        
                      R . R R                       G G . G                  
                        R R R                       G G G                    
                          R .                       . G                      
                            R                       G                        

Finalmente, transponemos filas con columnas:

                 ​



            B    

           BB    

          BBB    

         B.BB    

    PPP...B..GG.G

    PPPP.....GGG

    PP.....GY.G

    P.......GG

    .........

   R........Y

  R.RR....YY.

 RRR...O...YY

R.RR...O.YYYY

OOO.

OOO

O.

O

El espacio en blanco está por todas partes, pero los caracteres imprimibles están en el orden correcto si los leemos hacia el este y luego hacia el sur.

Todo lo que queda por hacer es sustituir el n ^º carácter imprimible del tablero de ajedrez original, por el n ^º carácter imprimible de la última modificación.

Código

                                   e# Stack: String B, Integer A
{                               }* e# Repeat A times:
 _N/                               e#   Push a copy of B and split it at linefeeds.
    ee                             e#   Enumerate the lines of B.
      Sf.*:s                       e#   Execute S.*s for each line:
                                   e#     [4 "abc"] -> "    abc"
            W%                     e#   Reverse the order of line lines.
              z                    e#   Zip; transpose rows with columns.
               s                   e#   Flatten the arrays of strings.
                S-                 e#   Remove spaces.
                                   e#   This pushes a string L.
                  \{          }/   e#   For each character C in the unmodified B:
                    _' >           e#     Check if C is bigger than ' '.
                        {  }&      e#     If it is:
                         ;(        e#      Discard C and shift out a char from L.
                             +     e#     Append a char (C or from L) to L.
                                   e#  L is B rotated by 60 degrees. Set L := B.

Python 2, 171 bytes

def f(S,n):
 o="";E=enumerate;B=S.splitlines(1)
 for r,l in E(B):
  for c,q in E(l):z=r-8;y=6-(z+c)/2;x=-y-z;exec"x,y,z=-y,-z,-x;"*n;o+=q*(q<"!")or B[z+8][12-y+x]
 print o

Esta es quizás la única vez que he encontrado str.splitlinesútil, para todas las demás veces, .split("\n")es más corto.

Utilizar como f(S,10).

Explicación

Para cada carácter en la entrada, nosotros:

• Guárdelo si es un espacio o una nueva línea, o
• Reemplácelo con el carbón correcto de lo contrario

Para averiguar con qué carácter reemplazar, convertimos la cuadrícula a coordenadas de cubo (x, y, z) , rotamos los ntiempos mediante la transformación (x, y, z) -> (-y, -z, -x), y luego volvemos a convertir.