Napisz najkrótszy program, który drukuje tę sekcję graficzną ASCII sześciokątnego kafelka lub plastra miodu :

       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/

• Nie należy pobierać żadnych danych wejściowych.
• Wyjście na standardowe wyjście lub najbliższą alternatywę dla twojego języka.
• Zamiast programu możesz napisać nazwaną funkcję, która nie przyjmuje parametrów i drukuje wynik normalnie lub zwraca go jako ciąg znaków.
• Wyjście może mieć dowolną liczbę początkowych i / lub końcowych znaków nowej linii, a każda linia na wyjściu może mieć dowolną liczbę początkowych i / lub końcowych spacji (o ile wzór jest odpowiednio wyrównany).
• Najkrótszy kod w bajtach wygrywa.

CJam, 45 43 42 41 40 bajtów

741e8 36+Ab"\__/  "38*21/.{G2$-<\S*.e<N}

Wypróbuj online w interpretatorze CJam .

Jak to działa

"\__/  "38*21/

powtarza wzór \__/ 38 razy i dzieli go na kawałki o długości 21 . Gdyby fragmenty były oddzielone liniami, byłby to wynik:

\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  

To wyraźnie zawiera pożądany plaster miodu. Pozostaje tylko zamienić niektóre postacie na spacje, odciąć inne i wprowadzić linie.

741e8 36+Ab

generuje liczbę całkowitą 74 100 000 036 i konwertuje ją na tablicę [7 4 1 0 0 0 0 0 0 3 6] . Każdy element tablicy koduje liczbę wiodących znaków odpowiedniego wiersza, które należy zastąpić spacjami. Odejmując tę ​​liczbę od 16 , otrzymujemy również prawidłową długość tej linii.

.{            } e# Execute for each pair of a digit D and a line L:
  G2$-<         e#   Chop off L after 16 - D characters.
       \S*      e#   Push a string of D spaces.
          .e<   e#   Compute the vectorized minimum.
             N  e#   Push a linefeed.

Ponieważ spacja ma niższy punkt kodowy niż inne znaki L, a wektoryzowane operatory pozostawiają nietknięte znaki dłuższego łańcucha, które nie odpowiadają jednemu z krótszych, .e<zastępuje pierwsze znaki D spacjami.

Python 2, 73

i=0
exec"k=max(7-i,i-24,0);print' '*k+('\__/  '*9)[i:][k:16-k];i+=3;"*11

Zobacz, jak działa.

Dla każdego z 11 rzędów wyjściowych oblicza liczbę spacji wiodących kjako maksymalnie trzy funkcje liniowe, które tworzą obwiednię lewej strony sześciokąta. Ponieważ linie ukośne mają nachylenie 3i -3lepiej jest indeksować numer wiersza jako i=0,3,...30.

Aby utworzyć siatkę sześciokątną, najpierw kafelkujemy wystarczającą ilość jednostki '\__/ '. Następnie przesunięcie [i:]wyrównuje go o 3 dla nieparzystych wierszy. Na koniec bierzemy potrzebną jej część [k:16-k], pozostawiając margines kpo lewej i prawej stronie.

CJam, 65 56 55 bajtów

"Ý6TNð*¯5"303b4b["/\_")"_ "4*S]f=sB/z{_W%"\/"_W%erN}/

Wypróbuj online w interpretatorze CJam .

Pomysł

Prawa połowa każdej linii to odwrócona kopia lewej połowy z zamienionymi ukośnikami i odwrotnymi ukośnikami. Dlatego wystarczy zakodować lewą połowę plastra miodu:

       _
    __/ 
 __/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
   \__/ 
      \_

Zamiast analizować ten wzór linia po linii, możemy analizować go kolumna po kolumnie:

   /\/\/\  
  _ _ _ _  
  _ _ _ _  
  /\/\/\/\ 
 _ _ _ _ _ 
 _ _ _ _ _ 
 /\/\/\/\/\
_ _ _ _ _ _

Pojawiają się oczywiste wzory:

• Ciąg _ _ _ _występuje pięć razy.
• Po każdym /następuje \.

Zastępując każdy /\, _, _ _ _ _i przestrzeń liczbę od 0 do 3, można konwersję powstałego tablicę z szeregu podstawy 4 do wyższej podstawy i przechowywania pełny wzór w sposób zwarty sposób.

Kod

"Ý6TNð*¯5"303b4b  e# Convert the string from base 303 to base 4.
["/\_")"_ "4*S]f= e# Replace each resulting digit by the corresponding item of the array
                  e# ["/\" "_" "_ _ _ _ " " "].
sB/               e# Split into strings of length 11.
z                 e# Zip: transpose rows with columns.
{             }/  e# For each string:
 _W%              e#     Push a reversed copy.
    "\/"_W%er     e#     Swap slashes and backslashes.
             N    e#     Push a linefeed.

C, 148 144 140 bajtów

k,r,c,d,p;f(){for(;k<187;k++){r=k/17;c=k%17;d=c+r%2*3;p=3*r+c-7<33u&3*r-c+8<33u;putchar(c==16?10:p&(d+5)%6<2?95:p&d%6==3?47:!p|d%6?32:92);}}

Z białymi znakami, bez ostrzeżeń kompilatora, a przed poprawkami kodu, aby zaoszczędzić kilka bajtów:

#include <stdio.h>

int k, r, c, d, p;

void f() {
    for ( ; k < 187; k++) {
        r = k / 17;
        c = k % 17;
        d = c + 3 * (r % 2);
        p = 3 * r + c - 7 < 33u && 3 * r - c + 8 < 33u;
        putchar(
            c == 16 ? 10 :
            p && (d + 5) % 6 < 2 ? 95 :
            p && d % 6 == 3 ? 47 :
            p && d % 6 == 0 ? 92 :
            32);
    }
}

To podejście nie wykorzystuje żadnych tabel znaków / ciągów. Zapętla wszystkie 187 (11 wierszy, 17 kolumn, w tym nowe wiersze) i decyduje, który znak wydrukować dla każdej pozycji, na podstawie kombinacji warunków.

Warunki obejmują test przebywania wewnątrz / na zewnątrz 4 narożników, przy użyciu 4 równań liniowych, z wynikiem zapisanym w zmiennej p. Reszta jest następnie w większości powtarzana co 6 znaków, a nieparzyste wiersze są przesuwane o 3 znaki w stosunku do parzystych.

Rubin - 78 bajtów

(-5..5).map{|i|puts' '*(j=[i.abs*3-i/6-9,0].max)+('/  \__'*4)[j+i%2*3,16-j*2]}

Transkrypcja rozwiązania xnor (69 bajtów):

11.times{|i|puts' '*(j=[7-i*=3,i-24,0].max)+('\__/  '*9)[i+j,16-j*2]}

JavaScript (ES6), 129 130

To czysty ciąg zamień / zamień / zamień ... nie wykorzystując żadnej właściwości geometrycznej.

Używając ciągów szablonów, wszystkie znaki nowej linii są znaczące i się liczą.

Uruchom snippet w przeglądarce Firefox, aby przetestować

f=_=>`70
405
 055
9992 3051
6301`[R='replace'](/9/g,`55123
30551
`)[R](/5/g,1230)[R](/\d/g,n=>['__','/',,'\\'][n]||' '.repeat(n))

// TEST

O.innerHTML = f()

<pre id=O></pre>

PHP - 139 137 107 101 91 87 bajtów

Nie wiem, czy to najlepszy sposób na grę w golfa, ale oto moja próba:

30 36 46 -50 bajtów dzięki Ismael Miguel

Sprawdź to online tutaj

<?='       __
    __',$a='/  \__',"
 __$a$a
",$c="$a$a/  \
\__$a$a/
","$c$c   \__$a/
      \__/";

<script src="http://ideone.com/e.js/WHWEZS" type="text/javascript" ></script>

stary kod:

<?php $a="/  \\__";$c=$a.$a."/  \\\n\__".$a.$a."/\n";echo "       __\n    __".$a."\n __".$a,$a."\n".$c,$c,$c."   \\__".$a."/\n      \\__/";

Lua 146

T="       __\n    __/  \\__\n __/  \\__/  \\__\n"
S="/  \\__/  \\__/  \\\n\\__/  \\__/  \\__/\n"
B="   \\__/  \\__/\n      \\__/"
io.write(T,S,S,S,B)

(dodano nowe linie dla zachowania przejrzystości)

Dart - 113

main({r:"/  \\__"}){print("       __\n    __$r\n __$r$r\n${"$r$r/  \\\n\\__$r$r/\n"*3}   \\__$r/\n      \\__/");}

Czyste rozwiązanie interpolacji łańcuchów, nic szczególnego. Operacje na łańcuchach, takie jak „substring”, są zbyt szczegółowe, aby konkurować w praktyce.

Uruchom go na DartPad .

JavaScript ( wersja robocza ES7 ), 96 94 93 bajty

Inspiracja zaczerpnięta z kilku rozwiązań tutaj ...

Edycja: -1 z edc65

f=z=>[for(x of[741e6]+36)' '.repeat(x)+'/  \\__'.repeat(4,z^=3).slice(+x+z,16-x+z)].join(`
`)

// For snippet demo:
document.write('<pre>'+f()+'</pre>');

Skomentowano:

f=z=>[                                 
        for(x of [741e6] + 36)        // for each character "x" in "74100000036"
            ' '.repeat(x) +           // x spaces
            '/  \\__'.repeat(4,       // build pattern string
            z ^= 3).                  // toggle z offset (3) for even lines
            slice(+x + z, 16 - x + z) // get appropriate substring
    ].join(`                          // join with newlines
    `)

Python 3, 100 87 bajtów

n=0x85208e08e08dd445
while n:l=n>>2&15;print(' '*(8-l)+('\__/  '*4)[n&3:n&3|l*2]);n>>=6

I czytelna wersja kodu poniżej. Chodzi o to, aby zakodować interwały (początek, długość), a następnie wstawić odpowiednią ilość spacji, aby wyśrodkować interwał.

hexagon_string = '\__/  ' * 4
for i in range(11):
    # Pick the begin and length of the i-th interval using hardcoded numbers
    b = (0x00030303111 >> 4*i) & 3   # n is a combination of these two numbers
    l = (0x25888888741 >> 4*i) & 15  #
    # Print the interval with appropriate whitespace in front of it
    spaces = ' ' * (8-l)
    print(spaces + hexagon_string[b : b+l*2])

Siatkówka , 66 bajtów

<empty line>
sss __<LF>ssa__<LF> aa__<LF>lll dau<LF>ssdu
l
/daa<LF>\aau<LF>
a
ud
u
__/
d
s\
s

Każda linia powinna przejść do własnego pliku i <LF>oznacza rzeczywistą nową linię w pliku. 1 bajt na dodatkowy plik dodany do liczby bajtów.

Możesz uruchomić kod jako jeden plik z -sflagą, zachowując <LF>znaczniki i być może zmieniając je na nowe wiersze na wyjściu, aby były czytelne, jeśli chcesz.

Algorytm składa się z 5 prostych kroków zastępczych (zmiana nieparzystej linii na parzystą), zaczynając od pustego ciągu wejściowego. Wyniki po każdym kroku są (rozdzielone znakami =):

sss __
ssa__
 aa__
lll dau
ssdu
============
sss __
ssa__
 aa__
/daa
\aau
/daa
\aau
/daa
\aau
 dau
ssdu
============
sss __
ssud__
 udud__
/dudud
\ududu
/dudud
\ududu
/dudud
\ududu
 dudu
ssdu
============
sss __
ss__/d__
 __/d__/d__
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
 d__/d__/
ssd__/
============
sss __
ss__/s\__
 __/s\__/s\__
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
 s\__/s\__/
sss\__/
============
       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/

JavaScript, 154 151 bajtów

b="\n",c="\t",d="/  \\",f="__",g="\\",h="/",a=f+d,j=a+a,i=d+j+b+g+j+f+h+b,k="   ";console.log(c+k+f+b+c+a+f+b+" "+j+f+b+i+i+i+k+g+a+f+h+b+c+"  "+g+f+h)