Viết chương trình ngắn nhất in phần nghệ thuật ASCII này của lát gạch hình lục giác hoặc tổ ong :

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

• Không có đầu vào nên được thực hiện.
• Xuất ra thiết bị xuất chuẩn hoặc ngôn ngữ thay thế gần nhất của bạn.
• Thay vì một chương trình, bạn có thể viết một hàm có tên không có tham số và in kết quả bình thường hoặc trả về dưới dạng chuỗi.
• Đầu ra có thể có bất kỳ số dòng mới hàng đầu và / hoặc dấu và mỗi dòng trong đầu ra có thể có bất kỳ số khoảng trắng hàng đầu và / hoặc dấu (miễn là mẫu được sắp xếp đúng.)
• Mã ngắn nhất tính bằng byte thắng.

CJam, 45 43 42 41 40 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

"\__/  "38*21/

lặp lại mô hình \__/ 38 lần và chia nó thành các đoạn dài 21 . Nếu các phần được phân tách bằng các nguồn cấp dữ liệu, đây sẽ là kết quả:

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

Điều này rõ ràng có chứa tổ ong mong muốn. Tất cả những gì còn lại phải làm là thay thế một số ký tự bằng khoảng trắng, cắt bỏ một số ký tự khác và thực sự giới thiệu các nguồn cấp dữ liệu.

741e8 36+Ab

tạo số nguyên 74 100 000 036 và chuyển đổi nó thành mảng [7 4 1 0 0 0 0 0 0 3 6] . Mỗi phần tử mảng mã hóa số lượng ký tự đầu của dòng tương ứng phải được thay thế bằng khoảng trắng. Bằng cách trừ số này từ 16 , chúng tôi cũng có được độ dài chính xác cho dòng này.

.{            } 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.

Vì một không gian có điểm mã thấp hơn các ký tự khác của L và các toán tử được vector hóa để lại các ký tự của chuỗi dài hơn không tương ứng với một trong các ký tự ngắn hơn chưa được chạm tới, .e<thay thế các ký tự D đầu tiên bằng khoảng trắng.

Con trăn 2, 73

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

Thấy nó chạy.

Đối với mỗi trong số 11 hàng đầu ra, hãy tính số lượng khoảng trắng hàng đầu klà tối đa ba hàm tuyến tính tạo thành đường bao bên trái của hình lục giác. Bởi vì các đường chéo có độ dốc 3và -3tốt hơn là lập chỉ mục số hàng là i=0,3,...30.

Để tạo lưới lục giác, trước tiên chúng ta gạch đủ đơn vị '\__/ '. Sau đó, dịch chuyển căn chỉnh [i:]lại nó bằng 3 cho các hàng lẻ. Cuối cùng, chúng tôi lấy phần cần thiết [k:16-k]của nó, để lại một lề kbên trái và bên phải.

CJam, 65 56 55 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý kiến

Nửa bên phải của mỗi dòng là một bản sao đảo ngược của nửa bên trái với dấu gạch chéo và dấu gạch chéo ngược được hoán đổi. Do đó, nó đủ để mã hóa nửa bên trái của tổ ong:

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

Thay vì phân tích từng dòng mẫu này, chúng ta có thể phân tích từng cột theo từng cột:

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

Các mẫu hiển nhiên xuất hiện:

• Chuỗi _ _ _ _xảy ra năm lần.
• Mỗi người /được theo sau bởi a \.

Bằng cách thay thế mỗi /\, _, _ _ _ _và không gian với một số 0-3, chúng tôi có thể chuyển đổi các mảng kết quả từ một số cơ sở 4 đến một cơ sở cao hơn và lưu trữ mô hình hoàn chỉnh trong một thời trang nhỏ gọn.

Mã

"Ý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 byte

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

Với khoảng trắng, không có cảnh báo trình biên dịch và trước một số chỉnh sửa mã để lưu một vài byte:

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

Cách tiếp cận này không sử dụng bất kỳ bảng ký tự / chuỗi. Nó lặp trên tất cả 187 (11 hàng, 17 cột bao gồm cả dòng mới) và quyết định in ký tự nào cho từng vị trí, dựa trên sự kết hợp của các điều kiện.

Các điều kiện bao gồm một bài kiểm tra để ở bên trong / bên ngoài 4 góc, sử dụng phương trình 4 dòng, với kết quả được lưu trong biến p. Phần còn lại sau đó chủ yếu lặp lại cứ sau 6 ký tự, với các hàng lẻ được dịch chuyển bởi 3 ký tự so với các hàng chẵn.

Ruby - 78 byte

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

Phiên âm của giải pháp xnor's (69 Byte):

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

JavaScript (ES6), 129 130

Đó là một chuỗi thuần thay thế / thay thế / thay thế ... không tận dụng bất kỳ thuộc tính hình học nào.

Sử dụng chuỗi mẫu, tất cả các dòng mới đều có ý nghĩa và số lượng.

Chạy đoạn trích trong Firefox để kiểm tra

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 byte

Tôi không biết đây có phải là cách tốt nhất để chơi golf không nhưng đây là thử của tôi:

30 36 46 -50 byte nhờ Ismael Miguel

Kiểm tra nó trực tuyến tại đây

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

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

mã cũ:

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

(dòng mới được thêm vào cho rõ ràng)

Phi tiêu - 113

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

Giải pháp nội suy chuỗi thuần túy, không có gì lạ mắt. Các hoạt động chuỗi như "chuỗi con" quá dài để cạnh tranh trong thực tế.

Chạy nó trên DartPad .

Javascript ( Dự thảo ES7 ), 96 94 93 byte

Cảm hứng lấy từ một vài giải pháp ở đây ...

Chỉnh sửa: -1 từ 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>');

Đã bình luận:

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 byte

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

Và một phiên bản có thể đọc được của mã dưới đây. Ý tưởng là mã hóa các khoảng (bắt đầu, độ dài) và sau đó đệm với số lượng khoảng trống chính xác để căn giữa khoảng.

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

Võng mạc , 66 byte

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

Mỗi dòng nên đi đến tệp riêng của nó và <LF>có nghĩa là dòng mới thực sự trong tệp. 1 byte cho mỗi tệp bổ sung được thêm vào số byte.

Bạn có thể chạy mã dưới dạng một tệp với -scờ, giữ các <LF>điểm đánh dấu và có thể thay đổi chúng thành dòng mới trong đầu ra để dễ đọc nếu bạn muốn.

Thuật toán là 5 bước thay thế đơn giản (thay đổi nội dung dòng lẻ thành nội dung dòng chẵn) bắt đầu từ một chuỗi đầu vào trống. Kết quả sau mỗi bước là (được phân định bởi ='s):

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 byte

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)