Zeichnen Sie die Konturen einer rechteckigen Erhebungsmatrix.

Aufgabe

Zwei Elemente xund ybefinden sich auf derselben Konturebene, wenn floor(x/10) == floor(y/10). Zum Beispiel 52und 58befinden sich auf derselben Konturebene, aber 58und 64nicht.

Das Zeichnen von Konturen wird wie folgt definiert: eErsetzen Sie jedes Element durch eine Zeichenfolge mit zwei Zeichen, die wie folgt ausgewählt wird:

• Das erste Zeichen ist, " "wenn sich das Element darunter eauf derselben Konturebene befindet wie eoder wenn sich kein Element darunter befindet, eund "_"ansonsten
• das zweite Zeichen ist , " "wenn das Element auf der rechten Seite der eauf der gleichen Konturebene ist wie eoder es ist kein Element auf der rechten eund "|"sonst

Die Elemente innerhalb der Zeilen werden zusammengefügt, dann werden die Zeilen mit Zeilenumbrüchen zusammengefügt.

Beispiel

Nehmen wir an, die Eingabe wird [[5,20],[3,6]]visualisiert als

5 20
3 6

Wir schauen uns zuerst an 5. Da 3sich auf derselben Konturebene wie befindet 5, ist das erste Zeichen " ". Da 20sich nicht auf derselben Konturebene wie befindet 5, ist das zweite Zeichen "|".

Nun schauen wir uns an 20. Da 6sich nicht auf derselben Konturebene wie befindet 20, ist das erste Zeichen "_". Da rechts von kein Element vorhanden ist 20, ist das zweite Zeichen " ".

Nun schauen wir uns an 3. Da es unten kein Element gibt, ist 3das erste Zeichen " ". Da 6sich auf derselben Konturebene wie befindet 3, ist das zweite Zeichen " ".

Nun schauen wir uns an 6. Da es unten kein Element gibt, ist 6das erste Zeichen " ". Da rechts von kein Element vorhanden ist 6, ist das zweite Zeichen " ".

Basierend auf diesen zwei Zeichenfolgen machen wir Ersatz, um zu bekommen [[" |","_ "],[" "," "]]. Wenn wir diese zusammenfügen, erhalten wir eine Ausgabe von

 |_ 
    

Regeln

• Die Eingabematrix ist immer rechteckig und besteht aus positiven ganzen Zahlen.
• Nachgestellte Leerzeichen oder Zeilenumbrüche können beliebig sein (einschließlich 0) und müssen in keiner Weise konsistent sein.
• Sie müssen nicht denselben Algorithmus anwenden, solange Sie dieselben Ergebnisse erzielen.
• Ihr Programm oder Ihre Funktion gibt möglicherweise eine durch Zeilenumbrüche getrennte Zeichenfolge, eine Liste von Zeichenfolgen oder eine Entsprechung aus.
• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Testfälle

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 Bytes (131 Zeichen)

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

Probieren Sie es online!

Leicht ungolfed:

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

Erklärung : Zuerst definieren wir eine Variable $n(Zeile 2) und eine Funktion w(Zeile 3). Diese Funktion gibt ein Leerzeichen zurück, wenn sich die beiden Argumente auf derselben "Höhe" befinden, und $nansonsten den Inhalt der Variablen . Anstatt durch 10 und Flooring zu teilen, missbrauchen wir die Tatsache, dass ints Coolwie Strings behandelt werden und verwenden chop, um das letzte Zeichen (= Ziffer) zu entfernen. Dann subtrahieren wir sie ruhig und zwingen sie erneut zu Zahlen: -).

Danach (Zeile 4) erstellen wir eine Funktion q, die eine Liste aufnimmt und diese Liste zurückgibt, wobei das erste Element entfernt und das letzte Element dupliziert wird.

Auf den nächsten drei Zeilen werden wir zwei weitere Matrizen aus der Eingangsmatrix machen: die erste hat die erste Zeile fehlt und die letzte Zeile dupliziert (die gerade ist .&q- mit .&, können Sie eine Funktion auf etwas rufen , als ob es eine Methode - das Ding vor dem Punkt ist dann das erste Argument), bei der anderen fehlt die erste Spalte und die letzte Spalte ist doppelt vorhanden (das ist .map(*.&q)).

Zuerst (Zeile 4) nehmen wir die ursprüngliche Matrix $_, "überlagern" sie mit der Matrix "verschobene Zeilen" und verwenden die Funktion wals binären Operator (das ist der [&w]) für die übereinstimmenden Elemente. Dieser setzt ein, _wo immer sich die passenden Elemente auf den verschiedenen Höhen befinden, und ein anderes. Wir erhalten also die Hälfte des Ergebnisses (nur die "ersten Zeichen").

In Zeile 6 machen wir dasselbe, aber zuerst wechseln wir $nzu |und "überlagern" nun die ursprüngliche Matrix mit der Matrix mit verschobenen Spalten. Das Ergebnis hat eine |unterschiedliche und die gleiche Höhe. Dies sind die "zweiten Zeichen".

Jetzt kombinieren wir sie einfach miteinander. Wir zippen die Arrays mit einem Zip mit einem Concat (yeah ...), was zu einer Matrix der ursprünglichen Form führt, deren jedes Element die 2 übereinstimmenden Elemente der verketteten "Halblösungen" sind. Schließlich ordnen wir nur diese Matrix zu (die wirklich eine Liste von Listen ist). Jede dieser Listen wird abgeflacht und dann saymit einem Zeilenumbruch versehen. Da saybeliebig viele Argumente verwendet werden können und alle ohne Trennzeichen gedruckt werden, wird die neue Zeile erst am Ende eingefügt, und das gewünschte Bild wird auf stdout ausgegeben. (Und der Block gibt eine Liste von Trues zurück (jeder saygibt eine zurück True), aber wen interessiert das?)

Jelly ,  25 23  22 Bytes

-1 Byte dank Meilen ( IVektorisierungen)

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

Ein volles Programm druckt das Ergebnis aus. Als monadischer Link nimmt er eine Liste von Nummernlisten, die Höhen und gibt Listenlisten zurück. Diese "Zeilen" bestehen jedoch aus Listen mit zwei "Zeichenpaaren" - wenn dies in Ordnung ist, kann 1 Byte durch Entfernen gespeichert werden Y.

Probieren Sie es online!

Wie?

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

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

Probieren Sie es online!

Gelee , 24 Bytes

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

Probieren Sie es online!

Erläuterung

:⁵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 Bytes dank Jonathan Allan

Python 2 , 226 Bytes

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

Probieren Sie es online!

Puh, das war ein Trottel, um die Logik herauszufinden. Ich sehe jetzt Hyper-Neutrino-Ninja mit einer kürzeren Antwort, aber ich habe zu viel daran gearbeitet, um es nicht zu posten. : P

Ich kann auch sagen, dass dies eine großartige Möglichkeit ist, ASCII-Kunst zu erstellen. Entschuldigen Sie, während ich mehr davon herstelle.

J, 58 Bytes

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

Probieren Sie es online!

Eine anonyme Funktion, die eine Matrix verwendet und die Konturen ausgibt.

Hier gibt es viel Raum für Verbesserungen. Ich hatte keine Zeit, alle Testfälle zu testen. Lassen Sie mich wissen, wenn es Probleme gibt. Werde versuchen mehr zu golfen und später erklären.

(Schnelle) Erklärung

Hilfsfunktion: Indiziert eine Zeichenfolge der Länge 2 basierend darauf, ob das erste Element eines Arrays der Länge 2 gleich dem zweiten ist. Wenn es gleich ist, indiziert es in das nullte Element, wenn es ungleich ist, indiziert es in das erste. Ein Array mit einer Länge von 1 indiziert immer das nullte Element der Zeichenfolge.

f=.{~0==/@]

Hauptfunktion

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

1:+<.@%&10 Fußböden jedes Element durch 10 geteilt und addiert 1 (so werden wir nie 0 bekommen - dies ist wichtig für die Hilfsfunktion).

2 2((' _'f{."1),' |'f{.);.3Schneidet die Matrix in 2 x 2 Segmente, wenn dies möglich ist (andernfalls wird in der Nähe der Kanten ein 2 x 1, 1 x 2 oder 1 x 1 Segment erstellt) und wendet die Funktion an, mit fder das linke obere Element mit dem oberen Element verglichen wird rechts und das obere linke Element links unten.

(,/"2)verflacht das ergebnis in die gewünschte form. Ich habe wirklich das Gefühl, ich sollte es vermeiden können, dies zu benutzen (und viele andere Dinge, aber ich schweife ab).

J , 46-45 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 120 bis 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`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. Bearbeiten: 2 Bytes dank @ Bálint gespeichert.

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 Bytes

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

Probieren Sie es online!

-2 Bytes dank Jonathan Frech
-15 Bytes durch Umstellung auf Proton anstelle von Python 2

Java 8, 200 170 169 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

Beachten Sie, dass die Ganzzahldivision in Java automatisch Fußböden bildet.

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 Bytes

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

Mit Zeilenumbrüchen und Einrückungen:

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

Misst die Ganzzahldivision der Matrix die zeilenweisen und spaltenweisen Unterschiede und ersetzt sie, wenn sie nicht null ist, durch |und_ jeweils dann fügen beide (schmerzlos dank R Vektorisierung) und Ausgänge.

Testfälle:

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

124 Byte Code + 2 für -apFlags

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

Probieren Sie es online!

Das Eingabeformat ist ein 2-D-Raster mit durch Leerzeichen getrennten Zahlen.

Erläuterung

Dies ist aus einer früheren Iteration des Codes.

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