একটি অ্যারে ভিজ্যুয়ালাইজ করুন

Question

যে কোনও গভীরতার একটি অ্যারে দেওয়া হয়েছে, +-|প্রতিটি সাবহারে এর সীমানা সহ এর সামগ্রীগুলি আঁকুন । প্লাস, বিয়োগ এবং উল্লম্ব পাইপের জন্য এগুলি ASCII অক্ষর।

উদাহরণস্বরূপ, অ্যারেটি থাকলে [1, 2, 3]আঁকুন

+-----+
|1 2 3|
+-----+

নেস্টেড অ্যারে যেমন [[1, 2, 3], [4, 5], [6, 7, 8]]আঁকুন For

+-----------------+
|+-----+---+-----+|
||1 2 3|4 5|6 7 8||
|+-----+---+-----+|
+-----------------+

র‌্যাগড অ্যারে যেমন [[[1, 2, 3], [4, 5]], [6, 7, 8]]আঁকুন For

+-------------------+
|+-----------+-----+|
||+-----+---+|6 7 8||
|||1 2 3|4 5||     ||
||+-----+---+|     ||
|+-----------+-----+|
+-------------------+

লক্ষ্য করুন যে আঁকার পরে আরও জায়গা আছে [6, 7, 8]। আপনি শীর্ষস্থানীয়, কেন্দ্র বা নীচে-সর্বাধিক লাইনে বিষয়বস্তুগুলি আঁকতে পারেন তবে আপনি যে কোনওটি চয়ন করুন, আপনাকে অবশ্যই ধারাবাহিক থাকতে হবে।

এই চ্যালেঞ্জটি জে থেকে বাক্স ক্রিয়া দ্বারা অনুপ্রাণিত হয়েছিল <।

বিধি

• এটি কোড-গল্ফ তাই সংক্ষিপ্ততম কোডটি জয়ী।
• বিল্টিনগুলি যা এটি সমাধান করে তা অনুমোদিত নয়।
• ইনপুট অ্যারেতে কেবল অবৈধ পূর্ণসংখ্যার মান বা অ্যারে থাকবে। প্রতিটি অ্যারে সমজাতীয় হবে, যার অর্থ এটির উপাদানগুলি কেবল অ্যারে বা কেবলমাত্র পূর্ণসংখ্যার দ্বারা হবে তবে উভয়ের মিশ্রণ কখনও হবে না।
• প্রতিটি সুবারে যে কোনও গভীরতায় বাসা বাঁধতে পারে।
• আউটপুট হয় স্ট্রিং বা স্ট্রিংগুলির অ্যারে হিসাবে যেখানে প্রতিটি স্ট্রিং আউটপুটের একটি লাইন may

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

[]
++
||
++

[[], []]
+---+
|+++|
|||||
|+++|
+---+

[[], [1], [], [2], [], [3], []]
+-----------+
|++-++-++-++|
|||1||2||3|||
|++-++-++-++|
+-----------+

[[[[[0]]]]]
+---------+
|+-------+|
||+-----+||
|||+---+|||
||||+-+||||
|||||0|||||
||||+-+||||
|||+---+|||
||+-----+||
|+-------+|
+---------+

[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+|1||
|||+---------+|||+-----+|||2 1|| ||
||||+-------+|||||3 2 1|||+---+| ||
|||||4 3 2 1|||||+-----+||     | ||
||||+-------+|||+-------+|     | ||
|||+---------+||         |     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

Comments

যদি আমার ভাষার কোনও নেস্টেড অ্যারে না থাকে, তবে আমি কি ডেটা টাইপের সংজ্ঞা উপেক্ষা করতে পারি?

— থ্রিএফএক্স

@ThreeFx এছাড়াও আপনি নেস্টেড অ্যারের প্রতিনিধিত্বমূলক একটি স্ট্রিং হিসাবে ইনপুট গ্রহণ করতে পারে

— মাইল

এটি আসলেই অদক্ষ (হাস্কেলের মধ্যে)। আমাকে নিজেও সংখ্যাগুলি পার্স করতে হবে ইত্যাদি। সেক্ষেত্রে ডেটাটাইপ সংজ্ঞায়িত ও ব্যবহার করা সংক্ষিপ্ত হবে।

— থ্রিএফএক্স

@ থ্রিএফএক্স বা আপনি সেন্ডিনেল মানগুলি দিয়ে অ্যারেটি প্যাড করতে পারেন যেমন -1যেহেতু আমি পূর্ণসংখ্যাকে অ-নেতিবাচক হতেও সীমাবদ্ধ করেছি। তারপরে কেবল সেইসব অবৈধ মানগুলির জন্য আউটপুট পরিষ্কার করতে হবে।

— মাইল

@ মিচসওয়ার্টজ শিওর, কোনও নেস্টেড টিপল ইনপুট নিন বা যে কোনও ফর্ম্যাট আপনার ভাষাতে স্থানীয়। আপনি যতক্ষণ ধারাবাহিক থাকবেন ততক্ষণ আপনার আউটপুট ঠিক আছে। পূর্ণসংখ্যাগুলি শীর্ষে, কেন্দ্র বা নীচে আঁকতে পারে এবং বাক্সগুলি আপনার উদাহরণের মতো তাদের স্থান পূরণ করতে উপরে, কেন্দ্র, নীচে বা প্রসারিত হতে পারে।

— মাইল মাইল

Answer 1

ডায়ালগ এপিএল , 56 বাইট

বাইটের প্রায় এক তৃতীয়াংশ অপসারণে সহায়তার জন্য এনএনজিকে ধন্যবাদ।

{⍵≡∊⍵:⍉⍪⍉⍕⍵⋄(⊢,⊣/)⊃,/(1⊖('++','|'⍴⍨≢),'-'⍪⍣2↑)¨↓↑↓¨∇¨⍵}⊂

TryAPL

ফাংশনটি সংজ্ঞায়িত করুন , তারপরে প্রতিটি পরীক্ষার কেস চালান এবং বিল্ট-ইন ]Displayইউটিলিটির সাথে তুলনা করুন ।
[1, 2, 3]
[[1, 2, 3], [4, 5], [6, 7, 8]]
[[[1, 2, 3], [4, 5]], [6, 7, 8]]
[]
[[], []]
[[], [1], [], [2], [], [3], []]
[[[[[0]]]]]
[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]

ব্যাখ্যা

সামগ্রিকভাবে, এটি {...}কোনও ঘেরের উপরে একটি বেনামে ফাংশন ⊂। পরেরটি বাসা বাঁধার আরও একটি স্তর যুক্ত করে প্রাক্তনকে বাইরের ফ্রেম যুক্ত করতে অনুরোধ করে।

সাদা-স্পেস সহ বেনামে ফাংশন ( ⋄এটি বিবৃতি বিভাজক):

{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    (⊢ , ⊣/) ⊃ ,/ (1 ⊖ ('++' , '|' ⍴⍨ ≢) , '-' ⍪⍣2 ↑)¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

এখানে এটি আবার, কিন্তু পৃথক ইউটিলিটি ফাংশন সহ:

CloseBox ← ⊢ , ⊣/
CreateVertical ← '++' , '|' ⍴⍨ ≢
AddHorizontals ← 1 ⊖ CreateVertical , '-' ⍪⍣2 ↑
{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    CloseBox ⊃ ,/ AddHorizontals¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

এখন আমি প্রতিটি ফাংশন ব্যাখ্যা করি:

CloseBoxএকটি টেবিল নেয় এবং একই টেবিলটি ফেরত দেয়, তবে টেবিলের ডানদিকে টেবিলের প্রথম কলাম যুক্ত করা হয়। সুতরাং, 1-বাই -3 টেবিলটি প্রদান করে XYZ, এই ফাংশনটি 1-বাই -4 টেবিলটি XYZXনিম্নরূপে প্রদান করবে:
 ⊢ যুক্তি (লিট। ডানদিকে যা রয়েছে)  বাম দিকের কলামে
 , প্রেন্টড
 ⊣/(লিট। প্রতিটি বাম-হ্রাস) সারি)

CreateVerticalএকটি টেবিল নিয়ে যায় এবং টেবিলের |পাশের অক্ষরগুলির সমন্বয়ে একটি স্ট্রিং দেয় যা দুটি +সারিটির সাথে মেলে দুটি এসকে চাপযুক্ত করে -। শেষ পর্যন্ত টেবিলটি চক্রাকারে এক +---...সারি উপরে এবং নীচে একক সারি পেতে ঘোরানো হবে । সুতরাং, যে কোনও তিনটি সারি সারণী দেওয়া হলে, এই ফাংশনটি ++|||নিম্নলিখিতভাবে ফিরে
 '++' , আসবে :  আর্গুমেন্টের (সারিগুলির) তালিকার
 '|' ⍴⍨ মাধ্যমে পুনরায় আকার দেওয়া একটি স্টাইলকে দুটি প্লাস চাপ দেওয়া হয়েছে
 ≢

AddHorizontalsতালিকাগুলির একটি তালিকা নেয়, এটি একটি টেবিলের মধ্যে তোলে, -শীর্ষে দুটি সারি যুক্ত করে, বামদিকে সংশ্লিষ্ট বাম প্রান্তগুলি যুক্ত করুন, তারপরে একটি সারিটি নীচে ঘোরান, যাতে টেবিলটির শীর্ষে একটি সীমানা থাকে , বাম এবং নীচে। নিম্নরূপ:
 1 ⊖ ঘোরান এক সারির (শীর্ষ সারি নীচে চলে যায়)
 CreateVertical , স্ট্রিং ++|||...(ক কলাম হিসাবে) prepended
 '-' ⍪⍣2 বিয়োগ শীর্ষে দুইবার যোগ
 ↑ তালিকা অফ তালিকা টেবিল থেকে রুপান্তরিত যুক্তি

{বেনামে ফাংশন }: যদি তর্কটি একটি সরল (নেস্টেড নয়) তালিকা হয় তবে এটি একটি অক্ষর সারণিতে তৈরি করুন (এইভাবে, 3-উপাদান তালিকা দেওয়া হয় 1 2 3, এই ফাংশনটি দৃশ্যত অদৃশ্য 1-বাই-পাঁচটি অক্ষরের টেবিলটি দেয় 1 2 3)। যদি আর্গুমেন্ট কোনও সহজ তালিকা না হয় তবে উপাদানগুলি সরল অক্ষরের টেবিলগুলি নিশ্চিত করুন; সমান উচ্চতা তাদের প্যাড; তাদের উপরে, নীচে এবং বামে প্রতিটি ফ্রেম করুন; তাদের একত্রিত; এবং অবশেষে খুব প্রথম কলামটি নিয়ে ডানদিকে যুক্ত করুন। নিম্নরূপ:
 { একটি বেনামী ফাংশন সংজ্ঞা শুরু
  ⍵ ≡ ∊⍵:যদি যুক্তি অভিন্ন যুক্তি চ্যাপ্টা হয় (অর্থাত এটা একটা সহজ তালিকা), তারপর:
   ⍉ পক্ষান্তরিত
   ⍪ columnized
   ⍉ পক্ষান্তরিত
   ⍕ ⍵ stringified যুক্তি; অন্য:
  CloseBox ডানদিকে বামতম কলাম যুক্ত করুন
  ⊃ ,/ প্রকাশিত (কারণ হ্রাস সংযুক্তি) সংক্ষিপ্ত-জুড়ে
  AddHorizontals¨ যুক্ত যুক্ত -প্রতিটি   কার্যক্রমে এই বেনাম  ফাংশনটির প্যাডড
  ↓ ↑ ↓¨ টু সমান উচ্চতা * এর প্রতিটি এবং উপরে নীচে এস যুক্ত করে বেনাম ফাংশন * লিট এর সংজ্ঞা শেষ করে Lit প্রতিটি টেবিলকে তালিকার তালিকায় তৈরি করুন, তালিকাগুলির তালিকাগুলি একত্রিত করুন (ছোট সারি পূরণের জন্য খালি স্ট্রিং সহ প্যাডিং) তালিকাগুলির তালিকাগুলির তালিকায় বিভক্ত করুন
  ∇¨ ⍵
 }

Answer 2

জাভাস্ক্রিপ্ট (ES6), 223 203 বাইট

f=(a,g=a=>a[0].map?`<${a.map(g).join`|`}>`:a.join` `,s=g([a]),r=[s],t=s.replace(/<[ -9|]*>|[ -9]/g,s=>s[1]?s.replace(/./g,c=>c>`9`?`+`:`-`):` `))=>t<`+`?r.join`\n`.replace(/<|>/g,`|`):f(a,g,t,[t,...r,t])

@ মিচশওয়ার্টিজের রুবি সলিউশন পোর্ট। পূর্ববর্তী সংস্করণ যা পুনরাবৃত্তভাবে অ্যারেগুলি মোড়ানো দ্বারা কাজ করেছিল (এবং কেবলমাত্র পূর্ণসংখ্যার জন্য নয় বরং স্বেচ্ছাসেবী সামগ্রীতে কাজ করেছে):

f=(...a)=>a[0]&&a[0].map?[s=`+${(a=a.map(a=>f(...a))).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[a.join` `]

দ্রষ্টব্য: যদিও আমি আমার যুক্তি তালিকায় স্প্রেড অপারেটরটি ব্যবহার করছি, পছন্দসই আউটপুটটি পেতে, মূল অ্যারের একক প্যারামিটার সরবরাহ করুন তবে অ্যারে ছড়িয়ে দেওয়ার চেষ্টা করে; এটি পছন্দসই বাইরের বাক্সে আউটপুট মোড়ানো এর প্রভাব ফেলে। দুঃখের সাথে বাইরের বাক্সটি আমার জন্য 18 বাইট খরচ করে এবং স্থান পৃথক করতে আমার 8 বাইট খরচ হয়, অন্যথায় নিম্নলিখিত বিকল্পের দৃশ্যধারণের জন্য 197 বাইট যথেষ্ট হবে:

f=a=>a.map?[s=`+${(a=a.map(f)).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(0,...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[``+a]

Comments

এটি কি খালি অ্যারেগুলি পরিচালনা করে? আমি Cannot read property 'map' of undefinedযেমন খালি অ্যারেগুলির জন্য একটি ত্রুটি পেয়েছি []। কারণ [1,2,[]], আমার জন্য শেষ সুবরেটি প্রদর্শিত হয় না।

— মাইল

@ মাইলস দুঃখিত, আমি পরীক্ষার কেসগুলি পরীক্ষা করতে ভুলে গেছি, এবং সেগুলি এখন সমস্ত কাজ করে। আপনি আউটপুটটি নির্দিষ্ট করেন নি [1,2,[]]কারণ আপনার উদাহরণগুলিতে কেবল পূর্ণসংখ্যা বা অ্যারে রয়েছে তবে উভয়ই অ্যারে প্রদর্শিত হবে।

— নিল

গ্রেট। এটিকেও কখনও মনে করবেন না, আমি পরীক্ষার ক্ষেত্রে এটি কভার করি নি এবং সমস্যাটি সহজ হবে (যেহেতু আপনার এখন পর্যন্ত একমাত্র কার্যকরী প্রবেশ) যদি প্রতিটি অ্যারে সমজাতীয় হয়।

— মাইল 11 ই

Answer 3

রুবি, 104 বাইট

->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

বেনামে ফাংশন যা একটি স্ট্রিং প্রত্যাশা করে। উদাহরণস্বরূপ, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}উত্পাদন করে

+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|         |     | ||
|||+---------+||+-------+|     | ||
||||+-------+||||+-----+||+---+| ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+||||+-----+||+---+| ||
|||+---------+||+-------+|     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

আপনি এই কোডটি পরীক্ষার জন্য ব্যবহার করতে পারেন:

f=->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

a=[]

a<<'[1, 2, 3]'
a<<'[[1, 2, 3], [4, 5], [6, 7, 8]]'
a<<'[[[1, 2, 3], [4, 5]], [6, 7, 8]]'
a<<'[]'
a<<'[[], []]'
a<<'[[], [1], [], [2], [], [3], []]'
a<<'[[[[[0]]]]]'
a<<'[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]'

a.map{|s|s.gsub! '], [','}{'
s.tr! '[]','{}'
s.gsub! ',',''
puts s
puts f[s],''}

এটি মধ্য সারি থেকে শুরু হয়ে বাইরের দিকে কাজ করে। প্রথমত, উদাহরণগুলি }{প্রতিস্থাপন করা হয় |। তারপরে, এখনও যখন ধনুর্বন্ধনী রয়েছে তখন সমস্ত অভ্যন্তরীণ {...}স্ট্রিংগুলি যথাযথ +-অনুক্রমগুলিতে রূপান্তরিত হয় এবং অন্যান্য অক্ষরগুলি |{}ফাঁকা জায়গায় পরিবর্তিত হয়। শেষে, মধ্যবর্তী বন্ধনীগুলি পাইপগুলিতে রূপান্তরিত হয়।

Comments

আপাতদৃষ্টিতে লেন্সিয়েন্ট ইনপুট ফর্ম্যাটিংয়ের প্রয়োজনীয়তা সহ আমি কিছু স্বাধীনতা নিয়েছি। প্রয়োজনে আলাদা ইনপুট ফর্ম্যাটটি পরিচালনা করতে কোডটি সহজেই সংশোধন করা যায়।

— মিচ শোয়ার্টজ

দুর্বলভাবে চিন্তাভাবনা করা মন্তব্যগুলি পাওয়া এই সাইটে অংশ নেওয়ার এক দুর্দান্ত আনন্দ।

— মিচ শোয়ার্টজ

Answer 4

ব্রেইনফাক, 423 বাইট

->>+>>,[[>+>+<<-]+++++[>--------<-]>[<+>-[[-]<-]]>[[-]<<[>>>>+<<<<<<-<[>-<-]>>>-
]<<<[-<<<<<<-<]>+>>>]<<<[>>+>>>>>+<<<<<<<-]>>>>>>>>>,]<<+[<<,++>[-[>++<,<+[--<<<
<<<<+]>]]<[-<+]->>>>[<++<<[>>>>>>>+<<<<<<<-]>>>-[<++>-[>>>>+<<<<<++<]<[<<]>]<[>>
+<<<<]>>>+>+>[<<<-<]<[<<]>>>>->+>[-[<-<-[-[<]<[<++<<]>]<[<++++<<]>]<[>+<-[.<<<,<
]<[<<]]>]<[-<<<<<]>>[-[<+>---[<<++>>+[--[-[<+++++++<++>>,]]]]]<+++[<+++++++++++>
-]<-.,>>]>>>>+>>>>]<<-]

কিছু মন্তব্যে ফর্ম্যাট করা:

->>+>>,
[
  [>+>+<<-]
  +++++[>--------<-]
  >
  [
    not open paren
    <+>-
    [
      not paren
      [-]<-
    ]
  ]
  >
  [
    paren
    [-]
    <<
    [
      close paren
      >>>>+<<<<
      <<-<[>-<-]>>>
      -
    ]
    <<<
    [
      open paren directly after close paren
      -<<<<<<-<
    ]
    >+>>>
  ]
  <<<[>>+>>>>>+<<<<<<<-]>>>
  >>>>>>,
]
<<+
[
  <<,++>
  [
    -
    [
      >++<
      ,<+[--<<<<<<<+]
      >
    ]
  ]
  <[-<+]
  ->>>>
  [
    <++<<[>>>>>>>+<<<<<<<-]>>>-
    [
      at or before border
      <++>-
      [
        before border
        >>>>+<<<<
        <++<
      ]
      <[<<]
      >
    ]
    <
    [
      after border
      >>+<<
      <<
    ]
    >>>+>+>
    [
      column with digit or space
      <<<-<
    ]
    <[<<]
    >>>>->+>
    [
      middle or bottom
      -
      [
        bottom
        <-<-
        [
          at or before border
          -
          [
            before border
            <
          ]
          <
          [
            at border
            <++<<
          ]
          >
        ]
        <
        [
          after border
          <++++<<
        ]
        >
      ]
      <
      [
        middle
        >+<
        -[.<<<,<]
        <[<<]
      ]
      >
    ]
    <[-<<<<<]
    >>
    [
      border char or space
      -
      [
        not space
        <+>---
        [
          not plus
          <<++>>
          +
          [
            --
            [
              -
              [
                pipe
                <+++++++<++>>,
              ]
            ]
          ]
        ]
      ]
      <+++[<+++++++++++>-]<-.,>>
    ]
    > >>>+>>>>
  ]
  <<-
]

এটি অনলাইনে চেষ্টা করুন।

ট্রেলিং করা (((((4 3 2 1))))(((3 2 1)))((2 1))(1))নতুন লাইনের মতো ইনপুট ফর্ম্যাট হওয়া আশা করে এবং ফর্মের আউটপুট উত্পাদন করে:

+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+| ||
|||+---------+|||+-----+|||   || ||
||||+-------+|||||     ||||   || ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+|||||     ||||   || ||
|||+---------+|||+-----+|||   || ||
||+-----------+|+-------+|+---+| ||
|+-------------+---------+-----+-+|
+---------------------------------+

বাসা বাঁধার গভীরতার উপর ভিত্তি করে কোন চরিত্রটি মুদ্রণ করতে হবে তা প্রাথমিক ধারণাটি ulate আউটপুট ফর্ম্যাটটি এমন যে একটি বাক্সের শীর্ষ সীমানার সারি সূচকটি মধ্য সারি জুড়ে প্রতিসাম্যতা সহ সংশ্লিষ্ট অ্যারের গভীরতার সমান।

টেপটি 7-সেল নোডে বিভক্ত হয়, প্রতিটি নোড আউটপুটে একটি কলামকে উপস্থাপন করে।

প্রথম লুপটি ইনপুট গ্রহণ করে এবং নোডগুলি সূচনা করে, গভীরতার উপর নজর রাখে এবং কলামটি কোনও প্রথম বন্ধনী (যেমন, কলামটিতে উল্লম্ব সীমানা রয়েছে কিনা) এর সাথে মিল রয়েছে কিনা )(এবং একক নোডের সংঘর্ষের ঘটনাগুলি ।

পরবর্তী লুপটি পুনরাবৃত্তির জন্য এক সারি আউটপুট করে। এই লুপের মধ্যে, অন্য লুপটি নোডগুলি ট্র্যাভার করে এবং পুনরাবৃত্তির জন্য একটি অক্ষর মুদ্রণ করে; এখানেই বেশিরভাগ কাজ ঘটে।

ইনিশিয়ালেশন লুপ চলাকালীন, একটি পুনরাবৃত্তির শুরুতে নোডের মেমরি বিন্যাস হয়

x d 0 c 0 0 0

xপূর্ববর্তী চরটি বন্ধকৃত প্রথম বন্ধনী ছিল কিনা, dগভীরতা (একাধিক) এবং cবর্তমান চরিত্রটি কিনা তার জন্য বুলিয়ান পতাকা কোথায় ।

অক্ষর মুদ্রণের লুপ চলাকালীন, পুনরাবৃত্তির শুরুতে নোডের মেমরি বিন্যাস হয়

0 0 d1 d2 c p y

যেখানে d1শীর্ষ অর্ধেকের জন্য সারি সূচকের সাথে তুলনা করা গভীরতা নির্দেশ করে; অর্ধেকের d2মতো d1তবে একইরকম ; cঅঙ্ক বা স্থান অন্যথায় শূন্য হলে সেই কলামটির ইনপুট চরিত্র; pপর্যায়টি নির্দেশ করে, অর্থাৎ উপরের অর্ধেক, মধ্যম বা নীচের অর্ধেক; এবং yএটি এমন একটি পতাকা যা বাম থেকে ডানে বাম দিকে প্রচারিত হয়, আমরা এখনও মাঝের সারিটিতে পৌঁছেছি কিনা তা ট্র্যাক করে। দ্রষ্টব্য যেহেতু yনোড প্রক্রিয়াজাতকরণের পরে শূন্য হয়, তাই আমরা yআরও কার্যকরী স্থান অর্জনের জন্য পূর্ববর্তী নোডের ঘরটি ব্যবহার করতে পারি ।

এই সেটআপটি সূচনা পর্বের সময় স্পষ্টভাবে সর্বাধিক গভীরতার গণনা এড়াতে আমাদের অনুমতি দেয়; সেই অনুযায়ী ঘরগুলি yআপডেট করার জন্য পতাকাটি আবার প্রচার করা হয় p।

একটা হল -1নোড কক্ষ বামদিকে নির্নয় সুবিধাজনক করতে, এবং নোড ঠিক কিনা আমরা এখনো শেষ সারি মুদ্রিত আছে ট্র্যাক রাখে করার জন্য একটি সেল রয়েছে।

Answer 5

পিএইচপি + এইচটিএমএল, প্রতিযোগিতা নয় ( 170 141 135 130 বাইট)

স্টিভড্রোজ দ্বারা অনুপ্রাণিত 29 বাইট সংরক্ষণ করেছেন

<?function p($a){foreach($a as$e)$r.=(is_array($e)?p($e):" $e");return"<b style='border:1px solid;float:left;margin:1px'>$r</b>";}

প্রতিযোগিতা করছেন না কারণ এটি কোন আস্কি আউটপুট নয় এবং কারণ আমি ব্রাউজারটিকে সমস্ত আকর্ষণীয় কাজ করতে দিয়েছি

Comments

<b>পরিবর্তে আপনি ট্যাগ তৈরি করতে পারেন <div>এবং এর রঙ নির্দিষ্ট করার দরকার নেই border। (9 বাইট সংরক্ষণ করা)

— স্টিটিড্রোজ

আপনার মোটেও একটি <ট্যাগ>

— লাগানোর

@ স্টিভেডরোজ এর সাথে <b>আমি white-spaceআরও 19 বাইট সংরক্ষণ করে এই বৈশিষ্ট্যটিও সরিয়ে ফেলতে পারি । মহান! এবং আমি এর paddingসাথে প্রতিস্থাপন করতে পারিmargin

— টাইটাস

Answer 6

জাভাস্ক্রিপ্ট (ES6), 221

একটি অ recursive ফাংশন একটি স্ট্রিং অ্যারের ফিরে (এখনও ভিতরে একটি recursive subfunction ব্যবহার করে)

a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

এটি 2 পদক্ষেপে কাজ করে।

পদক্ষেপ 1: পুনরাবৃত্তভাবে নেস্টেড ইনপুট অ্যারের স্ট্রিং উপস্থাপনা তৈরি করুন। উদাহরণ:

[[[1, 2, 3], [],[4, 5]], [6, 7, 8]] -> "OOO1 2 3,,4 5C,6 7 8CC"

Oএবং Cখোলা এবং নিকটবর্তী subarray চিহ্নিত করুন। সাধারণ সংখ্যাসূচক সাবহারিগুলি স্থান দ্বারা পৃথককৃত উপাদানগুলির সাথে রেন্ডার করা হয়, তবে অ্যারে সদস্যগুলি সাববারে হলে এগুলি কমা দ্বারা পৃথক করা হয়। এই স্ট্রিংটি ইনপুট অ্যারের মাল্টিলেভেল স্ট্রাকচারের উপর নজর রাখে, যখন আমি আউটপুটটির মাঝের সারিটি কেবলমাত্র প্রতিস্থাপন OC,করে পেতে পারি |। পুনরাবৃত্তভাবে এই টেম্প স্ট্রিংটি তৈরি করার সময়, আমি সর্বাধিক গভীরতার স্তরও খুঁজে পাই এবং খালি স্ট্রিংগুলির একটি অ্যারে শুরু করি যা আউটপুটটির অর্ধেক শীর্ষ অংশটি ধারণ করে।
দ্রষ্টব্য: বাইরের বাক্সটি জটিল, আমি অন্য বাইরের অ্যারের ভিতরে ইনপুটটি নীড় করে ফেলেছি, তারপরে আমি আউটপুটটির প্রথম সারিটি ফেলে রেখেছি যা প্রয়োজন নেই

পদক্ষেপ 2: টেম্প স্ট্রিংটি স্ক্যান করুন এবং আউটপুট তৈরি করুন

এখন আমার কাছে খালি স্ট্রিংগুলির একটি অ্যারে রয়েছে, প্রতিটি স্তরের জন্য একটি। আমি বর্তমান স্তরের উপর নজর রেখে টেম্পিং স্ট্রিংটি স্ক্যান করি যা প্রতিটিটির জন্য বৃদ্ধি Oপায় এবং প্রতিটিটির জন্য হ্রাস পায় C। আমি এটির মতো ভিজ্যুয়ালাইজ করি:

[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]

OOO1 2 3,,4 5C,6 7 8CC
+                    +
 +            +     +
  +     ++   +
|||1 2 3||4 5||6 7 8||

প্লাস আপ এবং ডাউন বর্তমান স্তরের অনুসরণ করে

প্রতিটি চরের জন্য, আমি নিয়মগুলি অনুসরণ করে আউটপুটের প্রতিটি সারিটিতে একটি অক্ষর যুক্ত করি:
- যদি অঙ্ক বা স্থান হয় তবে বর্তমান স্তরে এবং নীচে একটি '-' রাখুন, উপরে একটি স্থান রাখুন
- অন্যথায়, '+' রাখুন বর্তমান স্তরটি, নীচে থাকলে একটি '-' রাখুন এবং '|' রাখুন উপরে যদি

OOO1 2 3,,4 5C,6 7 8CC
+--------------------+
|+------------+-----+|
||+-----++---+|     ||
|||1 2 3||4 5||6 7 8||

টেম্প স্ক্যান করার সময় আমিও গড়ে তুলতে মধ্যম সারি প্রতিস্থাপন OC,সঙ্গে|

এই পদক্ষেপের শেষে, আমার উপরের অর্ধেক এবং মাঝারি সারি রয়েছে, নীচের অর্ধেক পেতে আমাকে কেবল শীর্ষটি আয়না করতে হবে এবং আমার কাজ শেষ হয়েছে

কম গল্ফড, মন্তব্য করা কোড

a=>{
   r = []; // output array
   R = ( // recursive scan function
     a, // current subarray 
     l  // current level
   ) => (
     r[l] = '', // element of r at level r, init to ""
     a[0] && a[0].map // check if it is a flat (maybe empty) array or an array of arrays
     ? 'O'+a.map(v=>R(v,l+1))+'C' // mark Open and Close, recurse
     : a.join` ` // just put the elements space separated
   );
   T = R([a],-1)]; // build temp string
   // pass the input nested in another array 
   // and start with level -1 , so that the first row of r will not be visible to .map

   // prepare the final output
   m = '' // middle row, built upon the chars in T
   l = -1 // starting level
   [...T].map(c => // scan the temp string
         {
            k = l; // current level
            1/c // check if numeric or space
             ? v = '-- ' // use '-','-',' '
             : (
                 v = '-+|', // use '-','+','|'
                 c > 'C' 
                   ? k=++l // if c=='O', increment level and assign to k
                   : c>'A'&&--l, // if c=='C', decrement level (but k is not changed)
                 c='|' // any of O,C,comma must be mapped to '|'
               );
            m += c; // add to middle row
            r = r.map( (x,i) => // update each output row
                       // based on comparation between row index and level
                       // but in golfed code I don't use the i index
                       // and decrement l at each step  
                       x + v[(k<i)*2+!(k-i)]
                     )
         })
   // almost done!  
   return [...r,m,...r.reverse()]

)

পরীক্ষা

F=
a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

out=x=>O.textContent = x+'\n'+O.textContent

;[[1,2,3]
,[[[1, 2, 3], [4, 5]], [6, 7, 8]]
,[]
,[[], []]
,[[], [1], [], [2], [], [3], []]
,[[[[[0]]]]]
,[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
].forEach(t=>
  out(JSON.stringify(t)+'\n'+F(t).join`\n`+'\n')
)  

function update()
{
  var i=eval(I.value)
  out(JSON.stringify(i)+'\n'+F(i).join`\n`+'\n')
}

update()

#I { width:90%}

<input id=I value='[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]' oninput='update()'>
<pre id=O></pre>

Answer 7

রুবি, 245 241 বাইট

ওভারহেড সমস্ত কিছু বাক্সে মোড়ানোর পাশাপাশি সমস্ত কিছু সারিবদ্ধ করার জন্য বেশ ভারী ...

অনুমান অনুযায়ী স্ট্রিংয়ের অ্যারেগুলিকে প্রতি লাইনে একটি স্ট্রিং দিয়ে আউটপুট দেয়। শীর্ষ-প্রান্তিকৃত নমুনা পরীক্ষার কেসগুলির পরিবর্তে নীচে-প্রান্তিককরণ কারণ এটি 1 বাইট সংরক্ষণ করে।

এটি অনলাইন চেষ্টা করুন!

V=->a{a==[*a]?(k=a.map(&V);k[0]==[*k[0]]?[h=?++?-*((k.map!{|z|z[1,0]=[' '*~-z[0].size+?|]*(k.map(&:size).max-z.size);z};f=k.shift.zip(*k).map{|b|?|+b.reduce{|r,e|r+e[1..-1]}+?|})[0].size-2)+?+,*f,h]:[h="+#{?-*(f=k*' ').size}+",?|+f+?|,h]):a}

Comments

@ অ্যাডাম এটি এখন ঠিক। পরে আরও অনুকূলিত করার জন্য যথাসাধ্য চেষ্টা করব ...

— মান কালি

নীচের সারিবদ্ধকরণের সাথে চমৎকার F প্রথম উত্তর। :-)

— অ্যাডম

Answer 8

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

সমস্ত সমাধানগুলি অ্যারের সর্বাধিক গভীরতার সাথে কম পরিমাণে 10 পরে কাজ করে greater

<?foreach(str_split(json_encode($_GET[a]))as$j){$j!="]"?:$c--;$r=($j==",")?($l=="]"?"":" "):$j;$r=$r=="]"?"|":$r;$r=$r=="["?($v=="]"?"":"|"):$r;if($r!=""){$n.=$r;$d.=+$c;}$v=$l;$l=$j;$j!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

সম্প্রসারিত

foreach(str_split(json_encode($_GET[a]))as$j){ # split JSON representation of the array
    $j!="]"?:$c--;
    $r=($j==",")?($l=="]"?"":" "):$j;
    $r=$r=="]"?"|":$r;
    $r=$r=="["?($v=="]"?"":"|"):$r;
    if($r!=""){
      $n.=$r;  # concanate middle string
      $d.=+$c; # concanate depth position
    }
    $v=$l;
    $l=$j;
    $j!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
# Build the strings before the middle string dependent of value middle string and depth 
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z))); #Output

425 বাইটের জন্য আমরা এটি REGEX দিয়ে তৈরি করতে পারি

<?$n=($p=preg_filter)("#\]|\[#","|",$r=$p("#\],\[#","|",$p("#,(\d)#"," $1",json_encode($_GET[a]))));preg_match_all("#.#",$r,$e,256);foreach($e[0] as$f){$f[0]!="]"&&$f[0]!="|"?:$c--;$d.=+$c;$f[0]!="|"&&$f[0]!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

সম্প্রসারিত

$r=preg_filter("#\],\[#","|",preg_filter("#,(\d)#"," $1",json_encode($_GET[a])));
preg_match_all("#.#",$r,$e,256);
$n=preg_filter("#\]|\[#","|",$r); # concanate middle string
foreach($e[0] as$f){
    $f[0]!="]"&&$f[0]!="|"?:$c--;
    $d.=+$c; concanate depth position
    $f[0]!="|"&&$f[0]!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
# similar to the other ways
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

455 একটি পুনরাবৃত্ত সমাধানের জন্য বাইট

<?function v($x,$t=0,$l=1){global$d;$d.=$t;$s="|";$c=count($x);foreach($x as$k=>$v){if(is_array($v))$e=v($v,$t+1,$k+1==$c);else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}$s.=$e;}$d.=$l?$t:"";$s.=$l?"|":"";return$s;}$n=v($_GET[a]);$m=max(str_split($d));for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

সম্প্রসারিত

function v($x,$t=0,$l=1){
    global$d; # concanate depth position
    $d.=$t;
    $s="|";
    $c=count($x);
    foreach($x as$k=>$v){           
        if(is_array($v)){$e=v($v,$t+1,$k+1==$c);}
        else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}
        $s.=$e;
    }
    $d.=$l?$t:"";
    $s.=$l?"|":"";
    return$s;
}
$n=v($_GET[a]); # concanate middle string
$m=max(str_split($d)); # maximum depth of the array
# similar to the other ways 
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

Comments

1) $j!="]"?:$c--;-> $c-=$j=="]";(-2)। 2) ($l=="]"?"":" ")-> " "[$l==$j](-5)। দ্বিতীয় লুপে সম্ভবত একই রকম বিকল্প। 3) if($r!=""){$n.=$r;$d.=+$c;}-> $n.=$r;if($r>"")$d.=+$c;(-3)। 4) $l=$j;$j!="["?:$c++;-> $c+="["==$l=$j;(-5)। 5) $x=0প্রয়োজন হয় না (-4)। 6) for($y=0;$y<$m;$y++)-> for($y=$m;$y--;)(-4)। 7) join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));-> join("\n",array_merge($z,[$n],array_reverse($z)));(-4) 8) অপ্রয়োজনীয় সাদা স্থান: foreach($e[0]as$f)(-1)

— তিতাস

9) ($j==",")(-2) এ অপ্রয়োজনীয় প্রথম বন্ধনী । 10) if($r>"")$d.=+$c;-> $d.=$r>""?+$c:"";(-0)

— তিতাস

পুনরাবৃত্ত সংস্করণ: 1) $d.=$l?$t;অপ্রচলিত (-10) 2) $s.=$l?"|":"";return$s;-> return$s."|"[$l];(-6)। 3) অপ্রচলিত বন্ধনী {$e=v($v,$t+1,$k+1==$c);}(-2)। 4) {$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}-> $d.=str_pad("",strlen($e=$v." "[$k+1==$c]),$t+1);(-5)।

— তিতাস