40

इस तरह एक पाठ दिया:

# #### ## #
## #  ##  #
   ####  ##

उसी टेक्स्ट को आउटपुट करें लेकिन पिक्सल को अक्षरों से जोड़कर ─│┌┐└┘├┤┬┴┼। यदि पिक्सेल में कोई पड़ोसी नहीं है, तो उसे न बदलें।

तो अंतिम पाठ का आउटपुट है:

│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘

आप बुलियन एरे के रूप में इनपुट ले सकते हैं।
इनपुट में हमेशा कम से कम 1 पिक्सेल होगा।
आप बॉक्स-ड्राइंग वर्णों को 1 बाइट के रूप में गिन सकते हैं।
आप मान सकते हैं कि इनपुट रिक्त स्थान के साथ गद्देदार है।

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

## #
=>
── #

###
 #
=>
─┬─
 │

##### ##
 # #  #
########
=>
─┬─┬─ ┌─
 │ │  │
─┴─┴──┴─

 # #
#####
 # #
=>
 │ │
─┼─┼─
 │ │

# # # # #
 # # # #
# # # # #
 # # # #
# # # # #
=>
# # # # #
 # # # #
# # # # #
 # # # #
# # # # #

#####
#####
#####
#####
#####
=>
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘

चूंकि यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है।

code-golf ascii-art

— TuxCrafting
स्रोत

2

क्या मुझे पिक्सेल के रूप में हैश चरित्र का उपयोग करना चाहिए? क्या मुझे बूलियन सरणी के रूप में इनपुट प्राप्त हो सकता है?

— रोहन झुनझुनवाला

क्या अनुगामी स्थान (स्थान) या नई रेखाएं हो सकती हैं?

— Sanchises

btw: -|r7LJE3TW+ब्लॉक पात्रों के लिए एक उपयुक्त 1 बाइट-चार प्रतिस्थापन है।

— टाइटस

7

जेली , 60 52 51 50 49 48 बाइट्स

ṖḤ0;+Ḋ×
“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j
ZÑ€4×Z++Ñ€ị¢Y

@ डेनिस को एक बाइट धन्यवाद दिया ।

इनपुट 1 और 0 के बूलियन सरणी है। प्रत्येक कॉलम और प्रत्येक पंक्ति पर आइरेट्स को आकार 3 के प्रत्येक इन्फिक्स के सिर और पूंछ को बाइनरी अंकों की एक जोड़ी से एक दशमलव में परिवर्तित किया जाता है, और प्रत्येक इन्फिक्स के केंद्र के साथ गुणा करता है। फिर यह सूचकांक को खोजने के लिए इसे अपने साथ रखता है '#───│┌┐┬│└┘┴│├┤┼ '।

इसे ऑनलाइन आज़माएं! ( केस 2 ) ( केस 3 ) ( केस 4 )

व्याख्या

यह J पर मेरे उत्तर के समान विचार पर निर्भर करता है, लेकिन प्रत्येक 3x3 सब्रे पर प्रसंस्करण के बजाय, मैं प्रत्येक पंक्ति और प्रत्येक स्तंभ पर प्रक्रिया करता हूं, जबकि अभी भी सूचकांक की एक ही तालिका प्राप्त कर रहा हूं।

आधे से अधिक बाइट्स बॉक्स पात्रों की सूची बनाने में खर्च किए जाते हैं '#───│┌┐┬│└┘┴│├┤┼ '। स्ट्रिंग शाब्दिक “जेली के साथ शुरू होते हैं और उनके टर्मिनेटर के आधार पर अलग-अलग अर्थ होते हैं। यहां टर्मिनेटर का ’अर्थ है कि स्ट्रिंग को जेली कोड पृष्ठ के अनुसार प्रत्येक वर्ण के कोड बिंदुओं के रूप में पार्स किया जाएगा , और आधार 250 अंकों की सूची से दशमलव में परिवर्तित किया जाएगा।

“µ³Q~E!G⁸ṗṫ\’ => 10041542192416299030874093
(bijective base 61) => [1, 1, 1, 3, 13, 17, 45, 3, 21, 25, 53, 3, 29, 37, 61]
(add 9471 and convert to char) => '───│┌┐┬│└┘┴│├┤┼'

फिर उस दशमलव को विशेषण आधार 61 में अंकों की सूची में परिवर्तित करें और प्रत्येक को 9471 से बढ़ाकर बॉक्स वर्णों की सीमा में ले जाएं और प्रत्येक को पायथन के उपयोग से रूपांतरित करें chr। फिर एक चरित्र शाब्दिक के साथ इसे प्रस्तुत करें ”#और एक स्थान संलग्न करें ⁶।

ṖḤ0;+Ḋ×  Helper link - Input: 1d list A
Ṗ        Get all of A except the last value
 Ḥ       Double each value in it
  0;     Prepend a 0
    +    Add elementwise with
     Ḋ     All of A except the first value
      ×  Multiply elementwise by A

“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j  Nilad. Represents '#───│┌┐┬│└┘┴│├┤┼ '
“µ³Q~E!G⁸ṗṫ\’               Get the code points of each char in the string and
                            convert from a list of base 250 digits to decimal
             ḃ61            Convert that to a list of digits in bijective base 61
                +9471       Add 9400 to each
                     Ọ      Convert from ordinals to chars, gets '───│┌┐┬│└┘┴│├┤┼'
                      ⁾#    A pair of chars ['#', ' ']
                         j  Join the pair using the box characters

ZÑ€4×Z++Ñ€ị¢Y  Input: 2d list M
Z              Transpose
 Ñ€            Apply the helper link to each row of the transpose (each column of M)
   4×          Multiply each by 4
     Z         Transpose
      +        Add elementwise with M
       +       Add elementwise with
        Ñ€       The helper link applied to each row of M
          ị¢   Use each result as an index to select into the nilad
            Y  Join using newlines
               Return and print implicitly

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

15

जे , 82 72 66 बाइट्स

(ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]

इनपुट 1 और 0 के बूलियन टेबल है। नियम बताता है कि बॉक्स वर्ण प्रत्येक को एक बाइट के रूप में गिनता है, तीन नहीं, और जो यहां लागू किया गया है।

प्रयोग

   f =: (ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]
   m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
   m { ' #'
# #### ## #
## #  ##  #
   ####  ##
   f m
│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘
   ' #' {~ m =: 5 5 $ 1
   f m
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘
   ' #' {~ m =: 5 9 $ 1 0
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #
   f m
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #

व्याख्या

पहले इनपुट को सभी पक्षों पर 0 के साथ गद्देदार किया जाता है।

   ] m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
1 0 1 1 1 1 0 1 1 0 1
1 1 0 1 0 0 1 1 0 0 1
0 0 0 1 1 1 1 0 0 1 1
   (0,.~0,.0,~0,]) m
0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 1 1 1 0 1 1 0 1 0
0 1 1 0 1 0 0 1 1 0 0 1 0
0 0 0 0 1 1 1 1 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0

फिर आकार 3 के प्रत्येक उप-वर्ग का चयन किया जाता है

   3 3 <;._3 (0,.~0,.0,~0,]) m
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

तब प्रत्येक उपश्रेणी में केवल 5 मानों को माना जाता है

┌───┐
│xAx│
│CED│
│xBx│
└───┘

मूल्यों ABCDका चयन प्रत्येक सबर्रे को समतल करके और सूचकांकों का चयन करके किया जाता है 1 7 3 5। उन मानों को गुणा किया Eजाता है, जो सूचकांक 4 पर है। इसे फिर बाइनरी अंकों की सूची से दशमलव में बदल दिया जाता है, और इसके द्वारा बढ़ा दिया जाता है E। xमान आवश्यक नहीं हैं।

   3 3 (4&{([+2#.*)1 7 3 5&{)@,;._3 (0,.~0,.0,~0,]) m
 5 0 2  8 4 3  0  6 3 0  5
10 3 0 13 0 0  6 11 0 0 13
 0 0 0 10 4 4 11  0 0 2 11

इसका उपयोग एक सूचकांक के रूप में किया जाता है कि नीचे तालिका के अनुसार किस वर्ण का चयन किया जाए (गोल्फिंग के लिए थोड़ा सा मोड दिया गया)। अंतिम कॉलम प्रत्येक सबर्रे के आउटपुट मूल्य से एक बॉक्स वर्ण से मेल खाता है।

 0  (space)  0
 1  #        1
 2  ┌        6
 3  ┬        8
 4  ┐        7
 5  ├        14
 6  ┼        16
 7  ┤        15
 8  └        10
 9  ┴        12
10  ┘        11
11  │        5, 9, 13
12  ─        2, 3, 4

इसके अलावा, जम्मू में, स्ट्रिंग ' #───│┌┐┬│└┘┴│├┤┼'8-बिट अक्षरों का उपयोग करती है , जिससे यह आवश्यक है कि 17 पात्रों के लिए 47 (प्रत्येक बाइट के लिए) की लंबाई हो। कमांड ucpइसे 16-बिट वर्णों में परिवर्तित करता है जो इसे लंबाई 17 करने की अनुमति देता है।

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

13

जावास्क्रिप्ट (ईएस 6), 155 121 103 102 वर्ण

let f =
    
s=>s.replace(/#/g,(c,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]==c,8*t(w=s.search`
`+1)+4*t(1)+2*t(-1)+t(-w)])

console.log(f(
  '# #### ## #\n' +
  '## #  ##  #\n' +
  '   ####  ##'
));

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

संपादित करें: ETHproductions की मदद से 18 बाइट्स को
बचाया'#'

यह काम किस प्रकार करता है

हम #इनपुट स्ट्रिंग में पाए जाने वाले सभी वर्णों पर पुनरावृति करते हैं । उनमें से प्रत्येक के लिए, हम परीक्षण करते हैं कि क्या उसके पड़ोसी भी फ़ंक्शन #का उपयोग कर रहे हैं t():

t = x => s[p + x] == c  // where c = '#'

पैरामीटर xके t()समारोह वर्तमान स्थिति के संबंध में पड़ोसी की ऑफसेट है p। हम टॉप / बॉटम पड़ोसियों के लिए बाएं / दाएं पड़ोसियों और -w / + w का परीक्षण करने के लिए -1 (+ का उपयोग करते हैं (जहां wएक पंक्ति की चौड़ाई है, यानी पहली पंक्ति-ब्रेक + 1 की स्थिति)।

प्रत्येक पड़ोसी को निम्नलिखित कम्पास के अनुसार एक अलग वजन (1, 2, 4 या 8) सौंपा गया है:

  1
2 + 4
  8

प्रत्येक वजन संयोजन में अद्वितीय मूल्य होता है [0 .. 15]। उदाहरण के लिए, यदि शीर्ष पर पड़ोसी और दाईं ओर पड़ोसी दोनों सेट हैं, तो योग 1 + 4 = 4 होगा, जिसे └इस तालिका का उपयोग करने में अनुवाद किया गया है :

00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
#  │  ─  ┘  ─  └  ─  ┴  │  │  ┐  ┤  ┌  ├  ┬  ┼

इसलिए, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]अपेक्षित चरित्र की ओर जाता है।

— Arnauld
स्रोत

हा, हमारे पास मूल रूप से एक ही विचार था;)

— ETHproductions

@ETHproductions - बहुत बहुत। ^ ^

— अर्नुलड

वास्तव में, वास्तव में अच्छी तकनीक है। आपने मुझे ठोस रूप से बाहर कर दिया है :)

— ETHproductions

आप इस तरह से 2 बाइट्स बचा सकते हैं:

s=>(w=s[0].length+1,s=s.join`\n`).replace(/#/g,(_,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]>' ',t(-w)+2*t(-1)+4*t(1)+8*t(w)])

— ETHproductions

और यह वास्तव में एक

s=>s.replace(/#/g,(_,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]>' ',t(-w)+2*t(-1)+4*t(1)+8*t(w)],w=s.indexOf`\n`+1)

— बहुस्तरीय

8

पायथन 2.7, 318 315 बाइट्स ( 270 267 चार्ट)

मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है (विशेष रूप से मैं उस कष्टप्रद पहली पंक्ति की टिप्पणी से छुटकारा पाना पसंद करूंगा) लेकिन यहां मेरी प्रविष्टि है:

#encoding:utf-8
f=lambda t:(lambda l,s:'\n'.join(''.join((u'┼├┤│┬┌┐│┴└┘│───#'[(s==l[i][j-1])+2*(s==l[i][j+1])+4*(i<1 or s==l[i-1][j])+8*(i>len(l)-2 or s==l[i+1][j])],s)[s==l[i][j]]for j in range(len(l[i])-1))for i in range(len(l))))([l+' 'for l in t.split('\n')],' ')

यहां बताया गया है कि पूरी चीज कैसे काम करती है:

#encoding:utf-8 # Dammit, Python. This adds an extra 16 bytes!
f=lambda t:( # main lambda function
    lambda l,s: # inner lambda so we can pass it "local constants" (see last line)
        '\n'.join( # join each line
            ''.join( # join each char within the line
                (u'┼├┤│┬┌┐│┴└┘│───#'[ # string of all possible characters, indexed by binary 0-15 based on adjacent chars
                    (s==l[i][j-1])+ # left
                    2*(s==l[i][j+1])+ # right
                    4*(i<1 or s==l[i-1][j])+ # up ('i<1' just yields zero in case this is the first line, so that we don't get index problems)
                    8*(i>len(l)-2 or s==l[i+1][j])], # down ('i>len(l)-2' is same as above)
                s)[s==l[i][j]] # if original is space, choose space, else choose the previously chosen box-drawing char
                for j in range(len(l[i])-1)) # do this process for each char (excluding last, which is a space)
            for i in range(len(l))) # do this for each line
    )([l+' ' for l in t.split('\n')],' ') # call the inner lambda with two parameters: first, the text split into lines; second, a space char (actually makes code shorter)

संपादित करें: पहले कुछ रिक्त स्थान निकाले for ... in ...

— Hactar
स्रोत

9

इसके बजाय अजगर 3 का उपयोग करने से आपकी यूनिकोड एन्कोडिंग समस्या का समाधान होना चाहिए, मुझे लगता है ...

— बाइट कमांडर

6

जावास्क्रिप्ट (ईएस 6), 150 139 133 131 चार्ट

a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है, जैसे f(["###", " # "])।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

<textarea id=I rows=6># #### ## #
## #  ##  #
   ####  ##</textarea>
<br>
<button onclick="O.innerHTML=f(I.value.split('\n')).replace(/\n/g,'<br>')">Run</button>
<pre id=O></pre>

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

— ETHproductions
स्रोत

5

ALPACA , 414 + 2 = 416 बाइट्स

neighbourhoodV(^ v < >);states" ";statep"#"toA when4inV p,toB when3inV p andvs,toC when3inV p and^s,toD when3inV p and>s,toE when3inV p and<s,toF when2inV p and>s andvs,toG when2inV p andvs and<s,toH when2inV p and<s and^s,toI when2inV p and^s and>s,toJ when^p orvp,toK when<p or>p;stateA"┼";stateB"┴";stateC"┬";stateD"┤";stateE"├";stateF"┘";stateG"└";stateH"┌";stateI"┐";stateJ"│";stateK"─".

-fIझंडे की आवश्यकता है ।

यह समाधान बहुत बड़ी संख्या में बाइट्स का उपयोग करता है, लेकिन यह अद्वितीय है कि यह एक सेलुलर ऑटोमेटन का उपयोग करता है। ALPACA का उपयोग आमतौर पर एक धातु भाषा के रूप में किया जाता है, लेकिन यहां मैं इसे एक प्रोग्रामिंग भाषा के रूप में उपयोग कर रहा हूं।

Ungolfed संस्करण:

neighbourhood V (^ v < >);
state s " ";
state p "#" to A when 4 in V p,
to B when 3 in V p and v s,
to C when 3 in V p and ^ s,
to D when 3 in V p and > s,
to E when 3 in V p and < s,
to F when 2 in V p and > s and v s,
to G when 2 in V p and v s and < s,
to H when 2 in V p and < s and ^ s,
to I when 2 in V p and ^ s and > s,
to J when ^ p or v p,
to K when < p or > p;
state A "┼";
state B "┴";
state C "┬";
state D "┤";
state E "├";
state F "┘";
state G "└";
state H "┌";
state I "┐";
state J "│";
state K "─".

— DanTheMan
स्रोत

4

PHP, 203 बाइट्स

यह संभवत: छोटे तरीके से किया जा सकता है।

while($s=fgets(STDIN))$f[]=$s;foreach($f as$y=>&$s)for($x=strlen($s);$x--;)if($s[$x]>$b=" ")$s[$x]="#───│┘└┴│┐┌┬│┤├┼"[($s[$x-1]>$b)+2*($s[$x+1]>$b)+4*($f[$y-1][$x]>$b)+8*($f[$y+1][$x]>$b)];echo join($f);

STDIN से इनपुट पढ़ता है। साथ चलाना -r।

— टाइटस
स्रोत

4

पायथन 3, 149 बाइट्स

def f(s):S=' ';w=s.find('\n')+1;t=lambda i:(s+w*S)[i]>S;return[[c,'#│─┘─└─┴││┐┤┌├┬┼'[t(p-w)+2*t(p-1)+4*t(p+1)+8*t(p+w)]][c>S]for p,c in enumerate(s)]

जैसे इनपुट लेता है ##\n #\nऔर जैसे आउटपुट देता है ['─', '┐', '\n', ' ', '│', '\n']।

— लिन
स्रोत

3

आर, 199 212 बाइट्स

संपादित करें: यह कोड स्निपेट के बजाय अब एक फ़ंक्शन है।

इनपुट m1s और 0s का एक मैट्रिक्स है। यह बहुत बदसूरत और हैकरी है।

function(m){
v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
d=dim(m)+1
n=array(0,dim=d+1)
n[2:d[1],2:d[2]]=m
for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
}

परीक्षणों की एक जोड़ी:

> m = matrix(c(1, 1, 1, 0, 1, 0), nrow=2, byrow=TRUE)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
─┬─
 │ 
> m = matrix(rep(1, 16), ncol=4)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
┌┬┬┐
├┼┼┤
├┼┼┤
└┴┴┘

— rturnbull
स्रोत

सबमिशन या तो एक पूर्ण कार्यक्रम या एक समारोह होना चाहिए। मौजूदा चर से पढ़ना इनपुट का एक स्वीकृत रूप नहीं है।

— TuxCrafting

आर के साथ अच्छी तरह से काम करने के लिए आपको कुछ यूनिकोड वर्ण कैसे मिलते हैं? x = "\ U253C" काम करता है लेकिन x = "25" नहीं करता है।

— Vlo

@ T @xCräftîñg: अब ठीक हो गया!

— rturnbull

@ Vlo utf-8 मेरी मूल OS एन्कोडिंग है। x = "┼"मेरे लिए ठीक काम करता है।

— rturnbull

3

पर्ल, 89 88 बाइट्स

के लिए +2 शामिल है -0p। विशेष पात्रों को 1 बाइट के रूप में गिना जाता है, लेकिन उन्हें वास्तव में एकल वर्ण के रूप में प्रदर्शित करने के लिए -C विकल्प भी जोड़ना सबसे अच्छा है।

एसटीडीआईएन पर इनपुट लाइन गद्देदार स्थान के साथ दें ताकि सभी की लंबाई समान हो:

perl -C connect.pl
# #### ## #
## #  ##  #
   ####  ##
^D

connect.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s%#%substr"#───│└┘┴│┌┐┬│├┤┼",/\G##/+2*/#\G/+4*/#$n\G/s+8*/\G#$n#/s,1%eg

— टन हास्पेल
स्रोत

1

MATL, 102 वर्ण

मैं एक पड़ोसी को एक मूल्य (1, 2, 4 या 8) सौंपता हूं; उनका योग ड्राइंग वर्णों वाले स्ट्रिंग में एक चरित्र से मेल खाएगा। मुझे लगता है कि सुधार के लिए अभी भी बहुत जगह है, लेकिन एक मोटे मसौदे के लिए:

' #│││─┌└├─┐┘┤─┬┴┼' % String to be indexed
wt0J1+t4$(          % Get input, and append zeros at end of matrix (solely to avoid
                    %  indexing a non-existent second row/column for small inputs)
ttttt               % Get a whole load of duplicates to work on
3LXHY)              % Select rows 2:end from original matrix (one of the many dupes)
      w4LXIY)       % Select rows 1:end-1 from the 'destination' summing matrix)
             +HY(   % Add the neighbors below, store in 'destination' matrix
tIY)b3LY)2*+IY(     % +2* the neighbors above    +-------------------------------+
tHZ)b4LZ)4*+HZ(     % +4* the neighbors right    |(note: H and I contain 1:end-1 |
tIZ)b3LZ)8*+IZ(     % +8* the neighbors left     |  and 2:end respectively)      |
HH3$)               % Select the original matrix +-------------------------------+
*                % Make sure only cells that originally had a # get replaced
  1+)            % Add one because the original string is one-indexed. Index using ).

किए जाने वाले सुधार:

संभवतः मैट्रिक्स के घुमाए गए प्रतियों पर काम करने वाले कुछ प्रकार के लूप के साथ पूरे संक्षेप भाग को बदलें
पूरी चीज को खाई और मैट्रिक्स के माध्यम से काम करने वाले एकल लूप के आधार पर कुछ बनाएं
मूल सरणी (?) से चपटा वेक्टर पर काम करने के लिए मॉड्यूलर अनुक्रमण का उपयोग करें

इसे ऑनलाइन आज़माएं! (बॉक्स ड्राइंग वर्ण समर्थन नहीं हो सकता है)

— Sanchises
स्रोत

पिक्सेल कनेक्ट करें

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

जेली , 60 52 51 50 49 48 बाइट्स

व्याख्या

जे , 82 72 66 बाइट्स

प्रयोग

व्याख्या

जावास्क्रिप्ट (ईएस 6), 155 121 103 102 वर्ण

यह काम किस प्रकार करता है

पायथन 2.7, 318 315 बाइट्स ( 270 267 चार्ट)

जावास्क्रिप्ट (ईएस 6), 150 139 133 131 चार्ट

टेस्ट स्निपेट

ALPACA , 414 + 2 = 416 बाइट्स

PHP, 203 बाइट्स

पायथन 3, 149 बाइट्स

आर, 199 212 बाइट्स

पर्ल, 89 88 बाइट्स

MATL, 102 वर्ण