第一个完成于前辈的Ascii多维数据集（PAC 1）是边长为1的简单多维数据集，看起来像这样：

 /////\
/////  \
\\\\\  /
 \\\\\/

的PAC 2是几何形状，使得它与它的前辈（组合 PAC 1）完成了一个边长2立方体：

      front                back
   /////////\           /////////\
  /////////  \         /////////  \
 /////\\\\\   \       /////////    \
/////  \\\\\   \     /////////      \
\\\\\  /////   /     \\\\\\\\\      /
 \\\\\/////   /       \\\\\\\\\    /
  \\\\\\\\\  /         \\\\\\\\\  /
   \\\\\\\\\/           \\\\\\\\\/

因为后视图有点无聊，所以我们只对前视图感兴趣。

这同样适用于所述PAC 3：对于某些视觉思维的PAC 2可以转头插入PAC 3以形成固体边长3立方体：

     /////////////\
    /////////////  \
   /////\\\\\\\\\   \
  /////  \\\\\\\\\   \
 /////   /////\\\\\   \
/////   /////  \\\\\   \
\\\\\   \\\\\  /////   /
 \\\\\   \\\\\/////   /
  \\\\\  /////////   /
   \\\\\/////////   /
    \\\\\\\\\\\\\  /
     \\\\\\\\\\\\\/

以PAC 4依此类推：

       /////////////////\
      /////////////////  \
     /////\\\\\\\\\\\\\   \
    /////  \\\\\\\\\\\\\   \
   /////   /////////\\\\\   \
  /////   /////////  \\\\\   \
 /////   /////\\\\\   \\\\\   \
/////   /////  \\\\\   \\\\\   \
\\\\\   \\\\\  /////   /////   /
 \\\\\   \\\\\/////   /////   / 
  \\\\\   \\\\\\\\\  /////   /
   \\\\\   \\\\\\\\\/////   /
    \\\\\  /////////////   /
     \\\\\/////////////   /
      \\\\\\\\\\\\\\\\\  /
       \\\\\\\\\\\\\\\\\/

任务：

编写一个完整的程序或函数，以正整数n作为输入，并完全按照上面所示返回或打印PAC n的相应前视图。可以接受其他尾随空格。

这是code-golf，因此请尝试使用您选择的语言使用尽可能少的字节。

JavaScript（ES6），229字节

f=
(n,l=n*4+1,r=1,i=n*2,g=a=>` / \\ /
`.replace(/./g,c=>c.repeat(a.pop())))=>n?g([r,,l,--i])+g([r,2,l,--i])+f(n-1,l-1?1:r-4,r-1?1:l-4).replace(/(\S).*(.)/g,r-1?`$1   $&$2$2$2$2`:`$1$1$1$1$&   $2`)+g([r,2,l,,,i])+g([r,,l,,,i+1]):``

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

批，559个 432 400字节

@echo off
set m=
for /l %%i in (1,1,%1)do call set m=  %%m%%
call:c "%m:~2%" %m: =//%/\
exit/b
:c
setlocal
set m=%~1%2%~3
echo  %m%
echo %m:/\=/  \%
set s=%~1
if "%s:~,1%"=="/" goto g
set t=%2
set t=%t:~3,-3%
if %t:~,1%==/ (call:c "%s:~2%////" /\%t:/=\% "   \%~3")else call:c "%s:~2%/   " %t:\=/%/\ "\\\\%~3"
:g
set m=%m:/=-%
set m=%m:\=/%
set m=%m:-=\%
echo %m:\/=\  /%
echo  %m%

说明：立方体的下半部分通过反射上半部分绘制。根据上图显示的上半部分，将两半进一步分成七个 六个三个条的部分：

1       12/////////////////\233
1      12/////////////////  \233
1     ////12/\\\\\\\\\\\\\23   \3
1    ////12/  \\\\\\\\\\\\\23   \3
1   /////   12/////////\23\\\\   \3
1  /////   12/////////  \23\\\\   \3
1 /////   ////12/\\\\\23   \\\\\   \3
1/////   ////12/  \\\\\23   \\\\\   \3

1. 缩进（每行减少）和左三角形，每隔增加一行
2. 中间的曲折三角形，小三角形每隔一行交替出现
3. 右边的三角形，与左边同步增加

编辑：通过改进将上半部分反映到下半部分的代码，节省了20％以上的代码。通过合并左边的两个和中间的三个条，节省了将近10％。

画布，36 字节

；Ｘø；｛１ｘ／╋
ø╶｛«５⁸２²４×⁸²«１╋²«＼＋；↔５３╋｝═

在这里尝试！

SOGL V0.12，32 个字节

ø.∫4*I└*2∙f«5└*∙+¼F«╝┼;↔±53╬5}╬±

在这里尝试！

简单的解释：
1.对1..x中的每一个进行迭代
2.制作⌐宽度i*4+1和高度= (0-indexed)i // 2
3 的形状。将其填充以使其看起来像⦧
4.将“ \”形状水平地附加到该形状上
5.插入上一步里面的东西反转了6.一切之后，垂直镜像

完整程序：

ø                                 push an empty string - starting stage
 .∫                          }    iterate over 1..input
   4*                               multiply the 1-indexed counter by 4
     I                              and add 1
      └*                            repeat "/" that many times
        2∙                          and repeat vertically twice. Top 2 lines are done
          f«                        push the 0-indexed counter floor divided by 2
            5└*                     push "/" repeated 5 times
               ∙                    and repeat that vertically by the result of the "f«"
                +                   add vertically, creating a "⌐" shape
                 ¼                  prepend each next line with one less space than the above
                  F«                push 1-indexed counter floor divided by 2
                    ╝               create a "\" diagonal that long
                     ┼              and append it horizontally. Shell is done of this hexagon
                      ;↔±           get the previous item on the stack and reverse it horizontally
                         53╬5       and at [5;3] insert the previous result in this
                              ╬±  once everything's done, mirror vertically to finish the hexagon

Haskell中，232个 227 224 187 183 180 175字节

m '/'='\\'
m '\\'='/'
m c=c
r=reverse
k=map
n?s=('/'<$[1..4*n])++s
f 0=[]
f n=n?"/\\":n?"/  \\":[1?k m(r s)++"   \\"|s<-f$n-1]
s="":k(' ':)s
((++).r<*>k(k m)).zipWith(++)s.r.f

最后一行中的匿名函数采用整数参数，并为该大小的多维数据集生成要打印的行。

想法是使用递归从较小的多维数据集中绘制较大的多维数据集。让我们看一下大小为1的立方体的上半部分，然后通过镜像大小为2的立方体的上半部分，并在其周围添加固定的斜杠和空格模式：

                                         ///////// \
                                        ///////// \
     ///// \ ==> / \\\\\ ==> //// / \\\\\\    \
    ///// \ / \\\\\ // /// / \\\\\    \ \

因此，绘制大小为n的立方体的算法为

1. 获得大小为n-1的立方体上半部分的线。
2. 镜像每条线（通过翻转/s和\s），////然后 \左右滑动。
3. 在两行前加上模式////ⁿ plus /\和/ \。
4. 镜像结果行以获取完整的多维数据集。
5. 用适当数量的空格填充线。

红宝石，174个167 169 167字节

->n{a=(1..m=n*4).map{' '*m}
(-n..0).map{|i|(-2*i).times{|k|a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]=?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)
a[~y]=a[y].tr('/\\','\\\\/')}}
a*$/}

在线尝试！

创建一个n*4由空格组成的字符串数组，然后用依次较小的多维数据集覆盖它。

注释代码

->n{a=(1..m=n*4).map{' '*m}                 #make an array of n*4 strings of n*4 spaces (up to centreline of final output)
  (-n..0).map{|i|                           #iterate through cube sizes from n down to 0 (i is negative -n to 0)
    (-2*i).times{|k|                        #iterate through the number of lines in the top half of the cube
      a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]= #overwrite the correct part of the correct line
      ?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)    #with the correct string of the form "/spaces\" with an additional -4*i symbols on one side
      a[~y]=a[y].tr('/\\','\\\\/')          #copy the current line from top half into bottom half, subsituting / for \ and vice versa
    }
  }
a*$/}                                       #return the elements of the array a, concatenated with newlines $/

Python 2中，254个 234 226 203 201 199字节

终于分200了！

P=[];n=0
M=lambda r:(u''+r).translate({47:92,92:47})
exec r"n+=1;q='/'*4;P=[q*n+'/\\',q*n+'/  \\']+[q+'%s   \\'%M(r[::-1])for r in P];"*input()
print'\n'.join(l.center(8*n)for l in(P+map(M,P[::-1])))

技巧：

在Python2中，此函数用于与交换所有内容\，/反之亦然
（仅在unicode中有效），
请检查此内容。

M=lambda r:(u''+r).translate({47:92,92:47})

为每次迭代生成新的前两行
现在，我找不到从上一次迭代接收此行的紧凑方法

P=[q*n+'/\\',q*n+'/  \\']

反转上一次迭代的所有行并交换斜杠

[q+'%s   \\'%M(r[::-1])for r in P]

复制上半部分，按行反转，交换斜杠

P+map(M,P[::-1])

中心填充字符串的整洁方法

l.center(8*n)

在线尝试！

Stax，36 个字节

äª.$u>↓Z╙╝B↨EXª¡╜?Xáhç∙╩p/♂ù⌠r↨c⌐f/*

运行并调试

这种方法迭代地建立了输出的上半部分。它执行主块指定次数。在该块中，每行都是镜像的，并添加了前缀和后缀。前两行将分别添加。构建完所有行后，将它们居中，然后垂直镜像底部。

这是解压，解压和注释的程序。

{               begin block to repeat
  iHYH^H'\*     make a string of '\' characters and set the Y register
                  pseudo-code: push(((y = (i * 2)) * 2 + 1) * 2 * '\')
                  given the 0-based iteration index `i`, let y = 2 * i
                  and push a string consisting of (i*8 + 2) backslashes
  2M            split the string into to equal size (i*4 + 1) substrings
  ~+            push array to input stack and concatenate
                  on the first iteration, this is a no-op
                  subsequently, it prepends the array to the result so far
  {             begin a block to use for mapping
    4'\*+       append 4 backslashes to this element
    :R          "brace-wise" reverse
                  this reverses the string AND the slashes in it
    |YH3+92&    write 92 to index (++y * 2 + 3) in the array
                  this puts the trailing backslash at the correct position
                  this will be an out of bounds index, so the string will grow
                  92 is the character code for backslash 
  m             execute map using block
}*              repeat block specified number of times
|C              vertically center all rows
{               begin block for output mapping
  Q             output this line without popping
  :Rr           "brace-wise" reverse, and then actually reverse
                  net effect is to swap forward and backward slashes
m               execute map using block
rm              reverse array, and output all rows

运行这个

Haskell，193个字节

比获胜者更长的时间，但是这种方法可能很有趣-使用甚至cos和pi:)

码：

i s e f|max e f>s=""|max e f<s=" "|e==s="\\"|1<2="/"
w n y x=head$do{d<-[1..n];o<-[-2*d..2*d];z<-[(cos(pi*(n-d)))*o+x];i(2*d)(abs$z-y)(abs$z+y-1)}++" "
n!h=h<$>[1-2*n..2*n]
f n=((2*n)!)<$>n!w n

像这样运行它：

mapM_ putStrLn (f 4)

该程序基本上“吸引”了许多像这样的钻石：

------------------------
------------------------
-----------/\-----------
----------/  \----------
---------/    \---------
--------/      \--------
--------\      /--------
---------\    /---------
----------\  /----------
-----------\/-----------
------------------------
------------------------

功能i s e f“吸引”大小的一颗钻石s，其中e, f有(abs$z-y)(abs$z+y-1)。

功能w将绘制的菱形移动i 到正确的位置。head在其定义中使用的仅负责查看最顶层。

在这里尝试

木炭，42字节

ＦＮ«↗×⊗⊕ι/↓↘Ｇ↖²→⊕×⁴⊕ι↘²\Ｇ←⁴↘⊕⊗ι→⁴\Ｍ⁴→‖Ｔ»‖Ｍ↓

在线尝试！链接是详细版本的代码。说明：

ＦＮ«

从最小到最大绘制立方体。（从最大到最小绘制，这意味着我得到了一个奇数的镜像，该镜像的字节数太多，无法修复。）

↗×⊗⊕ι/

打印一行/。（这将成为\右侧的，但已完成绘制镜像，因为在循环的末尾要镜像高尔夫球手。）

↓↘Ｇ↖²→⊕×⁴⊕ι↘²\

打印\s 的前两行。（将所有\s 绘制在一个多边形中意味着光标最终以尴尬的位置结束，这花费了太多的字节来修复。）

Ｇ←⁴↘⊕⊗ι→⁴\

打印\s 的左四行。（第五行来自上一个多维数据集。）

Ｍ⁴→

移到下一个多维数据集的开头。

‖Ｔ»

水平反射以准备下一个多维数据集。

‖Ｍ↓

垂直镜像所有内容以完成多维数据集。