다음과 같은 텍스트가 제공됩니다.

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

픽셀을 문자와 연결하여 동일한 텍스트를 출력합니다 ─│┌┐└┘├┤┬┴┼. 픽셀에 이웃이 없으면 변경하지 마십시오.

따라서 마지막 텍스트의 출력은 다음과 같습니다.

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

• 부울 배열로 입력을받을 수 있습니다.
• 입력은 항상 1 픽셀 이상을 포함합니다.
• 상자 그리기 문자를 1 바이트로 계산할 수 있습니다.
• 입력이 공백으로 채워져 있다고 가정 할 수 있습니다.

테스트 사례

## #
=>
── #

###
 #
=>
─┬─
 │

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

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

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

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

이것이 code-golf 이므로 가장 짧은 코드가 승리합니다.

젤리 , 60 52 51 50 49 48 바이트

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

@ Dennis 덕분에 바이트를 절약했습니다 .

입력은 1과 0의 부울 배열입니다. 각 열과 각 행을 반복하여 크기 3의 각 접두사의 머리와 꼬리를 이진수 쌍에서 10 진수로 변환하고 각 접두사의 중심에 곱합니다. 그런 다음 인덱스를 찾기 위해 자체와 합산합니다 '#───│┌┐┬│└┘┴│├┤┼ '.

온라인으로 사용해보십시오! ( 사례 2 ) ( 사례 3 ) ( 사례 4 )

설명

이것은 J의 대답 과 같은 아이디어에 의존 하지만 각 3x3 하위 배열에서 처리하는 대신 여전히 동일한 인덱스 테이블을 얻는 동안 각 행과 각 열을 처리합니다.

바이트의 절반 이상이 박스 문자 목록을 생성하는 데 소비 '#───│┌┐┬│└┘┴│├┤┼ '됩니다. 문자열 리터럴 “은 Jelly로 시작 하며 터미네이터에 따라 다른 의미를 갖습니다. 여기서 종료 ’자는 문자열이 Jelly 코드 페이지 에 따라 각 문자의 코드 포인트로 구문 분석되고 기본 250 자리 목록에서 10 진수로 변환 됨을 의미합니다 .

“µ³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) => '───│┌┐┬│└┘┴│├┤┼'

그런 다음 십진수를 bijective base 61의 자릿수 목록으로 변환하고 9471 씩 증가시켜 상자 문자 범위로 옮기고 Python을 사용하여 각각 변환하십시오 chr. 그런 다음 문자 리터럴을 앞에 ”#추가하고 공백을 추가하십시오 ⁶.

ṖḤ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 바이트

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

입력은 1과 0의 부울 테이블입니다. 규칙에 따르면 상자 문자는 각각 3이 아닌 1 바이트로 계산되며 여기에 적용됩니다.

용법

   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
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #

설명

먼저 입력이 모든면에 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
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

그런 다음 크기 3의 각 하위 배열이 선택됩니다.

   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│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

그런 다음 각 하위 배열의 5 개 값만 고려됩니다.

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

ABCD각 하위 배열을 병합하고 인덱스를 선택하여 값 을 선택합니다 1 7 3 5. 이 값은 E인덱스 4에 곱해집니다 . 그런 다음 이진수 목록에서 10 진수로 변환되고 씩 증가합니다 E. x값은 필요하지 않습니다.

   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

아래 표에 따라 어떤 캐릭터를 그릴 지 선택하는 인덱스로 사용됩니다 (골프를 위해 약간 순서가 바)). 마지막 열은 각 하위 배열의 출력 값을 상자 문자와 일치시킵니다.

 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

또한 J에서 문자열 ' #───│┌┐┬│└┘┴│├┤┼'은 8 비트 문자를 사용하여 필요한 17 문자에 대해 길이가 47 바이트 (각 바이트 당)입니다. 이 명령 ucp은 16 비트 문자로 변환하여 길이가 17이되도록합니다.

자바 스크립트 (ES6) 155 개 121 103 102 문자

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' +
  '   ####  ##'
));

편집 : ETHproductions의 도움으로 18 바이트 저장 편집 : 다음과 같이
replace ()의 첫 번째 매개 변수를 사용하여 1 바이트 저장'#'

작동 원리

#입력 문자열에있는 모든 문자를 반복 합니다. 각각에 #대해 t()함수를 사용하여 이웃도 문자 인지 테스트합니다 .

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

파라미터 x의 t()기능은 현재 위치에 대한 이웃의 오프셋된다 p. 우리는 -1 / + 1을 사용하여 왼쪽 / 오른쪽 이웃을 테스트하고 -w / + w를 위 / 아래 이웃 ( w행의 너비, 즉 첫 번째 줄 바꿈 위치 + 1)에 대해 테스트 합니다.

각 이웃에게는 다음 나침반에 따라 다른 가중치 (1, 2, 4 또는 8)가 할당됩니다.

  1
2 + 4
  8

각 가중치 조합은 [0 .. 15]에서 고유 한 값으로 이어집니다. 예를 들어 상단의 이웃과 오른쪽의 이웃이 모두 설정된 경우 합계는 1 + 4 = 5가되며이 └테이블 을 사용하여 변환됩니다 .

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

따라서 '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]예상되는 문자로 이어집니다.

파이썬 2.7, 318 315 바이트 ( 270 개 267 문자)

나는 이것이 더 골프를 칠 수 있다고 확신한다 (특히 성가신 첫 줄 주석을 제거하고 싶습니다). 그러나 여기 내 입장이 있습니다 :

#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')],' ')

전체 작동 방식에 대한 설명은 다음과 같습니다.

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

편집 : 전에 공백을 제거했습니다. for ... in ...

자바 스크립트 (ES6) 150 개 139 133 131 문자

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`
`

입력을 문자열 배열로 가져옵니다 (예 :) f(["###", " # "]).

테스트 스 니펫

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>

알파카 , 414 + 2 = 416 바이트

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"─".

-fI플래그가 필요합니다 .

이 솔루션은 매우 많은 바이트를 사용하지만 셀룰러 오토 마톤을 사용한다는 점에서 독특합니다. ALPACA는 일반적으로 금속 언어로 사용되지만 여기서는 프로그래밍 언어로 사용합니다.

언 골프 버전 :

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 바이트

이것은 아마도 더 짧은 방법으로 이루어질 수 있습니다.

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

STDIN에서 입력을 읽습니다. 로 실행하십시오 -r.

파이썬 3, 149 바이트

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

like ##\n #\n와 같은 입력을 취하고 like 와 같은 출력을 리턴합니다 ['─', '┐', '\n', ' ', '│', '\n'].

R, 199212 바이트

편집 : 이제 코드 스 니펫이 아닌 함수입니다.

입력은 m1과 0 의 행렬 입니다. 이것은 꽤 추악하고 해키입니다.

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 = 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")}
┌┬┬┐
├┼┼┤
├┼┼┤
└┴┴┘

펄, 89 88 바이트

에 +2가 포함됩니다 -0p. 특수 문자는 1 바이트로 계산되지만 실제로 단일 문자로 표시되도록하려면 -C 옵션을 추가하는 것이 가장 좋습니다.

공백이 채워진 STDIN에 입력하십시오. 모두 동일한 길이를 갖습니다.

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 자

이웃에게 값 (1, 2, 4 또는 8)을 할당합니다. 그들의 합은 그림 문자를 포함하는 문자열의 문자와 일치합니다. 나는 여전히 개선의 여지가 많이 있다고 생각하지만 대략 초안을 작성해야합니다.

' #│││─┌└├─┐┘┤─┬┴┼' % 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 ).

개선 사항 :

• 전체 합산 부분을 행렬의 회전 사본에서 작동하는 일종의 루프로 교체 할 수 있습니다.
• 전체를 버리고 매트릭스를 통해 작동하는 단일 루프를 기반으로 무언가를 만듭니다.
• 모듈 형 인덱싱을 사용하여 원래 배열 (?) 의 평평한 벡터에서 작업

온라인으로 사용해보십시오! (상자 그리기 문자를 지원하지 않을 수 있음)