Cualquier hexágono regular puede ser embaldosado con diamantes, por ejemplo así (robado de esta pregunta ):

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

Consideraremos lo anterior como un mosaico de tamaño 1 (ya que los lados de los diamantes están hechos de uno / o \ cada uno). El mismo mosaico del tamaño 2 se vería así:

      ____________
     /   /   /\   \
    /___/___/  \___\
   /   /\   \  /\   \
  /___/  \___\/  \___\
 /\   \  /   /\  /   /\
/  \___\/___/  \/___/  \
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/
  \   \  /   /\   \  /
   \___\/___/  \___\/
    \   \   \  /   /
     \___\___\/___/

Su tarea es rotar las inclinaciones de diamantes en un múltiplo de 60 grados. El mosaico de diamantes en la entrada puede ser de cualquier tamaño (y el tamaño no se especifica explícitamente en la entrada). Pero siempre sería un mosaico válido, y todos los lados del hexágono tendrían la misma longitud.

Estos son los ejemplos anteriores rotados 60 grados en sentido horario:

   ______
  /_/\_\_\
 /\_\/_/\_\
/\/_/\_\/_/\
\/\_\/_/_/\/
 \/_/\_\_\/
  \_\/_/_/

      ____________
     /   /\   \   \
    /___/  \___\___\
   /\   \  /   /\   \
  /  \___\/___/  \___\
 /\  /   /\   \  /   /\
/  \/___/  \___\/___/  \
\  /\   \  /   /   /\  /
 \/  \___\/___/___/  \/
  \  /   /\   \   \  /
   \/___/  \___\___\/
    \   \  /   /   /
     \___\/___/___/

La entrada es un entero no negativo y un mosaico de diamantes. 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.

Preguntas relacionadas:

• Girar un tablero de ajedrez chino
• Rotar una lista bidimensional en 45 grados
• Escalar un mosaico de diamantes

Pyth, 81 bytes

ju.es.e.reh|@s.e.e[yYykZ)bGCa+LV,t-y+k*3Y*5J-+kY/lG2Jc2j406610 4K"_/\\_\\"dKbGQ.z

Pruébalo en línea

Gira en sentido antihorario.

Cada rotación de 60 ° se realiza utilizando el siguiente algoritmo. Suponga que la entrada es un hexágono de orden k , por lo que tiene 2⋅ k + 1 filas y 4⋅ k columnas. Para encontrar el carácter girado en la fila i columna j , deje

• u = i + j - k
• v = j - 3⋅ i + 5⋅ k

Entonces el carácter de salida es

• \, si la entrada tiene /en la fila ( u + 1) / 2 columna ( v + 1) / 2; más
• /, si la entrada tiene _en la fila u / 2 columna v / 2 o en la fila u / 2 columna ( v + 2) / 2; más
• _, si la entrada tiene una \fila ( u + 2) / 2 columna v / 2 o una fila ( u + 1) / 2 columna ( v - 1) / 2; más
• espacio.

(No contamos caracteres en índices de medio entero).

JavaScript (ES6), 452 356 315 bytes

Donde \nrepresenta el carácter literal de nueva línea. Editar: ahorré 96 bytes al darme cuenta de que mi algoritmo no necesita saber la cantidad y el tamaño de los diamantes por separado, además de algunos campos de golf menores que me perdí la primera vez. Ahorré 41 bytes al reorganizar el código para que el destino sea siempre el mismo par de caracteres, además de un pequeño golf que me perdí al convertir a mi algoritmo anterior.

r=
(s,n)=>(z=s.search`_`,l=(f,n=z*2+1)=>[...Array(n)].map(f),a=s.split`\n`,l(_=>(o=a.map(s=>[...s].fill` `),l((_,r)=>l((_,c)=>(d=z+c*2-r,a[s=z+r-c]&&(a[s][r+c]=='/'?o[r][d]=o[r][d+1]='_':0,a[s][r+c-1]=='\\'?o[r][d]='/':0),a[--s]&&(a[s][r+c]==`_`||a[s][r+c-1]==`_`?o[r][d+1]=`\\`:0)))),a=o.map(a=>a.join``)),n),a.join`\n`)
;

<pre id=i1>
   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/
</pre>
<input type=button value="Rotate!" onclick="i1.textContent = r(i1.textContent, 1)">
<pre id=i2>
      ____________
     /   /   /\   \
    /___/___/  \___\
   /   /\   \  /\   \
  /___/  \___\/  \___\
 /\   \  /   /\  /   /\
/  \___\/___/  \/___/  \
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/
  \   \  /   /\   \  /
   \___\/___/  \___\/
    \   \   \  /   /
     \___\___\/___/
</pre>
<input type=button value="Rotate!" onclick="i2.textContent = r(i2.textContent, 1)">

Explicación: Considera cada par de caracteres de salida, lo que podría ser __, /_, _\, /o \, la comprobación de los caracteres apropiados en la entrada que se asignan a los caracteres de salida. Sin golf:

function rotate(str, num) {
  // Measure the size using the indent of the _ in the first row.
  var size = str.indexOf('_');
  var arr = str.split('\n');
  while (num--) {
    // We build a character array to represent the output by turning the
    // input into a nested array and replacing everything with spaces.
    // Note that the output will have any trailing spaces from the input.
    var res = arr.map(s => Array.from(s).fill(' '));
    // Loop over a diamond that encloses the hexagon.
    for (var destrow = 0; destrow <= size * 2; destrow++) {
      for (var col = 0; col <= size * 2; col++) {
        var destcol = size + col * 2 - destrow;
        var srcrow = size + destrow - col;
        var srccol = destrow + col;
        // Map / to __, \ to / and __ to \.
        // We write __ first in case it gets overwritten by / or \.
        if (arr[srcrow]) {
          if (arr[srcrow][srccol] == '/') {
            res[destrow][destcol] = res[destrow][destcol + 1] = '_';
          }
          if (arr[srcrow][srccol - 1] == '\\') {
            res[destrow][destcol] = '/';
          }
        }
        // Need to check both positions in case one was overwritten.
        if (arr[srcrow - 1] &&
            (arr[srcrow - 1][srccol] == '_' || arr[srcrow - 1][srccol - 1] == '_')) {
          res[destrow][destcol + 1] = '\\';
        }
      }
    }
    arr = res.map(a => a.join(''));
  }
  return arr.join('\n');
}