ऊंचाई के एक आयताकार मैट्रिक्स को देखते हुए, इसके समोच्च आकर्षित करें।

कार्य

दो तत्व xऔर yएक ही समोच्च स्तर पर हैं अगर floor(x/10) == floor(y/10)। उदाहरण के लिए, 52और 58एक ही समोच्च स्तर पर हैं, लेकिन 58और 64नहीं कर रहे हैं।

ड्राइंग आकृति का कार्य निम्नानुसार परिभाषित किया गया है: प्रत्येक तत्व के लिए e, इसे दो-चर स्ट्रिंग के साथ निम्नानुसार चुना गया है:

पहला चरित्र यह है " "कि नीचे eका तत्व समान समोच्च स्तर पर है eया यदि नीचे eऔर "_"अन्यथा कोई तत्व नहीं है
दूसरा चरित्र है " ", तो के अधिकार के लिए तत्व eके रूप में ही समोच्च स्तर पर है eया वहाँ के अधिकार के लिए कोई तत्व है eऔर "|"अन्यथा

पंक्तियों के भीतर तत्वों को एक साथ जोड़ा जाता है, फिर पंक्तियों को एक साथ जुड़कर newlines के साथ जोड़ा जाता है।

उदाहरण

मान लीजिए कि इनपुट है [[5,20],[3,6]], जैसा कि कल्पना है

5 20
3 6

हम सबसे पहले देखते हैं 5। चूंकि 3उसी समोच्च स्तर पर है 5, पहला चरित्र है " "। चूंकि 20समान समोच्च स्तर पर नहीं है 5, इसलिए दूसरा चरित्र है "|"।

अब हम देखते हैं 20। चूँकि 6समान समोच्च स्तर पर नहीं है 20, पहला चरित्र है "_"। चूँकि कोई तत्व सही नहीं है 20, दूसरा वर्ण है " "।

अब हम देखते हैं 3। चूंकि नीचे कोई तत्व नहीं है 3, पहला चरित्र है " "। चूंकि 6उसी समोच्च स्तर पर है 3, दूसरा चरित्र है " "।

अब हम देखते हैं 6। चूंकि नीचे कोई तत्व नहीं है 6, पहला चरित्र है " "। चूँकि कोई तत्व सही नहीं है 6, दूसरा वर्ण है " "।

इन दो-चार तारों के आधार पर, हम प्राप्त करने के लिए प्रतिस्थापन करते हैं [[" |","_ "],[" "," "]]। इनको एक साथ मिलाने पर, हमें इसका आउटपुट मिलता है

|_

नियम

इनपुट मैट्रिक्स हमेशा आयताकार होगा और सकारात्मक पूर्णांक से बना होगा।
ट्रेलिंग स्पेस या न्यूलाइन्स किसी भी राशि में हो सकते हैं (0 सहित) और किसी भी तरह से संगत नहीं होना चाहिए।
जब तक आप एक ही परिणाम नहीं देते तब तक आपको एक ही एल्गोरिदम का पालन करने की आवश्यकता नहीं है।
आपका प्रोग्राम या फ़ंक्शन एक नईलाइन-अलग स्ट्रिंग, स्ट्रिंग की सूची या समकक्ष आउटपुट कर सकता है।
यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

परीक्षण के मामलों

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

— fireflame241
स्रोत

1

मुझे यह महसूस करने से पहले यह भी पढ़ना शुरू नहीं हुआ कि यह कितना अच्छा होगा

— क्रिस्टोफर

6

पर्ल 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]) के रूप में फ़ंक्शन का उपयोग करते हैं। यह एक _जहाँ कहीं भी मेल खाने वाले तत्व अलग-अलग ऊँचाई पर हैं, और एक अन्यथा डालते हैं । तो हमें परिणाम का ½ (केवल "पहले अक्षर") मिलता है।

लाइन 6 पर, हम एक ही काम करते हैं, लेकिन पहले हम बदल $nजाते हैं |, और हम अब बदलाव कॉलम के साथ मैट्रिक्स के साथ मूल मैट्रिक्स को "ओवरले" करते हैं। परिणाम एक |अलग और एक ही ऊंचाई पर है। ये "दूसरे वर्ण" हैं।

अब हम बस उन्हें एक साथ जोड़ते हैं। हम एक संक्षिप्त (हाँ ...) के साथ एक ज़िप के साथ सरणियों को ज़िप करते हैं, जिसके परिणामस्वरूप मूल आकार का एक मैट्रिक्स होता है, जिसका प्रत्येक तत्व "आधे-समाधान" के 2 मिलान तत्व समवर्ती होता है। अंत में, हम बस इस मैट्रिक्स पर मैप करते हैं (जो वास्तव में सूचियों की सूची है)। इनमें से प्रत्येक सूची को चपटा किया जाता है और फिर say-ed (एक नई रेखा के साथ मुद्रित) किया जाता है। चूंकि sayकिसी भी संख्या में तर्क हो सकते हैं और यह उन सभी को बिना विभाजक के प्रिंट करता है, केवल अंत में नई रेखा बनाते हुए, हम स्टडआउट पर वांछित चित्र प्राप्त करते हैं। (और ब्लॉक Trues की सूची लौटाता है (प्रत्येक sayरिटर्न एक True), लेकिन कौन परवाह करता है।)

— Ramillies
स्रोत

+1 के लिएbut who cares

— हाइपरन्यूट्रीनो

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

— जोनाथन एलन
स्रोत

जीआर 3 बाइट्स। +1 लेकिन मैं आपको आउटगोल्फ करने की कोशिश करूंगा;)

— हाइपरन्यूट्रिनो

स्वतंत्र समाधान - बस देखा तुम्हारा है बहुत समान है! ⁵आपको एक सीधे बचाता है ...

— जोनाथन एलन

आप :⁵I;€0ao⁶मुख्य लिंक के बजाय सहायक में शामिल होने पर प्रत्येक का उपयोग करके एक बाइट बचा सकते हैंZç”_Zż"ç”|$Y

— मील

@ मीलों अरे वाह, यह काम करता है? धन्यवाद! मैंने सोचा था Iकि इस तरह वेक्टर नहीं होगा।

— जोनाथन एलन

हां I1 गहराई पर वेक्टर होता है, और दोनों 0 aऔर oगहराई 0

— मील

3

पायथन 2 , 199 186 157 155 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— चास ब्राउन
स्रोत

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

जोनाथन एलन को -2 बाइट्स धन्यवाद

— HyperNeutrino
स्रोत

आपका समाधान वास्तव में दूर कर सकता है Y- यह पात्रों की सूची की एक सूची लौटाएगा, जो मुझे विश्वास है कि ठीक है (जबकि "पंक्तियों के अंदर मेरे जोड़े हैं")।

— जोनाथन एलन

@JonathanAllan ओह, यह सच है ... धन्यवाद!

— हाइपरनेत्रिनो

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

इसे ऑनलाइन आज़माएं!

वाह, यह तर्क को काम करने के लिए एक ख़ुशी थी। मुझे अब हाइपर न्यूट्रिनो निंजा मुझे एक छोटे से उत्तर के साथ दिखाई देगा, लेकिन मैंने इसे पोस्ट नहीं करने के लिए इस पर बहुत अधिक काम किया । : पी

इसके अलावा, क्या मैं सिर्फ यह कह सकता हूं, यह ASCII- कला बनाने का एक शानदार तरीका है। मुझे माफ करना, जबकि मैं इनमें से एक नाव लोड करता हूं।

— totallyhuman
स्रोत

> निन्जाडेल: यार यह 45 मिनट हो गया है

— हाइपरन्यूट्रिनो

हाँ, मैंने जवाबों पर गौर नहीं किया ...: पी

— अमानवीय

आप enumerateदो बार पूर्ण नाम का उपयोग करने के बजाय एक चर को परिभाषित करके 4 बाइट्स बचा सकते हैं ।

— जोनाथन फ्रीच

218 बाइट्स पहले निकाल कर enumerate(ओ बीएस, मैं यहाँ यह लिंक करने के लिए सक्षम होने के लिए कुछ आदानों को दूर करने के लिए किया था)

— फेलिप Nardi बतिस्ता

2

जे, 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक अनाम फ़ंक्शन जो एक मैट्रिक्स लेता है और आकृति को आउटपुट करता है।

यहां सुधार के लिए लोटा कमरा। मेरे पास सभी परीक्षण मामलों की कोशिश करने का समय नहीं था इसलिए मुझे बताएं कि क्या कोई समस्या है। अधिक गोल्फ करने और बाद में समझाने की कोशिश करेंगे।

(क्विक) स्पष्टीकरण

हेल्पर फ़ंक्शन: 2 लंबाई सरणी का पहला तत्व दूसरे के बराबर है या नहीं, इसके आधार पर लंबाई 2 स्ट्रिंग में अनुक्रमित होती है। यदि यह समान है, तो यह शून्य तत्व में अनुक्रमित होता है, यदि यह असमान है, तो यह पहले में अनुक्रमित होता है। एक 1 लंबाई सरणी हमेशा स्ट्रिंग के शून्य तत्व में अनुक्रमित होती है।

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

जे , 46 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मील की दूरी पर
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। संपादित करें: सहेजे गए 2 बाइट्स @ 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))));

स्निपेट का विस्तार करें

— नील
स्रोत

आप (a[i] || [])[j]कंस्ट्रक्शन को मोड़ सकते हैं(a[i] || 0)[j]

— बेलािंट

इसके अलावा, आखिरी में 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>`

— बैलिंट

@ बेताल बह, मैं उस \nहिस्से को करना भूल जाता हूं ; मैं एक आरईपीएल में परीक्षण करता हूं ताकि शाब्दिक नए अंक रास्ते में मिल जाएं।

— नील

@ बैलिंट लेकिन आपका अंतिम सुझाव मूल उदाहरण के लिए विफल है, जिसे मैंने आउटपुट की सूची में जोड़ा है।

— नील

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

इसे ऑनलाइन आज़माएं!

-2 बाइट्स, जोनाथन फ्रेच
-15 बाइट्स के लिए धन्यवाद पायथन 2 के बजाय प्रोटॉन पर स्विच करके

— HyperNeutrino
स्रोत

आप की जगह दो बाइट्स बचा सकता है lenके साथ Lऔर परिभाषित L=len;।

— जोनाथन फ्रैच

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

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

जावा में पूर्णांक विभाजन स्वचालित रूप से फर्श पर ध्यान दें।

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

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

मैट्रिक्स के पूर्णांक प्रभाग, उपायों पंक्ति-वार और स्तंभ-वार मतभेद है, और जब तक नहीं की जगह रिक्त करता है |और _क्रमशः, तो दोनों (दर्द रहित, आर के vectorization करने के लिए धन्यवाद) चिपकाता है और आउटपुट।

परीक्षण के मामलों:

> 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झंडे के लिए कोड + 2 के 124 बाइट्स

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
स्रोत

मेरा कंट्रास्ट ड्रा करें

कार्य

उदाहरण

नियम

परीक्षण के मामलों

पर्ल 6 , 135 बाइट्स (131 चार्ट)

जेली , 25 23 22 बाइट्स

कैसे?

पायथन 2 , 199 186 157 155 बाइट्स

जेली , 24 बाइट्स

व्याख्या

पायथन 2 , 226 बाइट्स

जे, 58 बाइट्स

(क्विक) स्पष्टीकरण

जे , 46 45 बाइट्स

जावास्क्रिप्ट (ईएस 6), 120 118 बाइट्स

प्रोटॉन , 202 बाइट्स

जावा 8, 200 170 169 बाइट्स

आर, 159 बाइट्स

पर्ल 5 , 130 126 बाइट्स