Dikdörtgen bir yükseklik matrisi verildiğinde kontürlerini çizin.

Görev

İki eleman xve yaynı kontür seviyesinde ise floor(x/10) == floor(y/10). Örneğin, 52ve 58aynı kontur düzeyde olmakla 58ve 64değillerdir.

Kontur çizme eylemi şu şekilde tanımlanır: Her eleman için e, aşağıdaki gibi seçilen iki karakterli bir dize ile değiştirin:

• ilk karakter, " "eğer aşağıdaki element eaynı kontur seviyesindeyse eveya aşağıdan element yoksa eve"_"
• İkinci karakter " "sağındaki elemanı eğer eaynı kontur düzeyde olduğunu eveya sağında hiçbir unsur yoktur eve "|"başka türlü

Satırlar içindeki öğeler birleştirilir, ardından satırlar yeni satırlarla birleştirilir.

Örnek

Diyelim ki girdi şu şekilde [[5,20],[3,6]]görselleştirildi:

5 20
3 6

Önce biz bakarız 5. Yana 3aynı kontur düzeyde olduğunu 5, ilk karakterdir " ". Çünkü ikinci karakter 20aynı kontur seviyesinde olmadığı için .5"|"

Şimdi bakıyoruz 20. Yana 6aynı kontur düzeyde değil 20, ilk karakterdir "_". Sağında hiçbir element olmadığı için 20, ikinci karakter " ".

Şimdi bakıyoruz 3. Aşağıda hiçbir element olmadığı 3için ilk karakter " ". Çünkü ikinci karakter 6aynı kontur seviyesinde olduğu 3için " ".

Şimdi bakıyoruz 6. Aşağıda hiçbir element olmadığı 6için ilk karakter " ". Sağında hiçbir element olmadığı için 6, ikinci karakter " ".

Bu iki karakterli dizgelere dayanarak almak için değiştirmeler yaparız [[" |","_ "],[" "," "]]. Bunları bir araya getirdikten sonra, bir çıktısı alıyoruz.

 |_ 
    

kurallar

• Giriş matrisi her zaman dikdörtgen olacak ve pozitif tamsayılardan oluşacaktır.
• Sondaki boşluklar veya yeni satırlar herhangi bir miktarda (0 dahil) olabilir ve hiçbir şekilde tutarlı olması gerekmez.
• Aynı sonuçları ürettiğiniz sürece aynı algoritmayı izlemeniz gerekmez.
• Programınız veya işleviniz yeni satırlarla ayrılmış bir dizge, dizeler listesi veya eşdeğer bir çıktı verebilir.
• Bu kod golf , bayt cinsinden en kısa kod kazanır.

Test Kılıfları

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 bayt (131 karakter)

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

Çevrimiçi deneyin!

Biraz ungolfed:

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

Açıklama : İlk önce, bir değişken $n(satır 2) ve bir işlev w(satır 3) tanımlarız . İki argüman aynı "yükseklik" de ise, ve değişken değişken içeriği ise bu işlev bir boşluk döndürür $n. 10'a bölmek ve döşemeyi yapmak yerine, ints'in Cool( chopkarakter gibi işlenebilir) olması ve son karakteri (= rakam) kaldırmak için kullanılması gerçeğini kötüye kullanıyoruz . Sonra sakince çıkardık, tekrar sayılara zorluyoruz: --).

Ondan sonra (satır 4) qbir listeyi alan ve bu listeyi ilk eleman kaldırılmış ve son eleman kopyalanmış olarak döndüren bir fonksiyon oluştururuz.

Sonraki 3 satırda giriş matrisinden 2 matris daha yapacağız: birincisi ilk satır eksik ve son satır çoğaltılmış (bu sadece .&q- kullanarak .&, sanki herhangi bir şey üzerinde bir işlev çağırabilirsiniz) Bir yöntem - noktanın önündeki şey o zaman ilk argümandır), diğeri ilk sütunu eksik ve son sütunu çoğaltmıştır (bu .map(*.&q)).

İlk önce (satır 4) orijinal matrisi alırız $_, "kaydırılan satırlar" matrisiyle "bindirir" ve fonksiyonu eşleşen elemanlar üzerinde wikili bir operatör olarak kullanırız (budur [&w]). Bu _, eşleşen öğelerin farklı yüksekliklerde olduğu bir yere koyar ve bir başka. Böylece sonucu ½ ​​alırız (yalnızca "ilk karakterler").

Hat 6, biz aynı şeyi, ama önce değişiklik $niçin |, ve şimdi "bindirme" kaymıştır sütunlu matris ile orijinal matris. Sonuç |farklı ve aynı yüksekliklerdedir. Bunlar "ikinci karakterler".

Şimdi sadece onları birleştiriyoruz. Dizileri, her biri birleştirilmiş "yarım çözeltilerin" 2 eşleşen elemanı olan orijinal şeklin bir matrisiyle sonuçlanan, bir concat (evet ...) olan bir fermuarla sıkıştırırız. Son olarak, sadece bu matrisin haritasını çıkardık (bu gerçekten bir liste listesi). Bu listelerin her biri düzleştirilir ve ardından say-ed (yeni bir satırla basılır). Yana sayherhangi bir sayıda argüman alabilir ve sadece sonunda yeni satır yapım ayırıcı olmayan hepsini yazdırır, biz stdout'ta istenilen resmi olsun. (Ve blok bir Trues listesi döndürür (her biri bir saydöner True), ama kimin umrunda.)

Jöle ,  25 23  22 bayt

-1 byte sayesinde mil ( Ivectorises)

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

Sonucu basan tam bir program. Bir monadik bağlantı olarak, bir sayı listesi, yükseltmeler ve bir liste listesi alır, ancak bu "sıralar" iki karakterli "çift" listelerinden oluşur - eğer uygunsa 1 byte çıkarılarak kaydedilebilir Y.

Çevrimiçi deneyin!

Nasıl?

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

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

Çevrimiçi deneyin!

Jöle , 24 bayt

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

Çevrimiçi deneyin!

açıklama

:⁵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 sayesinde -2 bayt

Python 2,226 bayt

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

Çevrimiçi deneyin!

Whew, bu mantığı çözmek için bir doozydi. Şimdi Hiper Nötrino daha kısa cevap beni ninja'd ama bu konuda çok fazla çalışma harcanan bkz değil yayınlayabilirsiniz. : P

Ayrıca, şunu söyleyebilir miyim, bu ASCII sanatını yapmanın harika bir yoludur. Bunları daha fazla yüklerken, afedersiniz.

J, 58 bayt

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

Çevrimiçi deneyin!

Bir matris alan ve konturları çıkaran isimsiz bir işlev.

Burada iyileştirme için Lotta odası. Tüm test durumlarını denemek için zamanım olmadı, bu yüzden herhangi bir sorun olursa bana bildirin. Daha çok golf oynayıp daha sonra açıklayacağım.

(Hızlı) Açıklama

Yardımcı fonksiyon: 2 uzunluklu bir dizinin birinci elemanının ikinciye eşit olup olmamasına bağlı olarak bir uzunluk 2 dizgisine indeksler. Eşitse, sıfırıncı öğeye endekslenir, eşit değilse, ilkine endekslenir. 1 uzunluklu bir dizi her zaman dizenin sıfırıncı öğesine dizine eklenir.

f=.{~0==/@]

Ana işlev

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

1:+<.@%&10 her elemanın 10'a bölünmesi ve 1 eklenmesi (bu yüzden asla 0 alamayacağız - bu yardımcı fonksiyon için önemlidir).

2 2((' _'f{."1),' |'f{.);.3eğer mümkün ise matrisi 2 x 2 segmente böler (aksi takdirde kenarların yanında 2 x 1, 1 x 2 veya 1 x 1 segment verir) ve fsol üst elemanı üst ile karşılaştırmak için kullanılan işlevi uygular sağ ve sol üst eleman sol alt.

(,/"2)sonucu istenen şekilde düzleştirir. Bunu kullanmak zorunda kalmaktan kaçınmam gerektiğini (ve daha birçok şeyi yapmaktan kaçınmam gerektiğini) düşünüyorum.

J , 46 45 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 120 118 bayt

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`

Nerede \nliteral satır karakteri temsil eder. Düzenleme: @ Bálint sayesinde 2 bayt kaydedildi.

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 bayt

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

Çevrimiçi deneyin!

Python 2 yerine Proton'a geçerek Jonathan Frech -15 bayt sayesinde -2 bayt

Java 8, 200 170 169 bayt

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

Açıklama:

Burada dene.

Java’daki tamsayı bölmesinin otomatik olarak katlandığını unutmayın.

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 bayt

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

Yeni satırlarla ve girintilerle:

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

Matrisin tamsayı bölümü, satır bilgili ve sütun biçimindeki farklılıkları ölçer ve null |ve _sırasıyla boş olmadığında , her ikisini de (R'nin vektörelleştirilmesi sayesinde ağrısız) yapıştırır ve çıktılar.

Test durumları:

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

-apBayraklar için 124 baytlık kod + 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

Çevrimiçi deneyin!

Giriş formatı 2 boyutlu boşluk ayrılmış sayılar ızgarasıdır.

açıklama

Bu, kodun önceki bir yinelemesinden kaynaklanıyor.

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