可视化数组

26

给定任意深度的数组，请使用+-|每个子数组周围的边框绘制其内容。这些是加号，减号和垂直管道的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]。您可以在最上面，中间或最下面的一行上绘制内容，但是无论选择哪种内容，都必须保持一致。

这个挑战是由灵感箱动词<从J.

规则

  • 这是代码高尔夫球，因此最短的代码获胜。
  • 不允许使用解决此问题的内建函数。
  • 输入数组将仅包含非负整数值或数组。每个数组将是同质的，这意味着其元素将仅由数组或仅由整数组成，而不是两者的混合。
  • 每个子阵列可以嵌套到任何深度。
  • 输出可以是字符串，也可以是字符串数组，其中每个字符串都是输出行。

测试用例

[]
++
||
++

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

[[], [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|||||+-----+||     | ||
||||+-------+|||+-------+|     | ||
|||+---------+||         |     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+
code-golf  ascii-art 
— 英里
source
如果我的语言没有嵌套数组，是否可以忽略数据类型的定义？
— ThreeFx
1
@ThreeFx您也可以将输入作为代表嵌套数组的字符串
— 英里
那真的是低效的（在Haskell中）。我不得不手动解析数字，依此类推。在这种情况下，定义和使用数据类型会更短。
— ThreeFx
@ThreeFx或者您可以使用定点值填充数组，例如，-1因为我还将整数限制为非负数。然后只需要清除那些无效值的输出即可。
— 英里
1
@MitchSchwartz当然，请使用嵌套元组或您的语言固有的任何格式输入。只要您保持一致，输出就可以了。可以在顶部，中心或底部绘制整数，并且可以在顶部，中心，底部或拉伸框以填充其空间（如您的示例）。
— 英里

Answers:

4

Dyalog APL，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×3表XYZ，此函数返回的1 - 4表XYZX，如下所示：
 ⊢ 参数（文献什么是右侧）
 , 预置到
 ⊣/ 最左列（点亮左还原每个行）

CreateVertical取得表格并返回一个字符串，该字符串由适合|于表侧面s 的字符组成，但带有两个+s前缀以匹配。的两行-。最终，该表将循环旋转一行，以使+---...上下一行。因此，给定任何三行表，此函数将返回++|||，如下所示：
 '++' , 两个加号被加到
 '|' ⍴⍨ 由参数
 ≢ 的（行）计数重塑的阶梯上

AddHorizontals将一个列表列表放入表格中，-在顶部添加两行s，在左侧添加相应的左边缘字符，然后将其旋转到底部，从而使表格在顶部具有边框，左侧和底部。如下所示：
 1 ⊖ 将前缀
 CreateVertical , 的字符串的 第一行（第一行转到底部）++|||...（作为一列）旋转为
 '-' ⍪⍣2 负，
 ↑ 从列表列表转换为表的参数顶部加两次

{匿名函数}：如果参数是一个简单的（非嵌套）列表，请将其放入字符表（因此，给定3元素列表1 2 3，此函数将返回视觉上相同的1 x 5字符表1 2 3）。如果参数不是简单列表，请确保元素是简单字符表；否则，请参见图3。将它们垫到相等的高度；分别在其顶部，底部和左侧构图；结合起来；最后将第一列添加到右侧。如下所示：如果参数与展平的参数相同（即，它是一个简单的列表），则
 { 开始定义匿名函数
  ⍵ ≡ ∊⍵:；然后：
   ⍉ 转置
   ⍪ 列化的
   ⍉ 转置
   ⍕ ⍵ 字符串化参数；否则：
  CloseBox 将最左侧的列添加到的右侧
  ⊃ ,/  应用于每个自变量 的此匿名函数的每个填充到相等高度*的顶部和底部 所公开的（因为括起来）串联了
  AddHorizontals¨ 加号，从而 结束了匿名函数 * Lit 的定义。使每个表成为列表列表，将列表列表（用空字符串填充以填充短行）组合成表，然后将表拆分为列表列表-
  ↓ ↑ ↓¨
  ∇¨ ⍵
 }

— 亚当
source
7

JavaScript的（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])

@MitchSchwartz的Ruby解决方案的端口。以前的版本通过递归包装数组来工作（因此适用于任意内容，而不仅仅是整数）：

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]
— 尼尔
source
这会处理空数组吗？我收到Cannot read property 'map' of undefined空数组（例如）的错误[]。对于[1,2,[]]，没有为我显示最后一个子数组。
— 2016年
@miles对不起，我忘了签出测试用例，现在这些都可以了。您没有指定输出，[1,2,[]]因为您的示例仅显示包含整数或数组的数组，但不包含两者。
— 尼尔
大。同样不要介意，我没有在测试用例中进行介绍，并且如果每个数组都是同质的，那么这个问题会更简单（因为到目前为止您的唯一工作项）。
— 2016年
3

Ruby，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],''}

这从中间行开始，向外进行。首先，将的实例}{替换为|。然后，当仍然有花括号时，所有最里面的{...}字符串都将转换为适当的+-序列，而其他字符|{}则转换为空格。最后，中间支架变成管道。

— 米奇·施瓦兹（Mitch Schwartz）
source
我似乎对宽大的输入格式要求有所保留。如果需要，可以轻松地修改代码以处理不同的输入格式。
— 米奇·施瓦兹
接受思想较差的评论是参与此站点的最大乐趣之一。
— 米奇·施瓦兹
3

Brainfuck，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节点左侧有一个单元格，以方便导航，节点右侧有一个单元格，用于跟踪我们是否已打印最后一行。

— 米奇·施瓦兹（Mitch Schwartz）
source
2

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>";}

不竞争是因为它没有ascii输出，而且因为我让浏览器完成了所有有趣的工作

— 提图斯
source
1
您可以<b>标记而不是，<div>而无需指定的颜色border。（节省9个字节）
— SteeveDroz '16
您根本不需要放置<tag>，只需将输出显示为纯文本即可，这将节省大量字节（HTML删除后整个代码为80字节）
— ClementNerma
@SteeveDroz使用<b>，我还可以删除该white-space属性，另外节省19个字节。大！我可以替换padding为margin
— Titus，
2

JavaScript（ES6），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()]

这将分两步进行。

步骤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>
展开摘要

— edc65
source
2

Ruby，245241字节

将所有东西包装在盒子中以及对齐所有东西的开销非常重...

根据规范输出字符串数组，每行一个字符串。底部对齐而不是顶部对齐的示例测试用例，因为它节省了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}
— 价值墨水
source
@Adám，现在已修复。稍后将尽我最大的努力进行优化……
— Value Ink
不错，第一个答案与底部对齐。:-)
— 亚当
1

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字节，我们可以使用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)));
— 约格·赫尔瑟曼
source
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）
— Titus
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）。
— 泰特斯
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.