내 윤곽선 그리기

25

직사각형의 표고 행렬이 주어지면 윤곽선을 그립니다.

태스크

두 요소 x이며 y동일한 경우 등고선 레벨에 floor(x/10) == floor(y/10)있습니다. 예를 들어, 52와 58같은 윤곽선 수준에 있지만 58및 64수 없습니다.

등고선 그리기 동작은 다음과 같이 정의됩니다. 모든 요소 e에 대해 다음과 같이 선택된 2 문자 문자열로 대체하십시오.

  • 첫 번째 문자는 " "아래의 요소가있는 경우 e와 같은 형상의 레벨에 e아래에 아무런 소자가 존재하지 않는 경우 나 e하고 "_", 그렇지
  • 두번째 글자는 " "오른쪽에있는 요소가있는 경우 e와 같은 형상의 레벨에 e또는 오른쪽에 어떤 요소가없는 e하고 "|", 그렇지

행 내의 요소가 함께 결합 된 다음 행이 개행과 함께 결합됩니다.

예

입력이 다음 [[5,20],[3,6]]과 같이 시각화되어 있다고 가정 해 봅시다.

5 20
3 6

먼저을 봅니다 5. 가와 3동일한 윤곽 수준 5에 있으므로 첫 번째 문자는 " "입니다. 가와 20같은 윤곽 수준에 있지 않기 때문에 5두 번째 문자는 "|"입니다.

이제 우리는을 봅니다 20. 가와 6같은 윤곽 수준에 있지 않기 때문에 20첫 번째 문자는 "_"입니다. 의 오른쪽에 요소가 없으므로 20두 번째 문자는 " "입니다.

이제 우리는을 봅니다 3. 아래 3에 요소가 없으므로 첫 번째 문자는 " "입니다. 가와 6동일한 윤곽 수준 3에 있으므로 두 번째 문자는 " "입니다.

이제 우리는을 봅니다 6. 아래 6에 요소가 없으므로 첫 번째 문자는 " "입니다. 의 오른쪽에 요소가 없으므로 6두 번째 문자는 " "입니다.

이 두 문자 문자열을 기반으로 get을 대체합니다 [[" |","_ "],[" "," "]]. 이것들을 합치면

 |_

규칙

  • 입력 행렬은 항상 직사각형이며 양의 정수로 구성됩니다.
  • 후행 공백이나 줄 바꿈은 임의의 양 (0 포함) 일 수 있으며 어떤 식 으로든 일관성을 가질 필요는 없습니다.
  • 동일한 결과를 생성하는 한 동일한 알고리즘을 따를 필요는 없습니다.
  • 프로그램이나 함수는 줄 바꾸기로 구분 된 문자열, 문자열 목록 또는 이와 동등한 것을 출력 할 수 있습니다.
  • 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

input
output

[[1,5,8,9],[3,11,13,8],[7,14,10,9],[4,8,7,6]]
  _ _  
 |   | 
 |_ _| 

[[0,10,20,30,40,50,60,70,80,90],[0,0,10,10,20,20,30,30,40,40],[0,0,0,10,10,10,20,20,20,30],[0,0,0,0,10,10,10,10,20,20],[0,0,0,0,0,10,10,10,10,10],[0,0,0,0,0,0,10,10,10,10],[0,0,0,0,0,0,0,10,10,10],[0,0,0,0,0,0,0,0,10,10],[0,0,0,0,0,0,0,0,0,10],[0,0,0,0,0,0,0,0,0,0]]
 |_|_|_|_|_|_|_|_|_
   |_  |_ _|_ _|_ _
     |_    |_ _  |_
       |_      |_ _
         |_        
           |_      
             |_    
               |_  
                 |_


[[5,5,5,5,5,5,5,5,5,5,5],[5,10,10,10,10,10,10,10,10,10,5],[5,10,15,15,15,15,15,15,15,10,5],[5,10,15,20,20,20,20,20,15,10,5],[5,10,15,20,25,25,25,20,15,10,5],[5,10,15,20,25,30,25,20,15,10,5],[5,10,15,20,25,25,25,20,15,10,5],[5,10,15,20,20,20,20,20,15,10,5],[5,10,15,15,15,15,15,15,15,10,5],[5,10,10,10,10,10,10,10,10,10,5],[5,5,5,5,5,5,5,5,5,5,5]]
  _ _ _ _ _ _ _ _ _  
 |                 | 
 |    _ _ _ _ _    | 
 |   |         |   | 
 |   |    _    |   | 
 |   |   |_|   |   | 
 |   |         |   | 
 |   |_ _ _ _ _|   | 
 |                 | 
 |_ _ _ _ _ _ _ _ _| 

[[35,32,29,26,25,25,25,26,29,32,35],[32,28,25,22,20,20,20,22,25,28,32],[29,25,21,18,15,15,15,18,21,25,29],[26,22,18,14,11,10,11,14,18,22,26],[25,20,15,11,7,5,7,11,15,20,25],[25,20,15,10,5,0,5,10,15,20,25],[25,20,15,11,7,5,7,11,15,20,25],[26,22,18,14,11,10,11,14,18,22,26],[29,25,21,18,15,15,15,18,21,25,29],[32,28,25,22,20,20,20,22,25,28,32],[35,32,29,26,25,25,25,26,29,32,35]]
  _|             |_  
_|    _ _ _ _ _    |_
    _|         |_    
   |    _ _ _    |   
   |   |     |   |   
   |   |     |   |   
   |   |_ _ _|   |   
   |_           _|   
_    |_ _ _ _ _|    _
 |_               _| 
   |             |
code-golf  ascii-art  matrix 
— 불길 241
소스
1
나는 이것이 얼마나 멋진 지 깨닫기 전에 이것을 읽기 시작하지도 않습니다
— Christopher

답변:

6

Perl 6 , 135 바이트 (131 자)

{my$n="_";sub w{$^a.chop-$^b.chop??$n!!" "};my&q={|.[1..*],.tail};(($_ «[&w]».&q) ZZ~{$n="|";$_ «[&w]».map(*.&q)}()).map:{say |$_}}

온라인으로 사용해보십시오!

약간 골퍼되지 않음 :

{
    my $n = "_";
    sub w { $^a.chop - $^b.chop ?? $n !! " "};
    my &q = {|.[1..*],.tail};
    (
        ($_ «[&w]».&q)
        ZZ~
        {$n="|";$_ «[&w]».map(*.&q)}()
    ).map:{say |$_}
}

설명 : 먼저 변수 $n(2 행)와 함수 w(3 행 )를 정의합니다 . 이 함수는 두 인수가 같은 "고도"에 있으면 공백을 반환하고 $n그렇지 않으면 변수의 내용을 반환합니다. 10으로 나누고 바닥 대신, 우리는 ints가 Cool(문자열처럼 취급 될 수 있음) 사실을 남용 chop하고 마지막 문자 (= 숫자)를 제거하는 데 사용 합니다. 그런 다음 침착하게 차감하여 다시 숫자로 강제합니다.

그 후 (행 4) 우리 q는 목록을 가져 와서 첫 번째 요소가 제거되고 마지막 요소가 복제 된 해당 목록을 반환 하는 함수 를 구성합니다 .

다음 3 선에, 우리는 입력 행렬에서 2 개 행렬을 만들려고하고 있습니다 : 첫 번째는없는 첫 번째 행을 가지고 있으며, 마지막 행은 사용자들은 (복제 .&q- 사용 .&이 인 것처럼, 당신은 아무것도에 함수를 호출 할 수 있습니다 메소드 – 점 앞에있는 것은 첫 번째 인수입니다), 다른 하나는 첫 번째 열이 누락되고 마지막 열이 복제 된 것입니다 (즉 .map(*.&q)).

먼저 (행 4) 우리는 원래의 행렬을 취하고 $_"이동 된 행"행렬과 함께 "오버레이" 하고 일치하는 요소 w에서 이진 연산자 (즉 ,)로 함수 를 사용합니다 [&w]. 그것은 _일치하는 요소가 다른 고도 의 어디에나, 다른 곳에 놓는다 . 따라서 결과의 1/2을 얻습니다 ( "첫 문자 만").

6 행에서 동일한 작업을 수행하지만 먼저로 변경 $n하고 |열이 이동 된 행렬로 원본 행렬을 "오버레이"합니다. 결과는 고도가 |다르고 동일합니다. 이들은 "두 번째 문자"입니다.

이제 우리는 그것들을 함께 결합합니다. 배열을 concat (yeah ...)이있는 zip으로 압축하면 각 요소가 연결된 "half-solutions"의 2 개의 일치 요소 인 원래 모양의 행렬이됩니다. 마지막으로이 행렬 (실제로 목록의 목록) 위에 매핑합니다. 이러한 각 목록은 병합 say된 후 -ed (줄 바꿈으로 인쇄 됨)됩니다. 이후 say인수의 수를 가지고 그것은 단지 마지막에 개행을, 구분없이 모두를 인쇄 할 수 있습니다, 우리는 표준 출력에서 원하는 사진을 얻을. (그리고 블록은 Trues 의 목록을 say반환 True하지만 (각각 하나를 반환 ) 누가 관심을 갖고 있는지)

— 라 밀리
소스
–1but who cares
— HyperNeutrino
5

젤리 ,  25 23  22 바이트

마일로I 인한 -1 바이트 ( 벡터화)

:⁵I;€0ao⁶
Zç”_Zż"ç”|$Y

결과를 인쇄하는 전체 프로그램. 모나드 링크는 숫자 목록, 표고를 가져 와서 목록 목록을 반환하지만이 "행"은 두 문자 "쌍"의 목록으로 구성됩니다.이 값이 양호하면을 제거하여 1 바이트를 저장할 수 있습니다 Y.

온라인으로 사용해보십시오!

방법?

:⁵I;€0ao⁶ - Link 1, assignCharacters (row-wise): list of lists of numbers; character, c
 ⁵        - literal 10
:         - integer division (vectorises)
  I       - incremental differences (vectorises) (zero if the same else non-zero)
     0    - literal 0
   ;€     - concatenate for €ach (rightmost edge of a row has no contour mark)
      a   - logical and (vectorises) with c (replace non-zeros with the contour character)
        ⁶ - literal space character
       o  - logical or (vectorises) (replace the zeros with spaces)

Zç”_Zż"ç”|$Y - Main link: list of lists of numbers, contours
Z            - transpose the input (get the columns)
  ”_         - literal underscore character, '_'
 ç           - call the last link (1) as a dyad with '_'
    Z        - transpose the result
          $  - last two links as a monad:
        ”|   -   literal pipe character, '|'
       ç     -   call the last link (1) as a dyad with '|'
      "      - zip with the dyadic operation:
     ż       -   zip (interleave the column-wise characters with the row-wise ones)
           Y - join with newlines
             - implicit print
— 조나단 앨런
소스
grr 3 바이트. +1 그러나 나는 너를 능가하려고 노력할 것이다;)
— HyperNeutrino
독립적 인 솔루션-방금 당신의 것이 매우 비슷하다는 것을 보았습니다! ⁵... 당신에게 하나 똑바로 저장
— 조나단 앨런
:⁵I;€0ao⁶메인 링크 대신 도우미의 조인에 각각을 사용하여 바이트를 저장할 수 있습니다Zç”_Zż"ç”|$Y
— 마일
@ 마일스 오 와우, 작동? 감사! 나는 I그렇게 벡터화하지 않을 것이라고 상상 했다.
— Jonathan Allan
그래는 I깊이 1에서 벡터화, 모두 a와 o깊이 0 벡터화
— 마일
3

젤리 , 24 바이트

:⁵IṠ;€0
ZÇZị⁾_ +³Ç¤ị⁾| ¤

온라인으로 사용해보십시오!

설명

:⁵IṠ;€0           Helper Link; get contour data
:                 Floor division by
 ⁵                10
  I               Compute increments
   Ṡ              Sign; ±1 for different values and 0 for same values
    ;             Append
      0           Zero
     €            To each row
ZÇZị⁾_ +³Ç¤ị⁾| ¤  Main Link
Z                 Zip the input (for vertical contours _)
 Ç                Get the contour data
  Z               Zip the data (because it's zipped from the first Z)
   ị              Index into the string
    ⁾_            "_ "
       +          Add (vectorizing twice) to
        ³ ¤    ¤  Nilad starting from (input)
         Ç        Get contour data (horizontal contours |)
           ị      Index into the string
            ⁾|    "| "

Jonathan Allan 덕분에 -2 바이트

— 하이퍼 뉴트리노
소스
귀하의 솔루션은 실제로 제거 할 수 있습니다 Y-문자 목록을 반환합니다.
— Jonathan Allan
@JonathanAllan 아 맞아 ... 고마워!
— HyperNeutrino
2

파이썬 2 , 226 바이트

l=[[j/10for j in i]for i in input()]
for i,j in enumerate(l[:-1]):print''.join('_ '[h==l[i+1][g]]+'| '[h==j[g+1]]for g,h in enumerate(j[:-1]))+'_ '[j[-1]==l[i+1][-1]]
print''.join(' '+'| '[i==j]for i,j in zip(l[-1],l[-1][1:]))

온라인으로 사용해보십시오!

휴, 그것은 논리를 해결하기 위해 두려운이었다. 이제 Hyper Neutrino ninja이 더 짧은 답변으로 나를 보았지만 게시 하지 않기 위해 너무 많은 노력을 기울였습니다 . :피

또한 이것은 ASCII 아트를 만드는 훌륭한 방법입니다. 내가 보트로드를 더 많이 만드는 동안 실례합니다.

— 완전히 인간적인
소스
> ninja'd : 친구 45 분이
— 지났습니다
그래, 나는 대답을 보지 못했다 ... : P
— 완전 인간
enumerate전체 이름을 두 번 사용하는 대신 변수를 정의하여 4 바이트를 절약 할 수 있습니다 .
— Jonathan Frech
218 바이트의 첫 번째 제거하여 enumerate(OBS, 내가 여기에 링크 할 수 있도록 몇 가지 입력을 제거했다)
— 펠리페 나르디 바티스타
2

J, 58 바이트

f=.{~0==/@]
[:(,/"2)2 2((' _'f{."1),' |'f{.);.3 1:+<.@%&10

온라인으로 사용해보십시오!

행렬을 취하여 윤곽선을 출력하는 익명 함수입니다.

개선의 여지가 여기 있습니다. 모든 테스트 사례를 시험해 볼 시간이 없었으므로 문제가 있는지 알려주십시오. 더 골프를 치고 나중에 설명하려고합니다.

(빠른) 설명

도우미 기능 : 2 길이 배열의 첫 번째 요소가 두 번째 요소와 같은지 여부에 따라 길이 2 문자열로 색인합니다. 같으면 0 번째 요소로 색인화되고, 같지 않으면 첫 번째 요소로 색인화됩니다. 1 길이의 배열은 항상 문자열의 0 번째 요소로 색인합니다.

f=.{~0==/@]

주요 기능

[:(,/"2)2 2((' _'f{."1),' |'f{.);.3 1:+<.@%&10

1:+<.@%&10 각 요소를 10으로 나누고 1을 더합니다 (따라서 0을 얻지 않음-도우미 기능에 중요합니다).

2 2((' _'f{."1),' |'f{.);.3가능한 경우 행렬을 2 x 2 세그먼트로 자르고 (그렇지 않으면 가장자리 근처에 2 x 1, 1 x 2 또는 1 x 1 세그먼트를 제공함) f왼쪽 상단 요소를 상단과 비교 하는 데 사용하는 함수를 적용합니다. 오른쪽 및 왼쪽 상단 요소를 왼쪽 하단으로

(,/"2)원하는 모양으로 결과를 평평하게합니다. 나는 이것을 사용하지 않아도 될 것 같은 느낌이 든다.

— 서양 평지
소스
2

자바 스크립트 (ES6) 120 118 바이트

a=>a.map(b=>b.map(c=>c/10|0)).map((b,i,a)=>b.map((c,j)=>((a[i+1]||0)[j]-c?'_':' ')+(b[j+1]-c?'|':' ')).join``).join`\n`

어디 \n리터럴 개행 문자를 나타냅니다. 편집 : @ Bálint 덕분에 2 바이트가 절약되었습니다.

f=
a=>a.map(b=>b.map(c=>c/10|0)).map((b,i,a)=>b.map((c,j)=>((a[i+1]||0)[j]-c?'_':' ')+(b[j+1]-c?'|':' ')).join``).join`
`
;[
[[5,20],[3,6]]
,
[[1,5,8,9],[3,11,13,8],[7,14,10,9],[4,8,7,6]]
,
[[0,10,20,30,40,50,60,70,80,90],[0,0,10,10,20,20,30,30,40,40],[0,0,0,10,10,10,20,20,20,30],[0,0,0,0,10,10,10,10,20,20],[0,0,0,0,0,10,10,10,10,10],[0,0,0,0,0,0,10,10,10,10],[0,0,0,0,0,0,0,10,10,10],[0,0,0,0,0,0,0,0,10,10],[0,0,0,0,0,0,0,0,0,10],[0,0,0,0,0,0,0,0,0,0]]
,
[[5,5,5,5,5,5,5,5,5,5,5],[5,10,10,10,10,10,10,10,10,10,5],[5,10,15,15,15,15,15,15,15,10,5],[5,10,15,20,20,20,20,20,15,10,5],[5,10,15,20,25,25,25,20,15,10,5],[5,10,15,20,25,30,25,20,15,10,5],[5,10,15,20,25,25,25,20,15,10,5],[5,10,15,20,20,20,20,20,15,10,5],[5,10,15,15,15,15,15,15,15,10,5],[5,10,10,10,10,10,10,10,10,10,5],[5,5,5,5,5,5,5,5,5,5,5]]
,
[[35,32,29,26,25,25,25,26,29,32,35],[32,28,25,22,20,20,20,22,25,28,32],[29,25,21,18,15,15,15,18,21,25,29],[26,22,18,14,11,10,11,14,18,22,26],[25,20,15,11,7,5,7,11,15,20,25],[25,20,15,10,5,0,5,10,15,20,25],[25,20,15,11,7,5,7,11,15,20,25],[26,22,18,14,11,10,11,14,18,22,26],[29,25,21,18,15,15,15,18,21,25,29],[32,28,25,22,20,20,20,22,25,28,32],[35,32,29,26,25,25,25,26,29,32,35]]
].forEach(a=>document.write(['<pre>','</pre>'].join(f(a))));
스 니펫 확장

— 닐
소스
(a[i] || [])[j]구조물을 다음과 같이 바꿀 수 있습니다(a[i] || 0)[j]
— Bálint
또한, 마지막에 join`\n`당신은 제거 할 수 \n부분과 실제 개행 문자로 교체
— 발린
114 바이트 :a=>a.map(b=>b.map(c=>c/10|0)).map((b,i,a)=>b.map((c,j)=>" _"[(a[i+1]||0)[j]-c&1]+" |"[b[j+1]-c&1]).join``).join`<new line here>`
— Bálint
@Balint Bah, 나는 그 \n부분을 잊어 버린다 . 리터럴 개행이 방해가 될 정도로 REPL에서 테스트합니다.
— Neil
@ Bálint 그러나 마지막 제안은 출력 목록에 추가 한 원래 예제에 실패합니다.
— Neil
1

양성자 , 202 바이트

R=(L=len)+range
k=[map((//)&10,r)for r:eval(input())]
d=(x,y,X,Y)=>X>=L(k)or Y>=L(k[X])or k[x][y]==k[X][Y]
print('\n'.join(map(''.join,[['_ '[d(x,y,x+1,y)]+'| '[d(x,y,x,y+1)]for y:R(k[x])]for x:R(k)])))

온라인으로 사용해보십시오!


Python 2 대신 Proton으로 전환 하여 Jonathan Frech -15 바이트 덕분에 -2 바이트

— 하이퍼 뉴트리노
소스
당신은 대체하여 2 바이트를 저장할 수 len와 L및 정의 L=len;.
— Jonathan Frech
1

자바 (8), 200 (170) 169 바이트

a->{String r="";for(int l=a.length,i=0,j;i<l;i++,r+="\n")for(j=0;j<l;r+=(i>l-2||a[i][j]/10==a[i+1][j]/10?" ":"_")+(j++>l-2||a[i][j-1]/10==a[i][j]/10?" ":"|"));return r;}

설명:

여기에서 시도하십시오.

Java의 정수 나누기는 자동으로 플로어입니다.

a->{                   // Method with 2D int-array as parameter and String return-type
  String r="";         //  Result-String
  for(int l=a.length,  //  Length of the input array
      i=0,j;           //  Index integers
      i<l;i++,         //  Loop (1) over the rows of the input array
          r+="\n")     //  and append a new-line to the result after every iteration
    for(j=0;j<l;       //   Inner loop (2) over the columns of a row
      r+=              //    Append the String with:
         (i>l-2        //      If it's the last row,
         ||a[i][j]/10==a[i+1][j]/10?
                       //      or the current and next rows are equal floored/10:
          " "          //       Use a space
         :             //      Else:
          "_")         //       Use a "_"
        +              //     Plus
         (j++>l-2      //      If it's the last column in the row,
         ||a[i][j-1]/10==a[i][j]/10?
                       //      or the current and next columns are equal floored/10:
          " "          //       Use a space
         :             //      Else:
          "|")         //       Use "|"
    );                 //   End of column loop (2)
                       //  End of row-loop (1) (implicit / single-line body)
  return r;            //  Return the result-String
}                      // End of method
— 케빈 크루이 센
소스
1

R, 159 바이트

f=function(m){M=m%/%10;a=cbind(0,t(apply(M,1,diff)));b=rbind(apply(M,2,diff),0);a[!!a]="|";b[!!b]="_";M[]=gsub("0"," ",paste0(a,b));write(t(M),"",ncol(m),,"")}

줄 바꿈과 들여 쓰기

f=function(m){
    M=m%/%10
    a=cbind(0,t(apply(M,1,diff))) #row-wise difference
    b=rbind(apply(M,2,diff),0) #column-wise difference
    a[!!a]="|"
    b[!!b]="_"
    M[]=gsub("0"," ",paste0(a,b)) # M[] is a trick to force the result to have the same structure as M
    write(t(M),"",ncol(m),,"")
    }

행렬의 정수 나눗셈, 측정 행 방향 및 열 방향으로 차이가 언제 교체하지 않는 NULL |및 _각각 다음 두 (무통은 R의 벡터화 덕분) 및 출력 페이스트.

테스트 사례 :

> m=matrix(c(0,10,20,30,40,50,60,70,80,90,0,0,10,10,20,20,30,30,40,40,0,0,0,10,10,10,20,20,20,30,0,0,0,0,10,10,10,10,20,20,0,0,0,0,0,10,10,10,10,10,0,0,0,0,0,0,10,10,10,10,0,0,0,0,0,0,0,10,10,10,0,0,0,0,0,0,0,0,10,10,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0),byrow=T,ncol=10)
> f(m)
  |_|_|_|_|_|_|_|_|_
    |_  |_ _|_ _|_ _
      |_    |_ _  |_
        |_      |_ _
          |_        
            |_      
              |_    
                |_  
                  |_

> m=matrix(c(5,5,5,5,5,5,5,5,5,5,5,5,10,10,10,10,10,10,10,10,10,5,5,10,15,15,15,15,15,15,15,10,5,5,10,15,20,20,20,20,20,15,10,5,5,10,15,20,25,25,25,20,15,10,5,5,10,15,20,25,30,25,20,15,10,5,5,10,15,20,25,25,25,20,15,10,5,5,10,15,20,20,20,20,20,15,10,5,5,10,15,15,15,15,15,15,15,10,5,5,10,10,10,10,10,10,10,10,10,5,5,5,5,5,5,5,5,5,5,5,5),byrow=T,ncol=11)
> f(m)
   _ _ _ _ _ _ _ _ _  
  |                 | 
  |    _ _ _ _ _    | 
  |   |         |   | 
  |   |    _    |   | 
  |   |   |_|   |   | 
  |   |         |   | 
  |   |_ _ _ _ _|   | 
  |                 | 
  |_ _ _ _ _ _ _ _ _|
— Plannapus
소스
0

펄 5 , 130 126 바이트

-ap플래그 의 경우 124 바이트의 코드 + 2

push@a,[map 0|$_/10,@F]}{map{say map{($a[$r+1][$c]-$_&&$r<$#a?'_':$").($a[$r][++$c]-$_&&$c<@{$a[0]}?'|':$")}@$_;$c=0;$r++}@a

온라인으로 사용해보십시오!

입력 형식은 공백으로 구분 된 숫자의 2 차원 격자입니다.

설명

이것은 코드의 이전 반복에서 나온 것입니다.

push@a,[map 0|$_/10,@F]     # read the input, divide it by 10, and store it in a 2-D array
}{                          # end the implicit while loop and start the final block
map{                        # repeat this for each line
  $_=($a[$r+1][$c]-$_&&$r<$#a?'_':$")       # set appropriate characters to output based
     .($a[$r][++$c]-$_&&$c<@{$a[0]}?'|':$") # on the given rules
  for@$_;                                   # repeat for each number on the line
  $c=0;$r++;                         # setup row and column counters for next iteration
  say@$_                             # output this line
}@a
— Xcali
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.