Qualsiasi esagono regolare può essere piastrellato con diamanti, ad esempio in questo modo (rubato da questa domanda ):

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

Considereremo quanto sopra una piastrellatura di dimensione 1 (poiché i lati dei diamanti sono fatti di uno / o \ ciascuno). La stessa piastrellatura della dimensione 2 sarebbe simile a:

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

Il tuo compito è ruotare i diametri del diamante di un multiplo di 60 gradi. La piastrellatura del diamante nell'input può essere di qualsiasi dimensione (e la dimensione non è esplicitamente specificata nell'input). Ma sarebbe sempre una piastrellatura valida e tutti i lati dell'esagono avrebbero la stessa lunghezza.

Questi sono gli esempi sopra riportati ruotati di 60 gradi in senso orario:

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

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

L'input è un numero intero non negativo e una piastrellatura a diamante. Il tuo programma (o funzione) dovrebbe ruotarlo di un intero * 60 gradi. Decidi se ruotare in senso orario o antiorario, purché sia ​​coerente. Sia l'input che l'output non dovrebbero avere spazi iniziali o finali aggiuntivi.

Questo è code-golf. Il codice più corto vince.

Domande correlate:

• Ruota una scacchiera cinese
• Ruota un elenco bidimensionale di 45 gradi
• Scala una piastrellatura diamantata

Pyth, 81 byte

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

Provalo online

Ruota in senso antiorario.

Ogni rotazione di 60 ° viene eseguita utilizzando il seguente algoritmo. Supponiamo che l'input sia un esagono dell'ordine k , quindi ha 2⋅ k + 1 righe e 4⋅ k colonne. Per trovare il carattere ruotato nella riga i colonna j , let

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

Quindi il carattere di output è

• \, se l'input ha /alla riga ( u + 1) / 2 colonna ( v + 1) / 2; altro
• /, se l'ingresso ha _alla riga u / 2 colonna v / 2 o alla riga u / 2 colonna ( v + 2) / 2; altro
• _, se l'ingresso ha \alla riga ( u + 2) / 2 colonna v / 2 o alla riga ( u + 1) / 2 colonna ( v - 1) / 2; altro
• spazio.

(Non contiamo i caratteri in indici di mezzo intero.)

JavaScript (ES6), 452 356 315 byte

Dove \nrappresenta il carattere letterale di newline. Modifica: ho salvato 96 byte rendendomi conto che il mio algoritmo non ha bisogno di conoscere il numero e la dimensione dei diamanti separatamente, oltre ad alcuni golf minori che mi sono perso la prima volta. Ho salvato 41 byte riorganizzando il codice in modo che la destinazione fosse sempre la stessa coppia di caratteri, oltre a un golf minore che mi mancava durante la conversione al mio algoritmo precedente.

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)">

Spiegazione: ritiene ciascuna coppia di caratteri di uscita, che potrebbe essere __, /_, _\, /o \, controllando per i caratteri appropriati nell'input che mappano ai caratteri di output. Ungolfed:

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');
}