एक सरणी कल्पना

Question

किसी भी गहराई की एक सरणी को देखते हुए, अपनी सामग्री को +-|प्रत्येक सबर्रे के चारों ओर की सीमाओं के साथ आकर्षित करें । वे प्लस, माइनस और वर्टिकल पाइप के लिए ASCII अक्षर हैं।

उदाहरण के लिए, यदि सरणी है [1, 2, 3], तो ड्रा करें

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

नेस्टेड सरणी के लिए जैसे [[1, 2, 3], [4, 5], [6, 7, 8]], ड्रा

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

जैसे कि रैग्ड सरणी के लिए [[[1, 2, 3], [4, 5]], [6, 7, 8]], ड्रा करें

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

ध्यान दें कि ड्राइंग के बाद अधिक जगह है [6, 7, 8]। आप या तो शीर्ष-सर्वाधिक, केंद्र या नीचे-सबसे अधिक पंक्ति में सामग्री आकर्षित कर सकते हैं, लेकिन जो भी आप चुनते हैं, आपको निरंतर रहना चाहिए।

यह चुनौती जे से बॉक्स क्रिया <से प्रेरित थी ।

नियम

• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।
• इसे हल करने वाले बिल्डरों को अनुमति नहीं है।
• इनपुट सरणी में केवल nonnegative पूर्णांक मान या सरणियाँ होंगी। प्रत्येक सरणी समरूप होगी, जिसका अर्थ है कि इसके तत्व या तो केवल सरणियों या केवल पूर्णांकों द्वारा होंगे, लेकिन दोनों का मिश्रण कभी नहीं।
• प्रत्येक सबर्रे को किसी भी गहराई तक घोंसला दिया जा सकता है।
• आउटपुट या तो स्ट्रिंग के रूप में या स्ट्रिंग्स के एक सरणी के रूप में हो सकता है जहां प्रत्येक स्ट्रिंग आउटपुट की एक पंक्ति है।

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

[]
++
||
++

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

[[], [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 आप इनपुट को एक स्ट्रिंग के रूप में भी ले सकते हैं जो नेस्टेड सरणी का प्रतिनिधित्व करता है

— मील

यह वास्तव में अक्षम है (हास्केल में)। मुझे संख्याओं को मैन्युअल रूप से पार्स करना होगा। उस स्थिति में डेटाटाइप को परिभाषित करना और उसका उपयोग करना कम होगा।

— थ्री एफएक्स

@ThreeFx या आप संतरी मानों के साथ सरणी को पैड कर सकते हैं जैसे कि -1मैंने पूर्णांकों को भी गैर-नकारात्मक होने तक सीमित कर दिया है। फिर बस उन अवैध मूल्यों के लिए आउटपुट को साफ करना होगा।

— मील

@MitchSchwartz ज़रूर, इनपुट को नेस्टेड ट्यूपल में या जो भी स्वरूप आपकी भाषा का मूल है। जब तक आप सुसंगत रहते हैं तब तक आपका आउटपुट ठीक रहता है। इंटेगर को सबसे ऊपर, केंद्र, या नीचे की ओर खींचा जा सकता है, और बॉक्स आपके उदाहरण की तरह अपने स्थान को भरने के लिए शीर्ष, केंद्र, नीचे या फैला हो सकता है।

— मील

Answer 1

दिल्लोग एपीएल , 56 बाइट्स

बाइट्स के एक तिहाई को हटाने में मदद करने के लिए ngn के लिए धन्यवाद।

{⍵≡∊⍵:⍉⍪⍉⍕⍵⋄(⊢,⊣/)⊃,/(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-by-3 तालिका को देखते हुए XYZ, यह फ़ंक्शन 1-by-4 तालिका लौटाता है, इस XYZXप्रकार है:
 ⊢ तर्क (lit. दाईं ओर क्या है)  बाईं ओर के कॉलम
 , से
 ⊣/पहले प्रज्ज्वलित किया गया (प्रत्येक के बाएं-कमी पंक्ति)

CreateVerticalएक टेबल लेता है और एक स्ट्रिंग देता है जिसमें अक्षर होते हैं जो |टेबल के किनारों पर फिट होते हैं , लेकिन +दो पंक्तियों के मिलान के लिए दो एस के साथ -। आखिरकार तालिका को +---...ऊपर और नीचे एक एकल पंक्ति प्राप्त करने के लिए एक पंक्ति में चक्रीय रूप से घुमाया जाएगा । इस प्रकार, किसी भी तीन पंक्ति तालिका को देखते हुए, यह फ़ंक्शन लौटता है ++|||,  इस तर्क से (पंक्तियों ') के अनुसार
 '++' , दो प्लस
 '|' ⍴⍨ एक स्टाइल के पुनर्जीवन
 ≢के लिए तैयार हैं।

AddHorizontalsएक सूची-सूची लेता है, इसे एक तालिका में बनाता है, -शीर्ष पर एस की दो पंक्तियाँ जोड़ता है, बाएँ किनारे पर संबंधित बाएँ किनारे वर्ण जोड़ता है, फिर नीचे एक पंक्ति घुमाता है, ताकि तालिका के शीर्ष पर एक सीमा हो , छोड़ दिया, और नीचे। निम्नानुसार:  स्ट्रिंग की
 1 ⊖ एक पंक्ति (शीर्ष पंक्ति नीचे की ओर जाती है) को घुमाया गया है (  तालिका में स्तंभ के रूप में)  शून्य से दो बार सूची के सूचियों से तालिका में तब्दील तर्क के शीर्ष पर जोड़ा गया।
 CreateVertical ,++|||...
 '-' ⍪⍣2
 ↑

{अनाम फ़ंक्शन }: यदि तर्क एक सरल (नेस्टेड नहीं) सूची है, तो उसे एक वर्ण तालिका में बनाएं (इस प्रकार, 3-तत्व सूची को देखते हुए 1 2 3, यह फ़ंक्शन नेत्रहीन समान 1-बाय-पाँच वर्ण तालिका देता है 1 2 3)। यदि तर्क एक साधारण सूची नहीं है, तो सुनिश्चित करें कि तत्व सरल चरित्र तालिका हैं; उन्हें बराबर ऊंचाई तक पैड; प्रत्येक को उनके शीर्ष, नीचे और बाएं पर फ्रेम करें; उन्हें मिलाएं; और अंत में पहला कॉलम लें और इसे दाईं ओर जोड़ें। के रूप में इस प्रकार है:
 { एक गुमनाम समारोह की परिभाषा शुरू
  ⍵ ≡ ∊⍵:करता है, तो तर्क समान तर्क चपटा है (यानी यह एक सरल सूची है), तो:
   ⍉ स्थानांतरित
   ⍪ columnized
   ⍉ स्थानांतरित
   ⍕ ⍵ stringified तर्क; और:
  CloseBox दाईं ओर सबसे बाएं कॉलम को जोड़ें
  ⊃ ,/ खुलासा (क्योंकि कमी संलग्न है) संक्षिप्त-भर में प्रत्येक के ऊपर और नीचे
  AddHorizontals¨ जोड़ -पर   इस अनाम फ़ंक्शन के प्रत्येक
  ↓ ↑ ↓¨ पेड-टू-बराबरी-ऊँचाई *
  ∇¨ ⍵प्रत्येक तर्कों पर लागू होने
 } वाले अनाम फ़ंक्शन
* Lit की परिभाषा को समाप्त करता है । प्रत्येक तालिका को सूची-सूचियों में शामिल करें, सूचियों को संयोजित करें (छोटी पंक्तियों को भरने के लिए खाली तारों के साथ पैडिंग), फिर तालिका को सूचियों की सूची में विभाजित करें

Answer 2

जावास्क्रिप्ट (ईएस 6), 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])

@ MitchSchwartz का रूबी समाधान। पिछला संस्करण जिसने सरणियों को पुनरावर्ती रूप से लपेटकर काम किया (और इसलिए मनमाना सामग्री के लिए काम किया, न कि केवल पूर्णांक):

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,[]]क्योंकि आपके उदाहरण केवल पूर्णांक या सरणियों वाले सरणियों को दिखाते हैं लेकिन दोनों नहीं।

— नील

महान। यह भी कभी भी बुरा न मानें कि मैंने इसे परीक्षण के मामलों में शामिल नहीं किया था और समस्या सरल होगी (क्योंकि अब तक आप एक ही काम कर रहे हैं) यदि प्रत्येक सरणी समरूप है।

— मील

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||
||||+-------+|||||     ||||   || ||
|||+---------+|||+-----+|||   || ||
||+-----------+|+-------+|+---+| ||
|+-------------+---------+-----+-+|
+---------------------------------+

मूल विचार यह है कि घोंसले की गहराई के आधार पर किस वर्ण को प्रिंट करना है। आउटपुट स्वरूप ऐसा होता है कि किसी बॉक्स की शीर्ष सीमा का पंक्ति सूचकांक, मध्य पंक्ति के समरूपता के साथ संबंधित सरणी की गहराई के बराबर होता है।

टेप को 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

PHP + HTML, प्रतिस्पर्धा नहीं ( 170 141 135 130 बाइट्स)

SteeveDroz से प्रेरित 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 बाइट्स की बचत)

— 15

आपको एक <टैग> डालने की आवश्यकता नहीं है, बस आउटपुट को सादे पाठ के रूप में प्रदर्शित करें, जो कि बहुत सारे बाइट्स (HTML हटाने के बाद पूरे कोड के लिए 80 बाइट्स)

— बचाएगा

@SteeveDroz साथ <b>, मैं white-spaceएक और 19 बाइट्स बचाते हुए, विशेषता को भी हटा सकता हूं । महान! और मैं जगह ले सकता है paddingके साथmargin

— टाइटस

Answer 6

जावास्क्रिप्ट (ईएस 6), 221

एक गैर पुनरावर्ती फ़ंक्शन स्ट्रिंग्स की एक सरणी लौटाता है (अभी भी अंदर एक पुनरावर्ती सबफ़ंक्शन का उपयोग करके)

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खुले और बंद उप-चिह्न को चिह्नित करें। साधारण संख्यात्मक उपग्रहों को अंतरिक्ष द्वारा अलग किए गए तत्वों के साथ प्रदान किया जाता है, जबकि यदि सरणी सदस्य उप-प्रकार हैं तो वे अल्पविराम द्वारा अलग किए जाते हैं। यह स्ट्रिंग इनपुट सरणी के बहुस्तरीय संरचना का ट्रैक रखता है, जबकि मैं आउटपुट की मध्य पंक्ति को केवल 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

@ अब यह तय हो गया है। आगे बाद में अनुकूलन करने के लिए अपनी पूरी कोशिश करेंगे ...

— मूल्य इंक

नीस.पहली उत्तर नीचे संरेखण के साथ। :-)

— एडमंड

Answer 8

PHP, 404 बाइट्स

सभी समाधान सरणी की अधिकतम गहराई के साथ कम काम करते हैं। 10. अधिक से अधिक मूल्यों के लिए गहराई को एक सरणी में संग्रहीत करना चाहिए और एक स्ट्रिंग में नहीं।

<?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 बाइट्स के लिए हम इसे रेजेक्स के साथ बना सकते हैं

<?$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)।

— टाइटस