Biorąc pod uwagę prostokątną matrycę elewacji, narysuj jej kontury.

Zadanie

Dwa elementy xi ysą na tym samym poziomie konturu, jeśli floor(x/10) == floor(y/10). Na przykład, 52i 58są na tym samym poziomie konturu, ale 58i 64nie są.

Czynność rysowania konturów jest zdefiniowana w następujący sposób: Dla każdego elementu ezamień go na ciąg dwóch znaków wybrany w następujący sposób:

• pierwszy znak ma miejsce, " "gdy element poniżej eznajduje się na tym samym poziomie konturu co elub jeśli nie ma elementu elementu poniżej ei "_"inaczej
• drugi znak występuje, " "gdy element po prawej stronie eznajduje się na tym samym poziomie konturu, co enie, lub element nie jest po prawej stronie, ea "|"poza tym

Elementy w rzędach są łączone ze sobą, a następnie wiersze są łączone z nowymi liniami.

Przykład

Powiedzmy, że dane wejściowe są [[5,20],[3,6]]wizualizowane jako

5 20
3 6

Najpierw patrzymy na 5. Ponieważ 3jest na tym samym poziomie konturu co 5, pierwsza postać to " ". Ponieważ 20nie jest na tym samym poziomie konturu co 5, druga postać to "|".

Teraz patrzymy na 20. Ponieważ 6nie jest na tym samym poziomie konturu co 20, pierwsza postać to "_". Ponieważ po prawej stronie nie ma elementu 20, drugą postacią jest " ".

Teraz patrzymy na 3. Ponieważ poniżej nie ma elementu 3, pierwszą postacią jest " ". Ponieważ 6jest na tym samym poziomie konturu co 3, druga postać to " ".

Teraz patrzymy na 6. Ponieważ poniżej nie ma elementu 6, pierwszą postacią jest " ". Ponieważ po prawej stronie nie ma elementu 6, drugą postacią jest" " .

W oparciu o te łańcuchy dwuznakowe dokonujemy zamiany, aby uzyskać [[" |","_ "],[" "," "]]. Łącząc je razem, otrzymujemy wynik

 |_ 
    

Zasady

• Matryca wejściowa zawsze będzie prostokątna i złożona z dodatnich liczb całkowitych.
• Końcowe spacje lub znaki nowej linii mogą być w dowolnej ilości (w tym 0) i nie muszą być w żaden sposób spójne.
• Nie musisz postępować zgodnie z tym samym algorytmem, o ile generujesz takie same wyniki.
• Twój program lub funkcja może wyświetlać ciąg rozdzielony znakiem nowej linii, listę ciągów lub równoważny.
• To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.

Przypadki testowe

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 bajtów (131 znaków)

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

Wypróbuj online!

Nieznacznie nie golfista:

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

Objaśnienie : Najpierw definiujemy zmienną $n(wiersz 2) i funkcję w(wiersz 3). Ta funkcja zwraca spację, jeśli jej dwa argumenty mają tę samą „rzędną”, a zawartość zmiennej w $nprzeciwnym razie. Zamiast dzielić przez 10 i podłogę, nadużywamy faktu, że ints są Cool(mogą być traktowane jak łańcuchy) i używamy chopdo usunięcia ostatniego znaku (= cyfra). Następnie spokojnie odejmujemy je, zmuszając ponownie do liczb :—).

Następnie (wiersz 4) tworzymy funkcję, qktóra pobiera listę i zwraca tę listę z usuniętym pierwszym elementem i zduplikowanym ostatnim elementem.

W następnych 3 wierszach utworzymy jeszcze 2 macierze z macierzy wejściowej: w pierwszym brakuje pierwszego wiersza, a ostatni wiersz jest zduplikowany (to po prostu .&q- używając .&, możesz wywołać funkcję na czymkolwiek tak, jakby była metoda - rzecz przed kropką jest wtedy pierwszym argumentem), w drugiej brakuje pierwszej kolumny, a ostatnia kolumna jest zduplikowana (to jest .map(*.&q)).

Najpierw (wiersz 4) bierzemy oryginalną macierz $_, „nakładamy” ją na macierz „przesuniętych wierszy” i używamy funkcji wjako operatora binarnego (to jest to[&w] ) na pasujących elementach. Ten umieszcza _wszędzie tam, gdzie pasujące elementy znajdują się na różnych wysokościach, i inaczej. Otrzymujemy ½ wyniku (tylko „pierwsze znaki”).

W linii 6 robimy to samo, ale najpierw zmieniamy $nna| i teraz „nakładamy” oryginalną macierz na macierz ze przesuniętymi kolumnami. Wynik ma |różne i te same wysokości. Są to „drugie znaki”.

Teraz po prostu je łączymy. Układamy tablice za pomocą zamka błyskawicznego z concat (tak ...), co powoduje powstanie matrycy o oryginalnym kształcie, której każdy element jest 2 dopasowanymi elementami połączonych „pół-rozwiązań”. Na koniec po prostu mapujemy tę macierz (która jest tak naprawdę listą list). Każda z tych list jest spłaszczona, a następnie saydodana (wydrukowana z nową linią). Ponieważ saymoże przyjąć dowolną liczbę argumentów i drukuje je wszystkie bez separatorów, dzięki czemu nowy wiersz jest tylko na końcu, otrzymujemy pożądany obraz na standardowym wyjściu. (I blok zwraca listę Trues (każdy sayzwraca jeden True), ale kogo to obchodzi.)

Galaretka ,  25 23  22 bajtów

-1 bajt dzięki mil ( Ivectorises)

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

Pełny program drukujący wynik. Jako łącze monadyczne pobiera listę liczb, elewacji i zwraca listę list, jednak te „wiersze” składają się z list dwóch „par” znaków - jeśli jest w porządku, można usunąć 1 bajt przez usunięcie Y.

Wypróbuj online!

W jaki sposób?

:⁵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 bajtów

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

Wypróbuj online!

Galaretka , 24 bajty

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

Wypróbuj online!

Wyjaśnienie

:⁵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 bajty dzięki Jonathanowi Allanowi

Python 2 , 226 bajtów

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

Wypróbuj online!

Uff, to było logiczne. Teraz widzę ninja Hyper Neutrino z krótszą odpowiedzią, ale poświęciłem temu zbyt wiele pracy, żeby tego nie opublikować. : P

Mogę też powiedzieć, że jest to niesamowity sposób na tworzenie ASCII-art. Przepraszam, gdy robię ich więcej.

J, 58 bajtów

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

Wypróbuj online!

Anonimowa funkcja, która pobiera macierz i generuje kontury.

Tutaj jest dużo miejsca na ulepszenia. Nie miałem czasu na wypróbowanie wszystkich przypadków testowych, więc daj mi znać, jeśli są jakieś problemy. Spróbuję golfa więcej i wyjaśnię później.

(Szybkie) Objaśnienie

Funkcja pomocnicza: indeksuje do łańcucha długości 2 na podstawie tego, czy pierwszy element tablicy o długości 2 jest równy drugiemu. Jeśli jest równy, indeksuje do elementu zerowego, jeśli jest nierówny, indeksuje do pierwszego. Tablica o długości 1 indeksuje zawsze do elementu zerowego ciągu.

f=.{~0==/@]

Główna funkcja

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

1:+<.@%&10 podłogi każdy element podzielony przez 10 i dodaje 1 (więc nigdy nie otrzymamy 0 - jest to ważne dla funkcji pomocnika).

2 2((' _'f{."1),' |'f{.);.3 tnie matrycę na 2 x 2 segmenty, jeśli to możliwe (w przeciwnym razie da 2 x 1, 1 x 2 lub 1 x 1 segment w pobliżu krawędzi) i zastosuje funkcję, która używa f do porównania lewego górnego elementu do góry prawy i lewy górny element na lewym dolnym rogu.

(,/"2)spłaszcza wynik do pożądanego kształtu. Naprawdę czuję, że powinienem być w stanie uniknąć konieczności korzystania z tego (i wielu innych rzeczy, ale dygresuję).

J , 46 45 bajtów

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

Wypróbuj online!

JavaScript (ES6), 120 118 bajtów

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`

Gdzie \nreprezentuje dosłowny znak nowej linii. Edycja: Zapisano 2 bajty dzięki @ 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 bajty

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

Wypróbuj online!

-2 bajty dzięki Jonathanowi Frechowi
-15 bajtów poprzez przejście na Proton zamiast Python 2

Java 8, 200 170 169 bajtów

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

Wyjaśnienie:

Wypróbuj tutaj.

Należy pamiętać, że podział liczb całkowitych w Javie automatycznie podłogi.

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 bajtów

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

Z nowymi liniami i wcięciami:

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

Ma podział całkowitej matrycy, mierzy się różnice w rzędach i Kolumnowa, a gdy nie jest pusta zastąpić |i_ odpowiednio , a następnie wkleja zarówno (bezbolesne, dzięki wektoryzacji R), jak i wyniki.

Przypadki testowe:

> 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 bajtów

124 bajty kodu + 2 dla -apflag

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

Wypróbuj online!

Format wejściowy to siatka 2-D liczb oddzielonych spacjami.

Wyjaśnienie

Wynika to z poprzedniej iteracji kodu.

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