Einführung

Aus Wikipedia :

Eine Tessellation einer flachen Oberfläche ist das Kacheln einer Ebene unter Verwendung einer oder mehrerer geometrischer Formen, genannt Kacheln, ohne Überlappungen und ohne Lücken.

Eine ziemlich bekannte Tessellation ist unten abgebildet:

Die Rhomben sind so gekachelt, dass keine Überlappungen oder Lücken entstehen, und sie simulieren das Vertauschen von Würfelsäulen.

Aufgabe

Ihre Aufgabe ist es, ein Programm zu schreiben, das Rhomben auf die gleiche Weise wie im obigen Bild tesselliert. Die Eingabe für das Programm sind die Abmessungen der Tessellation: height x widthwobei width die Anzahl der Spalten und height die Anzahl der Zeilen ist.

Ein einzelner Würfel 1 x 1(3 Rhombusplättchen) wird genau so dargestellt:

    _____
  /\      \
 /  \      \
/    \ _____\ 
\    /      /
 \  /      /  
  \/_____ /   

Also, wenn die Eingabe / Dimensionen sind 3 x 2, sollte dies die Ausgabe sein:

    _____
  /\      \
 /  \      \
/    \ _____\ _____
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
          \    /      /
           \  /      /
            \/_____ /

Wie Sie sehen, gibt es 3 Zeilen (Höhe) und 2 Spalten (Breite). Die Spalten vertauschen sich nach oben und unten. Ihr Programm sollte dies auch tun und höher starten. Zum Beispiel 3 x 3wäre:

    _____               _____
  /\      \           /\      \
 /  \      \         /  \      \
/    \ _____\ _____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
          \    /      /
           \  /      /
            \/_____ /

Regeln

• Das Ergebnis muss ausgegeben werden, die Eingabe kann nach Belieben erfolgen, muss jedoch Höhe und Breite entsprechen
• Nachgestellte Zeilenumbrüche sind zulässig
• Die Tessellationsspalten beginnen immer von oben und wechseln sich ab
• Tessellationsseiten müssen gemeinsam genutzt werden und Tessellationen müssen zwischen den anderen Spalten ohne Lücken korrekt platziert werden
• Ihre Einreichung kann eine Funktion oder ein vollständiges Programm sein
• Ihr Programm muss bei gleicher Eingabe genau die oben angegebene Ausgabe ausgeben. Mit anderen Worten, die Ausgabe muss für Cubes / Tessellations dasselbe Format haben

Annahmen

• Sie können davon ausgehen, dass die Eingabe immer größer als ist 1 x 1, sodass Sie keine Fälle benötigen, in denen eine Null eingegeben wird

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes. Standardlücken sind ebenfalls verboten.

JavaScript (ES6), 243 Byte

f=
(h,w)=>[...Array(h*6+4)].map((_,i)=>[...Array(w*9+3)].map((_,j)=>i&&(i+j+3)%6==0&&j%9<(i>3?6:3)&&(i>3|j<w*9)&&(j>2|i<h*6)?'/':i&&(i-j+2)%6==0&&j%9<(i>h*6?j<w*9?3:0:6)?'\\':i%3==0&&j>2&&(i*3+j+14)%18%(!i|i>h*6?18:12)<4?'_':' ').join``).join`
`

<div oninput=o.textContent=+h.value&&+w.value?f(h.value,w.value):''><input id=h type=number min=1><input id=w type=number min=1><pre id=o>

Berechnet direkt alle gewünschten Zeichen. Für /:

i&&                         Not on first row of output
(i+j+3)%6==0&&              Backward diagonals
j%9<                        Not on top (right) diamond of hexagons or
    (i>3?6:3)&&             empty spaces on top half row
(i>3|j<w*9)&&               Not on top right corner of output
(j>2|i<h*6)                 Not on bottom left corner of output

Für \:

i&&                         Not on first row of output
(i-j+2)%6==0&&              Forward diagonals
j%9<                        Not on bottom (right) diamond of hexagons or
    (i>h*6?                 empty spaces on bottom half row or
        j<w*9?3:0:6)        bottom right corner of output

Für _:

i%3==0&&                    Every third line
j>2&&                       Not on left two columns
(i*3+j+14)%18%              Every 18 characters
    (!i|i>h*6?18:12)<4      One or two groups

Befunge, 277 269 ​​Bytes

&6*4+00p&:55+*3+10p2%20pv@
6+5:g03%*54:::<<0+55p03:<<v%*54++55:\p04:**`+3g03g00`\g01+*3!g02\-*84g+3+!\%
48*+,1+:10g`!#^_$,1+:00g-|>30g:2+6%\3-!+3+g48*-\:2`\20g3*+10g\`*30g2`**40g!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Probieren Sie es online!

Diese Frage sah täuschend einfach aus, aber die Randfälle erwiesen sich als komplizierter als ursprünglich angenommen. Der beste Ansatz bestand darin, die geraden und ungeraden Spalten als separate Renderings zu behandeln und die Ergebnisse dann einfach zusammenzuführen.

Für jede auszugebende x, y-Koordinate müssen wir zunächst bestimmen, welches Zeichen für eine ungerade Spalte gerendert werden soll, indem wir die x , y- Ausgabekoordinaten wie folgt auf die u , v- Koordinaten im Cube-Diagramm abbilden :

u = x%20
v = (y+5)%6 + (y==0)

Die Hinzufügung von (y==0)soll den Sonderfall der ersten Zeile behandeln. Wir müssen aber auch sicherstellen, dass wir nicht die letzten Zeilen am Ende der Spalte und die letzten Zeichen am Ende jeder Zeile rendern. Dies wird erreicht, indem das Ausgabezeichen mit dem folgenden Ausdruck multipliziert wird:

(y > h-3) && (x > w-3*!(columns%2))

Der !(columns%2)Grund für die Berechnung der Breite ist, dass der Betrag, den wir zum Abschneiden des Endes benötigen, davon abhängt, ob die Gesamtspaltenanzahl gerade oder ungerade ist.

Wir führen dann eine zweite Berechnung durch, um zu bestimmen, welches Zeichen für eine gerade Spalte gerendert werden soll, und ordnen die u , v- Koordinaten folgendermaßen zu:

u = (x+10)%20
v = (y+2)%6 + (y==3)

Dies ist die gleiche Grundberechnung wie für die ungeraden Spalten, jedoch leicht versetzt. Und wie zuvor müssen wir sicherstellen, dass wir einige Zeichen an den Grenzen nicht rendern - diesmal die ersten Zeilen am oberen Rand der Spalte sowie einige Zeichen am Anfang und Ende jeder Zeile. Der Ausdruck, den wir in diesem Fall multiplizieren, lautet:

(y > 2) && (x > 2) && (x < w-3*(columns%2))

Nachdem diese beiden möglichen Ausgabezeichen berechnet wurden, wird der folgende Endwert verwendet:

char1 + (char2 * !char1) + 32

Mit anderen Worten, wenn char1 Null ist, müssen wir char2 ausgeben , andernfalls geben wir char1 aus . Wenn beide ungleich Null sind, geben wir nur char1 aus , aber das ist in Ordnung, da beide sowieso den gleichen Wert haben würden. Beachten Sie auch, dass diese Zeichenwerte um 32 versetzt sind (daher die Addition von 32), sodass Null immer als Leerzeichen endet.

Batch, 590 Bytes

@echo off
set c=call:c 
set b=\      \
set f=%b:\=/%
set s=       
set u=_____
set w=%2
%c%"   " " %u%" "%s%%s%"
%c%"  " "/%b%" "%s%    "
%c%" " "/  %b%" "%s%  "
%c%"" "/    \ %u%\" " %u% "
for /l %%i in (1,1,%1)do %c%"\" "    %f%" "%b%"&%c%" \" "  %f%" "  %b%"&%c%"  \" "/%u% /" "    \ %u%\"&if %%i lss %1 %c%"  /" "%b%" "    %f%"&%c%" /" "  %b%" "  %f%"&%c%"/" "    \ %u%\" "/%u% /"
%c%"   " "" "%s%\    %f%"
%c%"  " "" "  %s%\  %f%"
%c%" " "" "    %s%\/%u% /"
exit/b
:c
set o=%~1
for /l %%j in (%w%,-2,1)do call set o=%%o%%%~2&if %%j gtr 1 call set o=%%o%%%~3
echo(%o%

Die :cUnterroutine akzeptiert drei Parameter; %3ist der Unterschied zwischen 1 und 2 Spalten, %2ist der Unterschied zwischen 2 und 3 Spalten, %1ist das zusätzliche Präfix für die erste Spalte, also eine Spalte ist %1%2, zwei Spalten ist %1%2%3, drei Spalten ist %1%2%3%2, vier Spalten ist %1%2%3%2%3usw.

Python 2 , 329 326 319 Bytes

h,w=input()
a,R=[' '*10]*3,range
b='  /\      \  # /  \      \ #/    \ _____\#\    /      /# \  /      / #  \/_____ /  '.split('#')
c=['    _____    ']+b*h
e,o=c+a,a+c
k=len(e)
f=e[:]
o[3]=o[3][:10]
for x in R(1,w):
 for y in R(k):f[y]+=((e[y][3:],e[y])[y in R(4)],(o[y][3:],o[y])[y in R(k-3,k)])[x%2]
print'\n'.join(f)

Probieren Sie es online!

Eigentlich 21 24 31 Bytes kürzer als mein vorheriger falscher Beitrag. Erstellt Listen für die ungeraden und geraden Spalten und verknüpft sie dann für jede Spalte in der Breite.