Wprowadzenie

Z Wikipedii :

Tesselacji z płaskiej powierzchni jest Dachówka płaszczyźnie przy użyciu jednej lub większej ilości geometrycznych kształtów zwane płytki, bez pokrywania się z i bez przerw.

Dość znaną teselację pokazano poniżej:

Romb są kafelkami w sposób, który nie nakłada się ani nie pokrywa, i symuluje zamienianie się kolumn kostek.

Zadanie

Twoim zadaniem jest napisanie programu, który będzie sprzedawał romby w ten sam sposób, jak na powyższym obrazku. Danymi wejściowymi dla programu będą wymiary teselacji: height x widthgdzie szerokość to ilość kolumn, a wysokość to ilość wierszy.

Pojedynczy sześcian 1 x 1(3 płytki rombu) jest reprezentowany dokładnie tak:

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

Jeśli więc dane wejściowe / wymiary są 3 x 2, powinny to być dane wyjściowe:

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

Jak widać, istnieją 3 rzędy (wysokość) i 2 kolumny (szerokość). Kolumny zmieniają się w górę i w dół. Twój program też powinien to zrobić i zacząć wyżej. Na przykład 3 x 3byłoby:

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

Zasady

• Wynik musi być wyprowadzony, dane wejściowe mogą być pobierane w dowolny sposób, ale muszą odpowiadać wysokości i szerokości
• Końcowe znaki nowej linii są dozwolone
• Kolumny teselacji zawsze zaczynają się od góry, a następnie naprzemiennie w górę i w dół
• Strony teselacji muszą być współużytkowane, a teselacje muszą być poprawnie umieszczone między innymi kolumnami bez przerw
• Twoje zgłoszenie może być funkcją lub pełnym programem
• Twój program musi wydrukować dokładnie powyższe dane wyjściowe przy tych samych danych wejściowych; innymi słowy, dane wyjściowe muszą mieć ten sam format dla kostek / teselacji

Założenia

• Możesz założyć, że dane wejściowe będą zawsze większe niż 1 x 1, więc nie potrzebujesz przypadków, w których wprowadzane jest zero

Punktacja

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach. Standardowe luki są zabronione, jak również.

JavaScript (ES6), 243 bajty

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>

Bezpośrednio oblicza wszystkie pożądane znaki. Dla/ :

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

Dla \:

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

Dla _:

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 ​​bajtów

&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!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Wypróbuj online!

To pytanie wydawało się zwodniczo łatwe, ale przypadki na krawędzi okazały się bardziej skomplikowane, niż początkowo się spodziewałem. Najlepszym rozwiązaniem, jakie mogłem wymyślić, było potraktowanie nieparzystych i parzystych kolumn jako osobnych renderingów, a następnie połączenie wyników.

Tak więc dla każdej współrzędnej x, y, która musi być wyprowadzona, najpierw musimy określić, który znak powinien być renderowany dla nieparzystej kolumny, odwzorowując współrzędne wyjściowe x , y na współrzędne u , v na schemacie kostki w następujący sposób:

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

Dodatkiem (y==0)jest obsługa specjalnego przypadku pierwszej linii. Ale musimy również upewnić się, że nie renderujemy ostatnich kilku wierszy u dołu kolumny i ostatnich kilku znaków na końcu każdego wiersza. Osiąga się to przez pomnożenie znaku wyjściowego przez wyrażenie:

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

The !(columns%2)W szerokości obliczeń, ponieważ ilość musimy odciąć końcówkę zależy od tego, czy łączna liczba kolumn jest parzyste, czy nieparzyste.

Następnie wykonujemy drugie obliczenie, aby określić, który znak powinien być renderowany dla parzystej kolumny, mapując współrzędne u , v w następujący sposób:

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

Jest to takie samo podstawowe obliczenie, jak w przypadku nieparzystych kolumn, ale nieznacznie przesunięte. I tak jak poprzednio, musimy upewnić się, że nie renderujemy niektórych znaków na granicach - tym razem pierwszych kilku wierszy u góry kolumny, a także niektórych znaków na początku i na końcu każdego wiersza. Wyrażenie, które mnożymy w tym przypadku to:

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

Po obliczeniu tych dwóch potencjalnych znaków wyjściowych użyto końcowej wartości:

char1 + (char2 * !char1) + 32

Innymi słowy, jeśli char1 wynosi zero musimy wyjściowego char2 , inaczej wyjściowy char1 . Jeśli oba są niezerowe, po prostu wyprowadzimy char1 , ale to dobrze, bo i tak będą miały tę samą wartość. Zauważ też, że te wartości znaków są przesunięte o 32 (stąd dodanie 32), więc zero zawsze kończy się spacją.

Partia, 590 bajtów

@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%

:cPodprogram trzy parametry; %3to różnica między 1 a 2 kolumnami, %2to różnica między 2 a 3 kolumnami, %1to dodatkowy prefiks dla pierwszej kolumny, więc jedna kolumna to %1%2dwie kolumny to %1%2%3trzy kolumny to %1%2%3%2cztery kolumny to %1%2%3%2%3itd.

Python 2 , 329 326 319 bajtów

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)

Wypróbuj online!

Właściwie 21 24 31 bajtów krótszych niż mój poprzedni niepoprawny post. Tworzy listy dla nieparzystych i parzystych kolumn, a następnie łączy je dla każdej kolumny na szerokości.