40

এটির মতো একটি পাঠ্য দেওয়া:

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

একই পাঠ্যটি আউটপুট করুন তবে পিক্সেলগুলি অক্ষরের সাথে সংযুক্ত করে ─│┌┐└┘├┤┬┴┼। যদি পিক্সেলের কোনও প্রতিবেশী না থাকে তবে এটি পরিবর্তন করবেন না।

সুতরাং শেষ পাঠ্য আউটপুট হয়:

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

আপনি বুলিয়ান অ্যারে হিসাবে ইনপুট নিতে পারেন।
ইনপুটটিতে সর্বদা কমপক্ষে 1 পিক্সেল থাকবে।
আপনি বক্স-অঙ্কন চরগুলি 1 বাইট হিসাবে গণনা করতে পারেন।
আপনি ধরে নিতে পারেন ইনপুটটি ফাঁকা স্থানের সাথে প্যাডযুক্ত।

পরীক্ষার মামলা

## #
=>
── #

###
 #
=>
─┬─
 │

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

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

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

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

যেহেতু এটি কোড-গল্ফ , তাই সংক্ষিপ্ততম কোডটি জয়ী।

code-golf ascii-art

— TuxCrafting
সূত্র

2

আমি কি পিক্সেল হিসাবে হ্যাশ চরিত্রটি ব্যবহার করব? আমি কি বুলিয়ান অ্যারে হিসাবে ইনপুট পেতে পারি?

— রোহান ঝুনঝুনওয়ালা

ট্রেলিং স্পেস (গুলি) বা নিউলাইন (গুলি) থাকতে পারে?

— সানচিইস

বিটিডব্লিউ: -|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 )

ব্যাখ্যা

এটি জেতে আমার উত্তর হিসাবে একই ধারণার উপর নির্ভর করে তবে প্রতিটি 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 এর অঙ্কের তালিকায় রূপান্তর করুন এবং বাক্সের অক্ষরের পরিসীমাতে সরানোর জন্য প্রতিটি 9491 দ্বারা বর্ধিত করুন এবং পাইথনের ব্যবহার করে প্রতিটিকে রূপান্তর করুন 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। এই মানগুলি E4 দ্বারা সূচক 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

জাভাস্ক্রিপ্ট (ES6), 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' +
  '   ####  ##'
));

স্নিপেট প্রসারিত করুন

সম্পাদনা: ETH প্রোডাকশনগুলির সাহায্যে 18 বাইট সংরক্ষণ করা হয়েছে সম্পাদনা:
প্রতিস্থাপনের 1 ম প্যারামিটার ব্যবহার করে 1 বাইট সংরক্ষণ করা ()'#'

কিভাবে এটা কাজ করে

আমরা #ইনপুট স্ট্রিংয়ে পাওয়া সমস্ত অক্ষরের উপরে পুনরাবৃত্তি করি । তাদের প্রত্যেকের জন্য, আমরা পরীক্ষা করি যে এর প্রতিবেশীরাও ফাংশনটি #ব্যবহার করে অক্ষর রয়েছে t():

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

প্যারামিটার xএর t()ফাংশন বর্তমান অবস্থান থেকে সম্মান সঙ্গে প্রতিবেশী অফসেট হয় p। বাম / ডান প্রতিবেশীদের পরীক্ষা করার জন্য আমরা -1 / + 1 ব্যবহার করি এবং শীর্ষ / নীচের প্রতিবেশীদের জন্য (ডাবল wপ্রস্থ, যেখানে প্রথম লাইন-ব্রেক + 1 এর অবস্থান) for

প্রতিটি প্রতিবেশীকে নিম্নলিখিত কমপাস অনুযায়ী আলাদা ওজন (1, 2, 4 বা 8) দেওয়া হয়েছে:

  1
2 + 4
  8

প্রতিটি ওজনের সংমিশ্রণ [0 .. 15] এ অনন্য মানের দিকে নিয়ে যায়। উদাহরণস্বরূপ, শীর্ষে থাকা প্রতিবেশী এবং ডানদিকে প্রতিবেশী উভয়ই সেট করা থাকলে যোগফলটি 1 + 4 = 5 হবে, যা └এই টেবিলটি ব্যবহার করে অনুবাদ করা হয়েছে:

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

সুতরাং, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]প্রত্যাশিত চরিত্র বাড়ে।

— Arnauld
সূত্র

হা, আমাদের মূলত একই ধারণা ছিল;)

— ETH প্রচারগুলি

@ ইথ প্রডাকশনস - খুব সুন্দর। ^^

— আর্নল্ড

সত্যিই, সেখানে দুর্দান্ত কৌশল। আপনি আমাকে দৃ solid়ভাবে আউট গল্ফ করেছেন :)

— ETH প্রচারগুলি

আপনি এর মতো 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)])

— ETH প্রোডাকশনগুলি

এবং এটি একটি বহু লাইন স্ট্রিং ফিরে ফিরে আসলে খুব সংক্ষিপ্ত:

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)

— ETH প্রোডাকশন

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

জাভাস্ক্রিপ্ট (ES6), 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 সাধারণত একটি ধাতব ভাষা হিসাবে ব্যবহৃত হয়, তবে এখানে আমি এটি প্রোগ্রামিং ভাষা হিসাবে ব্যবহার করছি।

অবরুদ্ধ সংস্করণ:

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

পিএইচপি, 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);

এসটিডিআইএন থেকে ইনপুট পড়ে। দিয়ে চালানো -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 এবং 0 এর ম্যাট্রিক্স । এটি বেশ কুৎসিত এবং হ্যাকি।

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
সূত্র

জমা অবশ্যই একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন হতে হবে। বিদ্যমান ভেরিয়েবল থেকে পঠন কোনও ইনপুটের অনুমোদিত রূপ নয়।

— TuxCraftting

আপনি কীভাবে ইউনিকোডের কয়েকটি অক্ষর আর এর সাথে সুন্দরভাবে কাজ করতে পারেন? x = "\ U253C" কাজ করে তবে x = "┼" কাজ করে না।

— Vlo

@ টেক্সক্রাফট্যাগ: এখনই স্থির!

— rturnbull

@ ভ্লো ইউটিএফ -8 হ'ল আমার নেটিভ ওএস এনকোডিং। 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

এমএটিএল, ১০২ টি অক্ষর

আমি প্রতিবেশীকে একটি মান নির্ধারণ করি (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 বাইট

ব্যবহার

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 155 121 103 102 টি অক্ষর

কিভাবে এটা কাজ করে

পাইথন 2.7, 318 315 বাইট ( 270 267 অক্ষর)

জাভাস্ক্রিপ্ট (ES6), 150 139 133 131 অক্ষর

পরীক্ষার স্নিপেট

ALPACA , 414 + 2 = 416 বাইট

পিএইচপি, 203 বাইট

পাইথন 3, 149 বাইট

আর, 199 212 বাইট

পার্ল, 89 88 বাইট

এমএটিএল, ১০২ টি অক্ষর