Đưa ra một văn bản như thế này:

# #### ## #
## #  ##  #
   ####  ##

Xuất cùng một văn bản nhưng bằng cách kết nối các pixel với các ký tự ─│┌┐└┘├┤┬┴┼. Nếu một pixel không có bất kỳ hàng xóm nào, đừng thay đổi nó.

Vì vậy, đầu ra của văn bản cuối cùng là:

│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘

• Bạn có thể lấy đầu vào là một mảng boolean.
• Đầu vào sẽ luôn chứa ít nhất 1 pixel.
• Bạn có thể đếm các ký tự vẽ hộp là 1 byte.
• Bạn có thể giả sử đầu vào được đệm bằng khoảng trắng.

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

## #
=>
── #

###
 #
=>
─┬─
 │

##### ##
 # #  #
########
=>
─┬─┬─ ┌─
 │ │  │
─┴─┴──┴─

 # #
#####
 # #
=>
 │ │
─┼─┼─
 │ │

# # # # #
 # # # #
# # # # #
 # # # #
# # # # #
=>
# # # # #
 # # # #
# # # # #
 # # # #
# # # # #

#####
#####
#####
#####
#####
=>
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘

Vì đây là môn đánh gôn , nên đoạn mã ngắn nhất sẽ thắng.

Thạch , 60 52 51 50 49 48 byte

ṖḤ0;+Ḋ×
“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j
ZÑ€4×Z++Ñ€ị¢Y

Đã lưu một byte nhờ @ Dennis.

Đầu vào là một mảng boolean của 1 và 0. Lặp lại trên mỗi cột và mỗi hàng chuyển đổi đầu và đuôi của mỗi số nguyên có kích thước 3 từ một cặp chữ số nhị phân thành số thập phân và nhân số đó với tâm của mỗi số. Sau đó, nó tổng hợp nó để tìm chỉ mục vào '#───│┌┐┬│└┘┴│├┤┼ '.

Hãy thử trực tuyến! ( trường hợp 2 ) ( trường hợp 3 ) ( trường hợp 4 )

Giải trình

Điều này dựa trên cùng một ý tưởng như câu trả lời của tôi trong J nhưng thay vì xử lý trên mỗi phân đoạn 3x3, tôi xử lý qua từng hàng và từng cột trong khi vẫn nhận được cùng một bảng chỉ mục.

Hơn một nửa số byte được dành để tạo danh sách các ký tự hộp '#───│┌┐┬│└┘┴│├┤┼ '. Chuỗi ký tự bắt đầu bằng “Jelly và có ý nghĩa khác nhau tùy thuộc vào terminator của chúng. Ở đây, terminator ’có nghĩa là chuỗi sẽ được phân tích cú pháp dưới dạng các điểm mã của từng ký tự theo trang mã Jelly và chuyển đổi từ danh sách 250 chữ số cơ bản thành số thập phân.

“µ³Q~E!G⁸ṗṫ\’ => 10041542192416299030874093
(bijective base 61) => [1, 1, 1, 3, 13, 17, 45, 3, 21, 25, 53, 3, 29, 37, 61]
(add 9471 and convert to char) => '───│┌┐┬│└┘┴│├┤┼'

Sau đó chuyển đổi số thập phân đó thành một danh sách các chữ số trong cơ sở phỏng đoán 61 và tăng từng số 9471 để di chuyển nó vào phạm vi của các ký tự hộp và chuyển đổi từng chữ số bằng Python chr. Sau đó, chuẩn bị nó với một ký tự bằng chữ ”#và nối thêm một khoảng trắng ⁶.

ṖḤ0;+Ḋ×  Helper link - Input: 1d list A
Ṗ        Get all of A except the last value
 Ḥ       Double each value in it
  0;     Prepend a 0
    +    Add elementwise with
     Ḋ     All of A except the first value
      ×  Multiply elementwise by A

“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j  Nilad. Represents '#───│┌┐┬│└┘┴│├┤┼ '
“µ³Q~E!G⁸ṗṫ\’               Get the code points of each char in the string and
                            convert from a list of base 250 digits to decimal
             ḃ61            Convert that to a list of digits in bijective base 61
                +9471       Add 9400 to each
                     Ọ      Convert from ordinals to chars, gets '───│┌┐┬│└┘┴│├┤┼'
                      ⁾#    A pair of chars ['#', ' ']
                         j  Join the pair using the box characters

ZÑ€4×Z++Ñ€ị¢Y  Input: 2d list M
Z              Transpose
 р            Apply the helper link to each row of the transpose (each column of M)
   4×          Multiply each by 4
     Z         Transpose
      +        Add elementwise with M
       +       Add elementwise with
        р       The helper link applied to each row of M
          ị¢   Use each result as an index to select into the nilad
            Y  Join using newlines
               Return and print implicitly

J , 82 72 66 byte

(ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]

Đầu vào là một bảng boolean của 1 và 0. Các quy tắc nêu rõ rằng mỗi ký tự hộp được tính là một byte, không phải ba và đã được áp dụng ở đây.

Sử dụng

   f =: (ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]
   m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
   m { ' #'
# #### ## #
## #  ##  #
   ####  ##
   f m
│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘
   ' #' {~ m =: 5 5 $ 1
   f m
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘
   ' #' {~ m =: 5 9 $ 1 0
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #
   f m
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #

Giải trình

Đầu tiên, đầu vào được đệm bằng 0 trên tất cả các mặt.

   ] m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
1 0 1 1 1 1 0 1 1 0 1
1 1 0 1 0 0 1 1 0 0 1
0 0 0 1 1 1 1 0 0 1 1
   (0,.~0,.0,~0,]) m
0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 1 1 1 0 1 1 0 1 0
0 1 1 0 1 0 0 1 1 0 0 1 0
0 0 0 0 1 1 1 1 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0

Sau đó, mỗi phân đoạn kích thước 3 được chọn

   3 3 <;._3 (0,.~0,.0,~0,]) m
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Sau đó, chỉ có 5 trong số các giá trị trong mỗi phân đoạn được xem xét

┌───┐
│xAx│
│CED│
│xBx│
└───┘

Các giá trị ABCDđược chọn bằng cách làm phẳng từng phân đoạn và chọn tại các chỉ mục 1 7 3 5. Các giá trị này được nhân Evới chỉ số 4. Sau đó, nó được chuyển đổi từ danh sách các chữ số nhị phân thành số thập phân và tăng theo E. Các xgiá trị không cần thiết.

   3 3 (4&{([+2#.*)1 7 3 5&{)@,;._3 (0,.~0,.0,~0,]) m
 5 0 2  8 4 3  0  6 3 0  5
10 3 0 13 0 0  6 11 0 0 13
 0 0 0 10 4 4 11  0 0 2 11

Điều này được sử dụng như một chỉ mục để chọn nhân vật sẽ vẽ theo bảng bên dưới (sắp xếp lại một chút để chơi gôn). Cột cuối cùng khớp với giá trị đầu ra của mỗi phân đoạn cho một ký tự hộp.

 0  (space)  0
 1  #        1
 2  ┌        6
 3  ┬        8
 4  ┐        7
 5  ├        14
 6  ┼        16
 7  ┤        15
 8  └        10
 9  ┴        12
10  ┘        11
11  │        5, 9, 13
12  ─        2, 3, 4

Ngoài ra, trong J, chuỗi ' #───│┌┐┬│└┘┴│├┤┼'sử dụng các ký tự 8 bit khiến nó có độ dài 47 (cho mỗi byte) cho 17 ký tự cần thiết. Lệnh ucpchuyển đổi nó thành các ký tự 16 bit cho phép nó có độ dài 17.

JavaScript (ES6), 155 121 103 102 ký tự

let f =
    
s=>s.replace(/#/g,(c,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]==c,8*t(w=s.search`
`+1)+4*t(1)+2*t(-1)+t(-w)])

console.log(f(
  '# #### ## #\n' +
  '## #  ##  #\n' +
  '   ####  ##'
));

Chỉnh sửa: đã lưu 18 byte với sự trợ giúp của ETHproductions
Chỉnh sửa: đã lưu 1 byte bằng cách sử dụng tham số đầu tiên của thay thế () là'#'

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

Chúng tôi lặp lại trên tất cả các #ký tự được tìm thấy trong chuỗi đầu vào. Đối với mỗi người trong số họ, chúng tôi kiểm tra xem hàng xóm của họ có phải là #nhân vật sử dụng t()hàm không:

t = x => s[p + x] == c  // where c = '#'

Tham số xcủa t()hàm là phần bù của hàng xóm đối với vị trí hiện tại p. Chúng tôi sử dụng -1 / + 1 để kiểm tra hàng xóm trái / phải và -w / + w cho hàng xóm trên / dưới (trong đó wlà chiều rộng của một hàng, tức là vị trí của ngắt dòng đầu tiên + 1).

Mỗi hàng xóm được gán một trọng lượng khác nhau (1, 2, 4 hoặc 8) theo la bàn sau:

  1
2 + 4
  8

Mỗi kết hợp trọng lượng dẫn đến giá trị duy nhất trong [0 .. 15]. Chẳng hạn, nếu cả hàng xóm ở trên cùng và hàng xóm bên phải được đặt, tổng sẽ là 1 + 4 = 5, được dịch thành └sử dụng bảng này:

00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
#  │  ─  ┘  ─  └  ─  ┴  │  │  ┐  ┤  ┌  ├  ┬  ┼

Do đó, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]dẫn đến các nhân vật mong đợi.

Python 2.7, 318 315 byte ( 270 267 ký tự)

Tôi chắc chắn rằng điều này có thể được đánh gôn hơn nữa (đặc biệt là tôi muốn thoát khỏi nhận xét đầu tiên gây phiền nhiễu đó) nhưng đây là mục nhập của tôi:

#encoding:utf-8
f=lambda t:(lambda l,s:'\n'.join(''.join((u'┼├┤│┬┌┐│┴└┘│───#'[(s==l[i][j-1])+2*(s==l[i][j+1])+4*(i<1 or s==l[i-1][j])+8*(i>len(l)-2 or s==l[i+1][j])],s)[s==l[i][j]]for j in range(len(l[i])-1))for i in range(len(l))))([l+' 'for l in t.split('\n')],' ')

Đây là một lời giải thích về cách toàn bộ hoạt động:

#encoding:utf-8 # Dammit, Python. This adds an extra 16 bytes!
f=lambda t:( # main lambda function
    lambda l,s: # inner lambda so we can pass it "local constants" (see last line)
        '\n'.join( # join each line
            ''.join( # join each char within the line
                (u'┼├┤│┬┌┐│┴└┘│───#'[ # string of all possible characters, indexed by binary 0-15 based on adjacent chars
                    (s==l[i][j-1])+ # left
                    2*(s==l[i][j+1])+ # right
                    4*(i<1 or s==l[i-1][j])+ # up ('i<1' just yields zero in case this is the first line, so that we don't get index problems)
                    8*(i>len(l)-2 or s==l[i+1][j])], # down ('i>len(l)-2' is same as above)
                s)[s==l[i][j]] # if original is space, choose space, else choose the previously chosen box-drawing char
                for j in range(len(l[i])-1)) # do this process for each char (excluding last, which is a space)
            for i in range(len(l))) # do this for each line
    )([l+' ' for l in t.split('\n')],' ') # call the inner lambda with two parameters: first, the text split into lines; second, a space char (actually makes code shorter)

EDIT: Đã xóa một số khoảng trắng trước for ... in ...

JavaScript (ES6), 150 139 133 131 ký tự

a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

Lấy đầu vào là một chuỗi các chuỗi, ví dụ f(["###", " # "]).

Kiểm tra đoạn

f=a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

<textarea id=I rows=6># #### ## #
## #  ##  #
   ####  ##</textarea>
<br>
<button onclick="O.innerHTML=f(I.value.split('\n')).replace(/\n/g,'<br>')">Run</button>
<pre id=O></pre>

ALPACA , 414 + 2 = 416 byte

neighbourhoodV(^ v < >);states" ";statep"#"toA when4inV p,toB when3inV p andvs,toC when3inV p and^s,toD when3inV p and>s,toE when3inV p and<s,toF when2inV p and>s andvs,toG when2inV p andvs and<s,toH when2inV p and<s and^s,toI when2inV p and^s and>s,toJ when^p orvp,toK when<p or>p;stateA"┼";stateB"┴";stateC"┬";stateD"┤";stateE"├";stateF"┘";stateG"└";stateH"┌";stateI"┐";stateJ"│";stateK"─".

Yêu cầu các -fIcờ.

Giải pháp này sử dụng một số lượng rất lớn byte, nhưng nó độc đáo ở chỗ nó sử dụng một máy tự động di động. ALPACA thường được sử dụng như một ngôn ngữ kim loại, nhưng ở đây tôi đang sử dụng nó như một ngôn ngữ lập trình.

Phiên bản bị đánh cắp:

neighbourhood V (^ v < >);
state s " ";
state p "#" to A when 4 in V p,
to B when 3 in V p and v s,
to C when 3 in V p and ^ s,
to D when 3 in V p and > s,
to E when 3 in V p and < s,
to F when 2 in V p and > s and v s,
to G when 2 in V p and v s and < s,
to H when 2 in V p and < s and ^ s,
to I when 2 in V p and ^ s and > s,
to J when ^ p or v p,
to K when < p or > p;
state A "┼";
state B "┴";
state C "┬";
state D "┤";
state E "├";
state F "┘";
state G "└";
state H "┌";
state I "┐";
state J "│";
state K "─".

PHP, 203 byte

Điều này có thể được thực hiện trong một cách ngắn hơn.

while($s=fgets(STDIN))$f[]=$s;foreach($f as$y=>&$s)for($x=strlen($s);$x--;)if($s[$x]>$b=" ")$s[$x]="#───│┘└┴│┐┌┬│┤├┼"[($s[$x-1]>$b)+2*($s[$x+1]>$b)+4*($f[$y-1][$x]>$b)+8*($f[$y+1][$x]>$b)];echo join($f);

đọc đầu vào từ STDIN. chạy với -r.

Python 3, 149 byte

def f(s):S=' ';w=s.find('\n')+1;t=lambda i:(s+w*S)[i]>S;return[[c,'#│─┘─└─┴││┐┤┌├┬┼'[t(p-w)+2*t(p-1)+4*t(p+1)+8*t(p+w)]][c>S]for p,c in enumerate(s)]

Lấy đầu vào thích ##\n #\nvà trả về đầu ra như thế nào ['─', '┐', '\n', ' ', '│', '\n'].

R, 199 212 byte

EDIT: Bây giờ nó là một chức năng, chứ không phải là một đoạn mã.

Đầu vào là ma trận m1s và 0s. Điều này là khá xấu xí và hacky.

function(m){
v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
d=dim(m)+1
n=array(0,dim=d+1)
n[2:d[1],2:d[2]]=m
for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
}

Một vài thử nghiệm:

> m = matrix(c(1, 1, 1, 0, 1, 0), nrow=2, byrow=TRUE)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
─┬─
 │ 
> m = matrix(rep(1, 16), ncol=4)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
┌┬┬┐
├┼┼┤
├┼┼┤
└┴┴┘

Perl, 89 88 byte

Bao gồm +2 cho -0p. Các ký tự đặc biệt được tính là 1 byte, nhưng để làm cho chúng thực sự hiển thị dưới dạng các ký tự đơn, tốt nhất là thêm tùy chọn -C.

Cung cấp đầu vào trên STDIN với không gian dòng được đệm để tất cả chúng có cùng độ dài:

perl -C connect.pl
# #### ## #
## #  ##  #
   ####  ##
^D

connect.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s%#%substr"#───│└┘┴│┌┐┬│├┤┼",/\G##/+2*/#\G/+4*/#$n\G/s+8*/\G#$n#/s,1%eg

MATL, 102 ký tự

Tôi gán cho hàng xóm một giá trị (1, 2, 4 hoặc 8); tổng của chúng sẽ khớp với một ký tự trong chuỗi chứa các ký tự vẽ. Tôi nghĩ vẫn còn nhiều chỗ để cải tiến, nhưng đối với một bản thảo thô:

' #│││─┌└├─┐┘┤─┬┴┼' % String to be indexed
wt0J1+t4$(          % Get input, and append zeros at end of matrix (solely to avoid
                    %  indexing a non-existent second row/column for small inputs)
ttttt               % Get a whole load of duplicates to work on
3LXHY)              % Select rows 2:end from original matrix (one of the many dupes)
      w4LXIY)       % Select rows 1:end-1 from the 'destination' summing matrix)
             +HY(   % Add the neighbors below, store in 'destination' matrix
tIY)b3LY)2*+IY(     % +2* the neighbors above    +-------------------------------+
tHZ)b4LZ)4*+HZ(     % +4* the neighbors right    |(note: H and I contain 1:end-1 |
tIZ)b3LZ)8*+IZ(     % +8* the neighbors left     |  and 2:end respectively)      |
HH3$)               % Select the original matrix +-------------------------------+
*                % Make sure only cells that originally had a # get replaced
  1+)            % Add one because the original string is one-indexed. Index using ).

Những cải tiến cần thực hiện:

• Có thể thay thế toàn bộ phần tổng kết bằng một số loại vòng lặp làm việc trên các bản sao xoay của ma trận
• Bỏ toàn bộ và tạo một cái gì đó dựa trên một vòng lặp làm việc thông qua ma trận
• Sử dụng lập chỉ mục mô-đun để làm việc trên một vectơ phẳng từ mảng ban đầu (?)

Hãy thử trực tuyến! (có thể không có hộp hỗ trợ ký tự vẽ)