বন্ধনী স্কোয়ারগুলি তৈরি করুন

Question

প্রতিটি প্রোগ্রামার জানে যে বন্ধনীগুলি []{}()<>সত্যই মজাদার। এই মজাদারতা বাড়ানোর জন্য, আন্তঃ বোনা বন্ধনীগুলির গ্রুপগুলি কিউট এবং ম্লান চিত্রগুলিতে রূপান্তরিত হতে পারে।

আসুন বলে একটি স্ট্রিং, যাতে মত, সুষম বন্ধনী রয়েছে আছে [{][<(]})>(())। প্রথম ধাপটি স্ট্রিংটিকে 45 ডিগ্রি ঘড়ির কাঁটার দিকে ঘোরানো। (ম্যাথমেটিকাতে এটি প্রায় সম্পন্ন করা যেতে পারে Rotate[ur_string,-pi/4])। এখানে প্রথম পদক্ষেপের ফলাফল:

[
 {
  ]
   [
    <
     (
      ]
       }
        )
         >
          (
           (
            )
             )

পরবর্তী প্রতিটি অক্ষরের মধ্যে একটি তির্যক স্থান যুক্ত করুন।

[

  {

    ]

      [

        <

          (

            ]

              }

                )

                  >

                    (

                      (

                        )

                          )

এরপরে, বাম-সর্বাধিক বন্ধনী দিয়ে শুরু করুন এবং অপরাধে এটির এবং তার সহযোগীর মধ্যে একটি বর্গক্ষেত্র আঁকুন।

+---+
|   |
| { |
|   |
+---+

      [

        <

          (

            ]

              }

                )

                  >

                    (

                      (

                        )

                          )

প্রতিটি জোড়া বন্ধনী দিয়ে এই প্রক্রিয়াটি পুনরাবৃত্তি করুন, +প্রয়োজনে পূর্বের অক্ষরগুলিকে ওভাররাইট করে ।

+---+
|   |
| +-+---------+
| | |         |
+-+-+         |
  |           |
  |   [       |
  |           |
  |     <     |
  |           |
  |       (   |
  |           |
  |         ] |
  |           |
  +-----------+

                )

                  >

                    (

                      (

                        )

                          )

যতক্ষণ না আপনি সবকিছু সুন্দর এবং বর্গক্ষেত্র না করে অবিরত থাকুন।

+---+
|   |
| +-+---------+
| | |         |
+-+-+         |
  |           |
  |   +-----+ |
  |   |     | |
  |   | +---+-+---+
  |   | |   | |   |
  |   | | +-+-+-+ |
  |   | | | | | | |
  |   +-+-+-+ | | |
  |     | |   | | |
  +-----+-+---+ | |
        | |     | |
        | +-----+ |
        |         |
        +---------+

                    +-----+
                    |     |
                    | +-+ |
                    | | | |
                    | +-+ |
                    |     |
                    +-----+

ইনপুট

ইনপুটটি ভারসাম্য বন্ধনীর একক লাইন এবং অন্য কোনও অক্ষর হবে না, প্রতিটি বন্ধনী একটির সাথে []{}()<>। প্রতিটি ধরণের বন্ধনী পৃথকভাবে সুষম হয়, যদিও বিভিন্ন ধরণের ওভারল্যাপ হতে পারে (এটি স্কোয়ারগুলি আকর্ষণীয় দেখায়)। একটি ট্রেলিং নিউলাইন optionচ্ছিক।

আউটপুট

আউটপুট হ'ল বন্ধনী স্ট্রিং থেকে উত্পন্ন ইন্টারলকিং স্কোয়ার প্যাটার্ন। ট্রেলিং স্পেস এবং ট্রেলিং নিউলাইন alচ্ছিক, তবে সেখানে শীর্ষস্থানীয় সাদা স্থান থাকতে হবে না।

লক্ষ্য

এটি কোড-গল্ফ, সবচেয়ে কম বাইট জেতা।

Comments

আমাদের কি একই ধরণের বন্ধনী বাসা বাঁধতে হবে? উদাহরণস্বরূপ, [[]]আমরা দুটি স্কোয়ারকে ওভারল্যাপিং করে আউটপুট দিতে পারি বা আমাদের অন্যটির ভিতরে একটি বর্গাকার আউটপুট করতে হবে?

— অস্থিরতা

একটি বর্গক্ষেত্র অন্যটির ভিতরে। আমি আমার উদাহরণ সামঞ্জস্য করব। সম্পাদনা: সম্পন্ন হয়েছে।

— PhiNotPi

Answer 1

জাভাস্ক্রিপ্ট (ES6), 269 ​​274 278 296 261 বাইট

সম্পাদনা সংরক্ষিত 4 বাইট ধন্যবা @Neil

x=>[...x].map(c=>{g.push([],[]),z='<{[(>}])'.indexOf(c);if(z>3)for(j=a=o[z-4].pop();j<=b;j++)S(j,a,'|'),S(j,b,'|'),S(a),S(b);else o[z].push(b);b+=2},S=(y,x=j,c='-')=>g[y][x]=g[y][x]?'+':c,o=[[],[],[],[]],g=[],b=0)&&g.map(r=>[...r].map(c=>c||' ').join``).join`
`

পরীক্ষা

F=x=>[...x].map(c=>{g.push([],[]),z='<{[(>}])'.indexOf(c);if(z>3)for(j=a=o[z-4].pop();j<=b;j++)S(j,a,'|'),S(j,b,'|'),S(a),S(b);else o[z].push(b);b+=2},S=(y,x=j,c='-')=>g[y][x]=g[y][x]?'+':c,o=[[],[],[],[]],g=[],b=0)&&g.map(r=>[...r].map(c=>c||' ').join``).join`
`

// Less golfed
U=x=>(
  S = (y,x=j,c='-')=>g[y][x]=g[y][x]?'+':c,
  o = [[],[],[],[]],
  g = [],
  b = 0,
  [...x].map(c=>
  {
    g.push([],[]),
    z='<{[(>}])'.indexOf(c);
    if(z>3)
      for(j = a =o[z-4].pop(); j <= b; j++)
        S(j,a,'|'),
        S(j,b,'|'),
        S(a),
        S(b)
    else
      o[z].push(b);
    b += 2
  }),
  g.map(r=>
    [...r].map(c=>c||' ').join``
  ).join`\n`
)

function test() {
  O.textContent=F(I.value)
}

test()

Input:<input id=I value='[{][<(]})>(())' oninput='test()'>
<pre id=O></pre>

Comments

কেন হবে না [...r].map?

— নীল

আরও ভাল [...r].map(c=>c||' '),।

— নিল

@ নীল আমি ব্যবহার করতে পারছি না r.mapকারণ r হ'ল একটি বিরল অ্যারে এবং মানচিত্রটি অনুপস্থিত উপাদানগুলি এড়িয়ে চলে। সুতরাং আমি এখন জি ব্যবহার করি, এটি ভরাট হয় (এবং আউটপুটে কলাম

— যতগুলি

আমি বলিনি r.map, আমি বলেছিলাম [...r].map, এবং [...r]এটি একটি বিচ্ছুর ছাপ নয়, যেমন আপনি কোডগল্ফ.স্ট্যাকেক্সেঞ্জার / এ / 50১50০৫ মন্তব্যতে নিজেকে উল্লেখ করেছেন

— নীল

@ নিল আমি এটি মিস করেছি ... এটি একটি দুর্দান্ত ইঙ্গিত বলে মনে হচ্ছে, ধন্যবাদ

— edc65

Answer 2

পাইথন 3, 226

n,p,*t=0,[],0,[],[],[],[]
for b in input():
 r=t[ord(b)//30];r+=[n];n+=2
 if b in'])}>':p+=[r[-2:]];del r[-2:]
R=range(n-1)
for y in R:print(''.join(' -|+'[sum((y in q)+2*(x in q)for q in p if x>=q[0]<=y<=q[1]>=x)]for x in R))

উদাহরণ । ব্যাখ্যা:

n,p,*t=0,[],0,[],[],[],[]   # n -> counter for input
                            # p -> bracket pairs
                            # t -> four stacks [unused, (), <>, [], {}]

for b in input():           # for each bracket b of input
  r=t[ord(b)//30];          # r -> alias for b's stack
  r+=[n];                   # push bracket's index
  n+=2                      # increase counter by 2 (to add diagonal gaps)

  if b in'])}>':            # if b is a closing bracket
    p+=[r[-2:]];            # pair the top 2 brackets on stack
    del r[-2:]              # pop them from stack

R=range(n-1)                # n-1 is now the width/height of output

for y in R:
  print(''.join(' -|+'[
    sum((y in{a,b})+2*(x in{a,b})for a,b in p if x>=a<=y<=b>=x)
  ]for x in R))

# three nested loops:
# 1) for each line y
#   2) for each character x
#     3) for each bracket pair (a, b)

if x>=a<=y<=b>=x
# if x or y isn't in the inclusive range [a, b], we can skip it

(y in{a,b})
# if y is a or b, then the character lies on a horizontal edge of that square
# so we add 1 to the sum

2*(x in{a,b})
# if x is a or b, then the character lies on a vertical edge of that square
# so we add 2 to the sum

' -|+'[sum()]
# if it lies on a single edge, the sum will be 1 or 2 -> '-' or '|'
# if it lies on two edges, the sum will be 1 + 2 == 3 -> '+'

Comments

শেষ লাইনে বন্ধনী জোড়া আনপ্যাক না করে আপনি 2 বাইট সংরক্ষণ করতে পারেন।

— অস্থিরতা

Answer 3

পিবি - 449 বাইট

^w[B!0]{w[B=40]{b[39]}t[B]w[B!0]{w[B=T]{^b[1]}w[B=T+1]{^b[1]}w[B=T+2]{^b[2]}^[Y]^>}<[X]^w[B!1]{>}t[1]b[0]w[T!0]{>w[B=1]{t[T+1]b[0]}w[B=2]{t[T-1]b[0]}}b[3]vw[B!0]{>}^w[B!3]{b[0]<}b[0]vb[1]>[X]vv[X]b[43]t[X]^[Y]^<[X]w[B=0]{>}>[X]vv[X]b[43]w[Y!T-1]{vw[B=45]{b[43]}w[B=0]{b[124]}}vb[43]t[1]>w[B!43]{t[T+1]w[B=124]{b[43]}w[B=0]{b[45]}>}w[T!0]{^t[T-1]w[B=45]{b[43]}w[B=0]{b[124]}}w[B!43]{w[B=124]{b[43]}w[B=0]{b[45]}<}<[X]^[Y]^w[B=0]{>}b[0]>w[B=1]{b[0]>}}

আমি যখন এটি পড়েছিলাম তখন আমি সকলেই উত্তেজিত হয়েছি কারণ আমার কাছে এমন একটি ভাষা রয়েছে যা সরাসরি কোনও অবস্থানে ছাপায়! আউটপুট অবস্থানের বিষয়ে এই চ্যালেঞ্জটি সহজ এবং সংক্ষিপ্ত হওয়া উচিত!

তারপরে আমি মনে করি পিবি যেভাবেই দীর্ঘায়িত ind

মন্তব্য সহ:

^w[B!0]{
    w[B=40]{b[39]}                       # change ( to ' to make closing bracket calculation work
    t[B]

    # this used to just find the first matching bracket
    # but then op clarified we had to use depth
    # whoops
    # <fix>

    w[B!0]{
        w[B=T]{^b[1]}                        # put a 1 above opening brackets of this type
        w[B=T+1]{^b[1]}                      # same as before, but ugly hack to make ( work
        w[B=T+2]{^b[2]}                      # put a 2 above closing brackets of this type
        ^[Y]^                                # return to input line
    >}
    <[X]^w[B!1]{>}t[1]b[0]               # set T to 1 above the opening bracket
    w[T!0]{>                             # until T (depth) == 0:
        w[B=1]{t[T+1]b[0]}                   # add 1 to T if 1
        w[B=2]{t[T-1]b[0]}                   # subtract 1 from T if 2
    }
    b[3]                                 # when T is 0, we've found the right one
    vw[B!0]{>}                           # go to the end of the input
    ^w[B!3]{b[0]<}b[0]v                  # clean up the row above
    # </fix>

    b[1]                                 # replace it with 1 so it's not confusing later
    >[X]vv[X]b[43]t[X]                   # put a + at its output position and save coord
    ^[Y]^<[X]w[B=0]{>}>[X]vv[X]b[43]     # put a + at opening bracket's output position
    w[Y!T-1]{v
        w[B=45]{b[43]}                       # replace - with +
        w[B=0]{b[124]}                       # otherwise put |
    }
    vb[43]                               # put a + at lower left corner
    t[1]                                 # count side length + 1
    >w[B!43]{
        t[T+1]
        w[B=124]{b[43]}                      # replace | with +
        w[B=0]{b[45]}                        # otherwise put -
    >}
    w[T!0]{^                             # create right side
        t[T-1]
        w[B=45]{b[43]}
        w[B=0]{b[124]}
    }
    w[B!43]{                             # create top side
        w[B=124]{b[43]}                      # this replacement saves us from putting the last + explicitly
                                             # which is why we counted the side length + 1, to get that 
                                             # extra char to replace
        w[B=0]{b[45]}
    <}
    <[X]^[Y]^w[B=0]{>}b[0]>w[B=1]{b[0]>}# Go to next character (skipping 1s)
}

Comments

আমি ... ঠিক ... পারছি না ...

— সাইয়েস

Answer 4

সিজেম, 117 বাইট

q_,2*:M2#0a*\:iee{1=K/}${~)4%1>{a+aL+:L;}*}/L{2f*__~,>m*5Zb\m*{~W2$#%Mb\}%\2m*Mfb3am*}%e_2/{~2$2$=+3e<t}/" |-+"f=M/N*

এখানে চেষ্টা করুন।

Answer 5

রুবি, 268

->z{a=(2..2*t=z.size).map{'  '*t}
g=->y,x{a[y][x]=(a[y][x-1]+a[y][x+1]).sum>64??+:?|}
2.times{|h|s=z*1
t.times{|i|c=s[i]
c>?$&&(j=s.index(c.tr('[]{}()<>','][}{)(><'))
(m=i*2).upto(n=j*2){|k|k%n>m ?g[k,m]+g[k,n]:h<1&&a[k][m..n]=?++?-*(n-m-1)+?+}
s[i]=s[j]=?!)}}
puts a}

পরীক্ষা প্রোগ্রামে ungolfed

f=->z{
  a=(2..2*t=z.size).map{'  '*t}                       #make an array of strings of spaces
  g=->y,x{a[y][x]=(a[y][x-1]+a[y][x+1]).sum>64??+:?|} #function for printing verticals: | if adjacent cells spaces (32+32) otherwise +

  2.times{|h|                                         #run through the array twice
    s=z*1                                             #make a duplicate of the input (*1 is a dummy operation to avoid passing just pointer)
    t.times{|i|                                       #for each index in input
    c=s[i]                                            #take the character
    c>?$&&(                                           #if ascii value higher than for $
      j=s.index(c.tr('[]{}()<>','][}{)(><'))          #it must be a braket so find its match
      (m=i*2).upto(n=j*2){|k|                         #loop through the relevant rows of array
        k%n>m ?g[k,m]+g[k,n]:                         #if k!=n and k!m draw verticals
        h<1&&a[k][m..n]=?++?-*(n-m-1)+?+              #otherwise draw horizontals (but only on 1st pass)
      }
      s[i]=s[j]=?!)                                   #we are done with this set of brackets, replace them with ! so they will be ignored in next call of index  
    }
  }
  puts a
}


z=gets.chop
f[z]