Hãy xem xét các khối 3x3 sau đây mà thuật toán hình vuông diễu hành sẽ xác định cho mọi ô (với ID có nhãn dựa trên 0):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

Mục tiêu của thử thách này được đưa ra một ma trận 2D của khối ID, vẽ toàn bộ đường viền bằng cách xếp các ô nhỏ hơn lại với nhau. Lưu ý rằng có một số trường hợp lặp lại (ví dụ: 0 và 15 trực quan giống nhau)

Đầu vào

Chương trình / hàm của bạn sẽ lấy đầu vào là ma trận hình chữ nhật 2D của các số nguyên trong phạm vi [0+a,15+a](trong đó alà một sự thay đổi số nguyên tùy ý bạn chọn, điều này cho phép bạn sử dụng lập chỉ mục dựa trên số 0 hoặc lập chỉ mục dựa trên 1 cho các khối). Điều này có thể từ bất kỳ nguồn mong muốn (stdin, tham số chức năng, vv).

Đầu ra

Chương trình / hàm của bạn sẽ xuất ra một chuỗi đơn biểu thị toàn bộ đường viền. Không nên có thêm khoảng trắng hàng đầu / dấu, nhưng một dòng mới duy nhất được phép. Không nên có sự tách biệt giữa các khối liền kề theo chiều dọc hoặc chiều ngang.

Lưu ý rằng bạn không phải thực hiện bất kỳ loại xử lý đặc biệt nào đối với các khối ánh xạ tới "yên xe"; chỉ cần vẽ khối với ID đã cho.

Đầu ra có thể là bất kỳ mức chìm nào mong muốn (thiết bị xuất chuẩn, giá trị trả về, v.v.)

Ví dụ

Tất cả các ví dụ dưới đây sử dụng ID khối dựa trên 0.

case 1:

2 1
4 8

......
......
../\..
..\/..
......
......

case 2:

15 13 12 14 15
13 8 0 4 14
11 1 0 2 7
15 11 3 7 15

...............
......---......
...../...\.....
.../.......\...
...............
../.........\..
..\........./..
...............
...\......./...
.....\.../.....
......---......
...............


case 3:

12 12 12 8 4
0 0 0 0 2
0 0 0 2 7
0 2 3 7 15

........./....\
---------......
...............
...............
...............
............../
............/..
...............
.........../...
........./.....
......---......
...../.........

case 4:

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

............
.........---
...\..../...
..\/...|./..
.......|....
...../.|....
/...|...\..\
....|.......
....|.\.....
............
---.........
...../\.....

case 5:

0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 2 7 15 15
0 0 2 5 14 15 15
0 2 5 8 4 12 14
0 4 8 0 0 0 6
0 0 0 0 0 0 4

.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
............/........
.....................
.........../.........
........./...........
.....................
......../../\........
....../../....\......
...............---...
...../../.........\..
.....\/............|.
...................|.
...................|.
....................\
.....................
.....................

Chấm điểm

Đây là mã golf; mã ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

Toán học, 353 326 byte

s=Table[".",3,3];z=Reverse;l@0=l@15=s;y=s;y[[3,1]]="\\";l@1=l@14=y;y=s;y[[3,3]]="/";l@2=l@13=y;y=s;y[[2,All]]="-";l@3=l@12=y;y=l@4=l@11=z/@z@l@1;y[[3,1]]="\\";l@10=y;y=s;y[[All,2]]="|";l@6=l@9=y;y=l@7=l@8=z/@z@l@2;y[[3,3]]="/";l@5=y;StringReplace[ToString@Grid@Map[Column,Map[StringJoin,Map[l,#,{2}],{3}],{2}],{"\n\n"->"\n"}]&

đầu vào

[{{15, 13, 12, 14, 15}, {13, 8, 0, 4, 14}, {11, 1, 0, 2, 7}, {15, 11, 3, 7, 15}} ]

JavaScript (ES6), 195 byte

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

Các trường hợp thử nghiệm

let f =

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

console.log(f([
  [ 2, 1 ],
  [ 4, 8 ]
]));

console.log(f([
  [ 15, 13, 12, 14, 15 ],
  [ 13,  8,  0,  4, 14 ],
  [ 11,  1,  0,  2,  7 ],
  [ 15, 11,  3,  7, 15 ]
]));

console.log(f([
  [ 12, 12, 12,  8,  4 ],
  [  0,  0,  0,  0,  2 ],
  [  0,  0,  0,  2,  7 ],
  [  0,  2,  3,  7, 15 ]
]));

console.log(f([
  [  0,  1,  2,  3 ],
  [  4,  5,  6,  7 ],
  [  8,  9, 10, 11 ],
  [ 12, 13, 14, 15 ]
]));

console.log(f([
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  2,  7, 15, 15 ],
  [  0,  0,  2,  5, 14, 15, 15 ],
  [  0,  2,  5,  8,  4, 12, 14 ],
  [  0,  4,  8,  0,  0,  0,  6 ],
  [  0,  0,  0,  0,  0,  0,  4 ]
]));

Toán học, 173 byte

StringRiffle[ArrayFlatten[ReplacePart[Table[".",16,3,3],{{2|11|15,3,1}|{5|11|12,1,3}->"\\",{3|6|14,3,3}|{6|8|9,1,1}->"/",{4|13,2,_}->"-",{7|10,_,2}->"|"}][[#]]&/@#],"\n",""]&

Hãy thử nó tại hộp cát Wolfram!

" \n" Nên được thay thế bằng một dòng mới. Đầu vào là 1 chỉ mục - ví dụ, trường hợp thử nghiệm thứ ba trở thành {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. Đầu ra là một chuỗi.

Ý tưởng về cơ bản giống như câu trả lời của Jenny_mathy - tạo mười sáu hình vuông bằng cách lấy một lưới 3x3 "."và thay thế một số ký tự, sau đó ghép các hình vuông lại với nhau - nhưng sử dụng các hàm ngắn hơn một chút để thực hiện. (Cảm ơn alephalpha đã nhắc nhở tôi rằng ArrayFlattencó tồn tại!)

Có thể điều này có thể được thực hiện trong ít byte hơn bằng cách tạo các ô vuông một cách khéo léo thay vì cơ bản mã hóa chúng, nhưng điều đó sẽ đòi hỏi nhiều nỗ lực hơn

Võng mạc , 165 byte

T`d`L`1\d
 |\bB\B

.+
X$&¶Y$&¶Z$&
%{`[XYZ]$

([XYZ])[69]
.|.$1
X[^4-B]
...X
X[4AB]
..\X
X[578]
/..X
Y[^369C]
...Y
Y[3C]
---Y
Z[03478BCF]
...Z
Z[1AE]
\..Z
Z[25D]
../Z

Hãy thử trực tuyến! Liên kết bao gồm ví dụ thứ hai. Giải thích: Hai giai đoạn đầu tiên chuyển đổi từ thập phân sang thập lục phân, cho phép các khoảng trắng bị xóa. Giai đoạn thứ ba sau đó tăng gấp ba lần mỗi dòng, cung cấp cho mỗi dòng mới một điểm đánh dấu riêng. Các điểm đánh dấu này sau đó đi qua các chữ số hex, chuyển đổi chúng thành biểu đồ đường viền khi chúng đi, cho đến khi chúng đến cuối dòng, tại đó chúng bị xóa.

Python 2 , 247 byte

J='...'
print'\n'.join(map(''.join,sum([[sum([f[i*3:][:3]for i in j],[])for f in map(list,[J*4+'..\\/...|./../...|...\\..\\'+J*4,J*3+'---.......|........|.......---'+J*3,'...\\..../......../.|........|.\\'+J*3+'./\\.....'])]for j in input()],[])))

Hãy thử trực tuyến!

-1 byte nhờ LeakyNun

SOGL V0.12 , 106 89 byte

žj}² ³
ē0=?²
{ā;{"⁰9═‼pnk№Ο|╚φ;“2─6nwEX .9*3n²Xƨ.ƨ-¹╬-}²X"č7_#‘3n}² /33³\13³\31³/11žj}┼}O

Hãy thử nó ở đây! (có thêm một byte →để dễ dàng nhập liệu. Điều này nếu không sẽ mong đợi mảng đã có trên ngăn xếp)

Python 2, 196 191 181 176 byte

Hãy thử trực tuyến!

Một hàm lấy một mảng các mảng int và trả về một chuỗi:

J=''.join;N='\n'.join
f=lambda I:N(N(J(J('\/|-.'[C/16-2]*(C%16)for C in map(ord,'o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k'))[c*9+3*j:][:3]for c in r)for j in[0,1,2])for r in I)

EDIT: đã lưu 5 byte bằng cách gán J, N; 10 byte khác bởi vì tôi quên đầu vào đã được coi là một mảng các mảng int; và sau đó 5 byte khác được lưu bằng cách cắt thông minh hơn ...

Chuỗi được nối của tất cả 16 ô 3x3 (144 byte, bỏ qua ngắt dòng) được mã hóa theo chiều dài chạy thành chuỗi 41 byte:

o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k

trong đó mỗi phần tử RLE (cellType, length)được mã hóa cho ký tự chr(32+16*cellType+length)(thật tiện lợi khi chạy tối đa là 15; và nó ord(' ')==32được chia cho 16). Khi giải mã, chúng ta lấy '\/|-.'[cellType]ký tự có thể in được.

Không có gì đặc biệt thông minh sau đó ...

05AB1E , 61 byte

v•2mßklJFΘõÿ|åU‚ιØØ•6B5¡∊¶¡110bTǝ.BJ3ô3ôyèøJ»}»4ÝJð«"\./-|."‡

Hãy thử trực tuyến!

Nửa đầu của mẫu có thể được nén thành:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

Nửa thứ hai sẽ cần phải là:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Chúng ta chỉ có thể phản chiếu theo chiều dọc của nửa đầu và chèn binary 110 (1101110)vào cho 2111111125.

Tiếp theo, chúng tôi lấy mô hình này và chia thành các nhóm, sau đó đệm nó với các mẫu:

1 = 111111111
2 = 111111011
3 = 111111112
4 = 111333111
5 = 110111111
6 = 211111112
7 = 141141141
8 = 211111111
9 = 141141141
A = 110111011
B = 110111111
C = 111333111
D = 111111112
E = 111111111

Bây giờ chúng ta có các khối xây dựng của mình, các phần cuối chỉ thay thế các mục ma trận bằng các khối xây dựng phù hợp, nén các hàng lại với nhau và in cho người dùng bằng các ký hiệu thay thế:

0 = .........
1 = ......\..
2 = ......../
3 = ...---...
4 = ..\......
5 = /......./
6 = .|..|..|.
7 = /........
8 = /........
9 = .|..|..|.
A = ..\...\..
B = ..\......
C = ...---...
D = ......../
E = .........

Có thể đăng giải thích hoạt động chính thức nếu bất cứ ai muốn nó, cảm ơn.

Jelly , 64 byte

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y

Hãy thử trực tuyến!

Điều này sử dụng một nén ngây thơ và có thể có thể lưu nhiều byte với mã hóa độ dài chạy.

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

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y
“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ encodes the integer 4591777158889232952973696500124538798606476761349931038636020730336909822188496590423586252520
ṃ“/-\|.”                   - convert to base 5 and index into the string to get "/......../.........|..|..|...\...\....\.........---.........../......\.................\........../...---.....\....../......./.|..|..|."
        s3s3               - split every 9 characters into a 3x3 square submatrix       
            ṙ9             - rotate left by 9 to line up the submatrix for 1 with index 1
              ị@³          - index the input into this
                 ZY$€Y     - format