Cho một ma trận hình chữ nhật của độ cao, vẽ các đường viền của nó.

Bài tập

Hai yếu tố xvà ytrên cùng một mức đường viền nếu floor(x/10) == floor(y/10). Ví dụ, 52và 58ở cùng một mức đường viền, nhưng 58và 64không.

Hành động vẽ các đường viền được định nghĩa như sau: Đối với mọi phần tử e, thay thế nó bằng một chuỗi hai char được chọn như sau:

• ký tự đầu tiên là " "nếu phần tử bên dưới eở cùng mức đường viền với ehoặc nếu không có phần tử nào ở bên dưới evà "_"nếu không
• ký tự thứ hai là " "nếu phần tử ở bên phải eở cùng mức đường viền với ehoặc không có phần tử nào ở bên phải evà "|"nếu không

Các yếu tố trong các hàng được nối với nhau, sau đó các hàng được nối với nhau bằng các dòng mới.

Thí dụ

Giả sử đầu vào là [[5,20],[3,6]], được hình dung như

5 20
3 6

Trước tiên chúng tôi nhìn vào 5. Vì 3là trên cùng một đường viền như 5, ký tự đầu tiên là " ". Vì 20không ở cùng mức đường viền như 5, ký tự thứ hai là "|".

Bây giờ chúng tôi nhìn vào 20. Vì 6không ở cùng mức đường viền như 20, ký tự đầu tiên là "_". Vì không có yếu tố nào ở bên phải 20, nên ký tự thứ hai là " ".

Bây giờ chúng tôi nhìn vào 3. Vì không có yếu tố nào bên dưới 3, nên ký tự đầu tiên là " ". Vì 6ở cùng cấp độ đường viền với 3, ký tự thứ hai là " ".

Bây giờ chúng tôi nhìn vào 6. Vì không có yếu tố nào bên dưới 6, nên ký tự đầu tiên là " ". Vì không có yếu tố nào ở bên phải 6, nên ký tự thứ hai là " ".

Dựa trên các chuỗi hai char này, chúng tôi thực hiện thay thế để có được [[" |","_ "],[" "," "]]. Kết hợp những thứ này lại với nhau, chúng ta có được một đầu ra của

 |_ 
    

Quy tắc

• Ma trận đầu vào sẽ luôn là hình chữ nhật và bao gồm các số nguyên dương.
• Không gian lưu trữ hoặc dòng mới có thể ở bất kỳ số lượng nào (bao gồm 0) và không nhất quán theo bất kỳ cách nào.
• Bạn không phải tuân theo cùng một thuật toán miễn là bạn tạo ra kết quả tương tự.
• Chương trình hoặc chức năng của bạn có thể xuất ra một chuỗi phân tách dòng mới, danh sách các chuỗi hoặc tương đương.
• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

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

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

Perl 6 , 135 byte (131 ký tự)

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

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

Hơi vô dụng:

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

Giải thích : Đầu tiên, chúng tôi xác định một biến $n(dòng 2) và một hàm w(dòng 3). Hàm này trả về một khoảng trắng nếu hai đối số của nó có cùng "độ cao" và nội dung của biến $nkhác. Thay vì chia cho 10 và sàn, chúng ta lạm dụng thực tế là ints Cool(có thể được coi như chuỗi) và sử dụng chopđể loại bỏ ký tự cuối cùng (= chữ số). Sau đó, chúng tôi bình tĩnh trừ chúng, buộc chúng thành số một lần nữa:.

Sau đó (dòng 4), chúng ta tạo một hàm qlấy danh sách và trả về danh sách đó với phần tử đầu tiên được loại bỏ và phần tử cuối cùng được nhân đôi.

Trên 3 dòng tiếp theo, chúng tôi sẽ tạo thêm 2 ma trận từ ma trận đầu vào: hàng đầu tiên bị thiếu hàng đầu tiên và hàng cuối cùng được nhân đôi (đó là .&q- sử dụng .&, bạn có thể gọi một hàm trên bất cứ thứ gì như thể nó là một phương thức - điều ở phía trước dấu chấm sau đó là đối số đầu tiên), đối số khác có cột đầu tiên bị thiếu và cột cuối cùng được sao chép (đó .map(*.&q)).

Đầu tiên (dòng 4) chúng ta lấy ma trận gốc $_, "phủ" nó với ma trận "các hàng được dịch chuyển" và sử dụng hàm wnhư một toán tử nhị phân (đó là [&w]) trên các phần tử khớp. Cái đó đặt _bất cứ nơi nào các yếu tố phù hợp ở trên các độ cao khác nhau và mặt khác. Vì vậy, chúng tôi nhận được kết quả (chỉ "các ký tự đầu tiên").

Tại dòng 6, chúng tôi làm điều tương tự, nhưng sự thay đổi đầu tiên chúng ta $nđến |, và chúng tôi ngay bây giờ "overlay" ma trận ban đầu với ma trận với các cột thay đổi. Kết quả có một |khác nhau và ở cùng độ cao. Đây là những "nhân vật thứ hai".

Bây giờ chúng tôi chỉ cần kết hợp chúng lại với nhau. Chúng tôi nén các mảng bằng một zip với một concat (yeah ...), dẫn đến một ma trận có hình dạng ban đầu với mỗi phần tử là 2 phần tử khớp của "nửa giải pháp" được nối. Cuối cùng, chúng tôi chỉ ánh xạ qua ma trận này (đây thực sự là một danh sách các danh sách). Mỗi danh sách này được làm phẳng và sau đó say-ed (được in bằng một dòng mới). Vì saycó thể lấy bất kỳ số lượng đối số nào và nó in tất cả chúng mà không có dấu phân cách, làm cho dòng mới chỉ ở cuối, chúng tôi nhận được hình ảnh mong muốn trên thiết bị xuất chuẩn. (Và khối trả về một danh sách Trues (mỗi saytrả về một True), nhưng ai quan tâm.)

Thạch ,  25 23  22 byte

-1 byte nhờ dặm ( Ivectorises)

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

Một chương trình đầy đủ in kết quả. Là một liên kết đơn, nó lấy một danh sách các danh sách các số, độ cao và trả về một danh sách danh sách, tuy nhiên các "hàng" này bao gồm danh sách hai "cặp" ký tự - nếu điều này tốt thì có thể lưu 1 byte bằng cách xóa Y.

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

Làm sao?

:⁵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

Python 2 , 199 186 157 155 byte

lambda a:(lambda x:'\n'.join(''.join('_ '[x==z]+'| '[x==y]for x,y,z in zip(r,r[1:]+r[-1:],q))for r,q in zip(x,x[1:]+x[-1:])))([[v/10for v in r]for r in a])

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

Thạch , 24 byte

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

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

Giải trình

:⁵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
            ⁾|    "| "

-2 byte nhờ Jonathan Allan

Python 2 , 226 byte

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

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

Whew, đó là một doozy để làm việc logic. Bây giờ tôi thấy Hyper Neutrino ninja muốn tôi trả lời ngắn hơn nhưng tôi đã dành quá nhiều công sức cho việc này để không đăng nó. : P

Ngoài ra, tôi có thể nói, đây là một cách tuyệt vời để tạo ra ASCII-art. Xin lỗi cho tôi trong khi tôi thực hiện một tải thuyền nhiều hơn trong số này.

J, 58 byte

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

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

Một hàm ẩn danh có một ma trận và xuất ra các đường viền.

Lotta phòng để cải thiện ở đây. Tôi không có thời gian để thử tất cả các trường hợp thử nghiệm vì vậy hãy cho tôi biết nếu có bất kỳ vấn đề nào. Sẽ cố gắng để chơi golf nhiều hơn và giải thích sau.

(Nhanh) Giải thích

Hàm trợ giúp: lập chỉ mục thành một chuỗi có độ dài 2 dựa trên việc phần tử đầu tiên của mảng 2 có bằng chuỗi thứ hai hay không. Nếu nó bằng nhau, nó lập chỉ mục vào phần tử zeroth, nếu nó không bằng nhau, nó lập chỉ mục vào phần đầu tiên. Mảng 1 chiều dài luôn lập chỉ mục vào phần tử zeroth của chuỗi.

f=.{~0==/@]

Chức năng chính

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

1:+<.@%&10 tầng mỗi phần tử chia cho 10 và thêm 1 (vì vậy chúng tôi sẽ không bao giờ nhận được 0 - điều này rất quan trọng đối với chức năng của trình trợ giúp).

2 2((' _'f{."1),' |'f{.);.3cắt ma trận thành 2 x 2 phân đoạn nếu có thể (nếu không, nó sẽ đưa ra phân đoạn 2 x 1, 1 x 2 hoặc 1 x 1 gần các cạnh) và áp dụng hàm sử dụng fđể so sánh phần tử trên cùng bên trái với đỉnh bên phải và phần tử trên cùng bên trái ở dưới cùng bên trái.

(,/"2)làm phẳng kết quả thành hình dạng mong muốn. Tôi thực sự cảm thấy mình có thể tránh được việc phải sử dụng thứ này (và rất nhiều thứ khác, nhưng tôi lạc đề).

J , 46 45 byte

' _|'({~];"1@(,&.>-@|:)&(0,~}.~:}:)|:)<.@%&10

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

JavaScript (ES6), 120 118 byte

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`

Trường hợp \nđại diện cho nhân vật dòng chữ mới. Chỉnh sửa: Đã lưu 2 byte nhờ @ Bálint.

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

Proton , 202 byte

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

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

-2 byte nhờ Jonathan Frech
-15 byte bằng cách chuyển sang Proton thay vì Python 2

Java 8, 200 170 169 byte

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

Giải trình:

Hãy thử nó ở đây.

Lưu ý rằng phân chia số nguyên trong Java sàn tự động.

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

R, 159 byte

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),,"")}

Với dòng mới và thụt lề:

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),,"")
    }

Việc phân chia số nguyên của ma trận, đo lường sự khác biệt giữa hàng và cột, và khi không thay thế bằng |và _tương ứng, sau đó dán cả hai (không đau, nhờ vào vector hóa của R) và đầu ra.

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

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

Perl 5 , 130 126 byte

124 byte mã + 2 cho -apcờ

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

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

Định dạng đầu vào là lưới 2 chiều của các số được phân tách bằng dấu cách.

Giải trình

Đây là từ một lần lặp trước của mã.

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