挑战

创建一个函数或程序，当给定整数时size，该函数或程序将执行以下操作：

如果size等于1，则输出

H H
HHH
H H

如果size大于1，则输出

X X
XXX
X X

X程序/功能的输出在哪里size - 1

（只要您愿意，0只要您在答案中指定，就可以使基本情况与相对应）

可以使用以下任何一种输出格式，以您更方便的方式：

• 所需结构的字符串，其中任意两个不同的字符分别对应于H和space

• 具有所需结构的二维数组，其中任意两个不同的值分别对应于H和space

• 字符串的数组/列表，每个字符串中有一行输出，并且与H和对应的任意两个不同的值space

只要每行上有恒定数量的前导空格，就可以使用前导空格。两个不同的输出字符可以取决于您选择的任何内容，只要它们不同即可。

指定代码返回的输出格式。

测试用例

1

H H
HHH
H H

2

H H   H H
HHH   HHH
H H   H H
H HH HH H
HHHHHHHHH
H HH HH H
H H   H H
HHH   HHH
H H   H H

3

H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

这是代码高尔夫球，因此每种语言的最低字节数为准！

Wolfram语言（Mathematica），46字节

Nest[ArrayFlatten@{r={#,0,#},{#,#,#},r}&,1,#]&

返回0s和1s 的二维数组。

在线尝试！

画布，14 12 字节

H；［⌐⌐∔＊×∔；３＊＋

在这里尝试！

Code    |Instruction                                                         |Stack
--------+--------------------------------------------------------------------+-------------------------
        |Push input to stack (implicit)                                      |I
H       |Push "H" to stack                                                   |I,"H"
；      |Swap the top two stack items                                        |"H",I
［      |The following ToS (input) times:                                    |X
    ⌐⌐  |Duplicate ToS (result from last loop ("H" if first loop)) four times|X,X,X,X,X
    ∔   |Join vertically                                                     |X,X,X,X\nX
    ×   |Prepend                                                             |X,X,XX\nX
    ∔   |Join vertically                                                     |X,X\nXX\nX
    ；  |Swap top two stack items                                            |X\nXX\nX,X
    ３＊|Repeat three times vertically                                       |X\nXX\nX,X\nX\nX
    ＋  |Join horizontally                                                   |X<space>X\nXXX\nX<space>X
        |End loop (implicit)                                                 |X
        |Print ToS (implicit)                                                |

其中I是输入，X是由先前环路（“H”为第一回路）中产生的图案，并且<space>是在图案的第一和第三行中的空的空间中，由隐式添加＋。

-2个字节，感谢dzaima！

MATL，12 11字节

t:"[ACA]BX*

给定输入n，这将输出包含0和的矩阵n。

在线尝试！

要将其转换为和的字符矩阵，请在标头中H添加g72*c。也可以在线尝试！

或添加]1YC以图形方式显示矩阵。在MATL在线上尝试一下！

说明

t          % Input (implicit): n. Duplicate
:          % Range. Gives the array [ 1 2 ... n]
"          % For each (that is, do n times)
  [ACA]    %   Push the array [5 7 5]
  B        %   Convert to binary. Gives the 3×3 matrix [1 0 1; 1 1 1; 1 0 1]
  X*       %   Kronecker product
           % End (implicit). Display (implicit)

Stax，16 15 字节

╛c_mê║6{│◙ÖmπV"

运行并调试

这是带有注释的程序的ascii表示。该程序将H侧向建立，然后在末尾转置一次。

'H]                 ["H"]
   {         },*    repeat block specified number of times
    c               copy the matrix
     {3*m           triplicate each row
         |S         surround; prepend and append like b + a + b
           |C       horizontally center rows with spaces
                M   transpose back to original orientation
                 m  output each row

奖金14字节程序 -使用其输入作为输出字符。从理论上讲，这不会在10处产生正确的形状，因为它有2位数字，但是尝试运行会使我的浏览器崩溃。

红宝石，72个字节

输出是一个字符串列表，每行一个字符串。

f=->n{n<1?[?H]:[*a=(x=f[n-1]).map{|i|i+' '*i.size+i},*x.map{|i|i*3},*a]}

在线尝试！

Haskell，50个字节

f 0=[[1]]
f n=[x++map(*c)x++x|c<-[0,1,0],x<-f$n-1]

在线尝试！

制作一个0和1的网格。空格和H的长度增加一个字符。

Haskell，51个字节

f 0=["H"]
f n=[x++map(min c)x++x|c<-" H ",x<-f$n-1]

在线尝试！

果冻，17 16 15字节

381B«€s3Z€ẎF€µ¡

这是一个完整的程序，可以打印1和0的2D数组。

在线尝试！或查看带有H和空格的输出。

APL（Dyalog Classic），14个字节

×/¨∘.≥⍨2|,⍳⎕⍴3

在线尝试！

⎕ 评估输入n

,⍳⎕⍴3 元素从0 1 2开始的所有n元组

2| Mod 2

×/¨∘.≥⍨ 通过比较每对元组a和b形成矩阵-如果a的所有元素≥b的对应元素，则为1，否则为0

SOGL V0.12，13 个字节

┌.{³2∙⁴┼+;3∙┼

在这里尝试！

R，64字节

function(n)Reduce(`%x%`,rep(list(matrix(c(1,1,1,0,1,0),3,3)),n))

在线尝试！

作为Luis Mendo的回答的无耻端口，减少了Kronecker的乘积。

页脚打印结果很好，但它是一个匿名函数返回matrix的1用于H和0空间。

Java（OpenJDK 9），135字节

n->{n+=Math.pow(3,n)-n;int s=1,H[][]=new int[n][n],x,y;for(;s<n;s*=3)for(x=n;x-->0;)for(y=n;y-->0;)H[x][y]|=~(x/s%3)&y/s%3&1;return H;}

在线尝试！

返回int[][]带有0for H和1for的space。实际上，这是“雕刻”壁的，H而不是“堆积” H的。

说明

n->{                        // An int to int[][] lambda function
  n+=Math.pow(3,n)-n;       //  change n to 3^n, through +=...-n to avoid an explicit cast
  int s=1,                  //  size of the carvings.
      H[][]=new int[n][n],  //  the 2D array to return, filled with 0s
      x,                    //  counter for the 2D array
      y;                    //  counter for the 2D array
  for(;s<n;s*=3)            //  for each size
    for(x=n;x-->0;)         //   for each row
      for(y=n;y-->0;)       //    for each column
        H[x][y] |=          //     assign 1 to a cell of the array if...
           ~(x/s%3)         //      it is located in the "holes" of the H
          &y/s%3            //
          &1;               //      
  return H;                 //  return the array
}                           // end the lambda

V，22字节

éHÀñäLgvr PGï3PkyHGpH

在线尝试！

十六进制转储：

00000000: e948 c0f1 e416 4c67 7672 2050 47ef 3350  .H....Lgvr PG.3P
00000010: 6b79 4847 7048                           kyHGpH

这基本上与Sierpinski地毯和Anarchy Golf上的Fractal Plus完全相同。

Python 2，70个字节

f=lambda r:-r*'H'or[x+[x,' '*3**r][b]+x for b in 1,0,1for x in f(r-1)]

在线尝试！

函数输出字符串列表。

Python 2，84个字节

r=input()
for i in range(3**r):x,s=' H';exec"s+=[x,s][i%3%2]+s;x*=3;i/=3;"*r;print s

在线尝试！

使用与其他3 * 3分形图案相同的模板：

• 塞尔平斯基地毯
• 分形X
• 分形加。

J，25 22字节

,./^:2@(*/#:@5 7 5)^:]

在线尝试！

        */               multiply by
          #:@5 7 5       the binary matrix shaped like H
,./^:2                   assemble the 4-dimensional result into a matrix
                   ^:]   do it input times

Haskell，73 67 64 55字节

g#f=g<>f<>g
w=map.(id#)
(iterate(w(>>" ")#w id)["H"]!!)

这仅适用于最新版本的Prelude，因为它是<>从导出的Data.Semigroup。要在TIO上运行它，请按以下步骤添加导入：在线尝试！

g#f=              -- function # takes two functions g and f and a list s
                  -- and returns
   g <> f <> g    -- g(s), followed by f(s) and another g(s)

w=                -- w takes a function and a list of lists
                  -- (both as unnamed parameters, because of pointfree style,
                  -- so let's call them f and l)
  map.(id#)       -- return map(id#f)l, i.e. apply (id#f) to every element of l

  w(>>" ")#w id   -- this partial application of # is a function that
                  -- takes the missing list (here a list of lists)
                  -- remember: (>>" ") is the function that replaces every element
                  -- of a list with a single space

iterate(   )["H"] -- starting with a singleton list of the string "H"
                  -- which itself is a singleton list of the char 'H'
                  -- repeatedly apply the above function
              !!  -- and pick the nth iteration



Example for ["H H", "HHH", "H H"], i.e.

   H H
   HHH
   H H

call the iterated function:
                    ( w(>>" ")         # w id       ) ["H H","HHH","H H"]

expand w:           ( map(id#(>>" "))  # map(id#id) ) ["H H","HHH","H H"]

expand outermost #: map(id#(>>" "))["H H","HHH","H H"] ++
                    map(id#id)     ["H H","HHH","H H"] ++
                    map(id#(>>" "))["H H","HHH","H H"]

expand map:         [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"] ++
                    [(id#id)     "H H",   (id#id)     "HHH",   (id#id)     "H H"] ++
                    [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"]

expand other #:     ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"] ++
                    ["H H"++"H H"++"H H", "HHH"++"HHH"++"HHH", "H H"++"H H"++"H H"] ++
                    ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"]

collaps ++:         ["H H   H H", "HHH   HHH", "H H   H H",
                     "H HH HH H", "HHHHHHHHH", "H HH HH H",
                     "H H   H H", "HHH   HHH", "H H   H H"]

which is printed line by line: 

  H H   H H
  HHH   HHH
  H H   H H
  H HH HH H
  HHHHHHHHH
  H HH HH H
  H H   H H
  HHH   HHH
  H H   H H

编辑：-9个字节，感谢@ Potato44。

Perl 5中，46个 44 43 41 40字节

基于1的计数。用途0和1用于H和空间，拥有国内领先的1（空间）

say//,map/$'/^1,@;for@;=glob"{A,.,A}"x<>

基于mtve的经典想法。

在线尝试！

Vim- 66 56 54字节

A @ c H esc " r d ^ q c { ctrl-v } " a y g v r space g v d " a P P " a P V G " b y P g v ctrl-v $ d " a P . . G " b p q @ r

输入被视为缓冲区中的数字。

APL（Dyalog Unicode），38 34字节^SBCS

({(⍵,(0×⍵),⍵){⍺⍪⍵⍪⍺}⍵,⍵,⍵}⍣⎕)1 1⍴1

输出是一个二维数组，1表示H和0表示空间。

在线尝试！

木炭，30 29字节

HＦＥＮＸ³ι«Ｊ⁰¦⁰Ｃ⁰ιＣιιＴ⊗ι⊗ι‖ＯＯ→↓ι

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

H

打印原稿H。

ＦＥＮＸ³ι«

循环size使用3 的第一个幂。

Ｊ⁰¦⁰

将光标移回原点。Trim需要这样做，因为的原始打印H和下面的反射都会移动光标。

Ｃ⁰ι

向下复制先前的迭代，创建一个多米诺骨牌。

Ｃιι

左右复制结果，创建一个四聚体。

Ｔ⊗ι⊗ι

将画布修剪成L形状为triomino 的形状。

‖ＯＯ→↓ι

重叠水平和垂直反射画布，完成迭代。

木炭在某些分形上比其他分形更好。这是一个类似的想法，但是大小几乎是一半：

HＦＮ«⟲Ｃ²⁶‖ＯＯLＸ³ι

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

Python 2 143字节

def g(a,x,y,s):
	if s:s/=3;[g(a,x+k/3*s,y+k%3*s,s)for k in 0,2,3,4,5,6,8]
	else:a[x][y]=1
def f(s):s=3**s;a=eval("s*[0],"*s);g(a,0,0,s);print a

在线尝试！

-30字节归因于递归

包装器代码用于良好的格式化。如果将其删除，它会正常工作

PHP 7，125 109字节

一种不同的方法：而不是递归嵌套和扁平化结果，而是循环遍历行和列，并使用3rd循环查找是否要打印H或_。

编辑：通过将行/列循环合并为一个，节省了很多，尽管花了一点时间才能正确减少内部循环。需要Power Operator的PHP 7。

在线尝试！

for($z=3**$argn;$z*$z>$q=$p;print$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;

打印结果。与一起作为管道运行-nR。

合格功能147130字节

function r($n){for($z=3**$n;$z*$z>$q=$p;$r.=$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;return$r;}

返回一个字符串。使用默认配置运行（否php.ini）。

果冻，25个字节

,’b3U×"3S_4A1e
3*çþ`ị⁾ HY

在线尝试！

尽管这比现有的Jelly提交要长，但它尝试仅与坐标无关地独立生成每个角色。

特别地，如果该坐标是(x,y)（1索引），第一连杆返回0和1对应于H和 分别。

,                Pair. Get (x,y)
 ’               Decrement. Get (x,y) (0-indexing)
  b3             Convert to base 3 digits.
    U            Upend. So next operations can pair the corresponding digits.
     ×"3         Multiply the first element (list) by 3.
        S        Sum (corresponding digit together). Let the sum be s.
         _4A1e   Check if any of abs(s-4) is 1. Equivalently, check
                 if there is any 3 or 5 in the list of s.

另外，这5个字节ị⁾ HY用于格式化，因此该程序（20个字节）也是有效的（但输出看起来不太好）：

,’b3U×"3S_4A1e
3*çþ`

T-SQL，267261字节

DECLARE @N INT=3DECLARE @ TABLE(I INT,H VARCHAR(MAX))INSERT @ VALUES(1,'H H'),(2,'HHH'),(3,'H H');WITH
T AS(SELECT 1 A,3 P,I J,H S FROM @ UNION ALL SELECT A+1,P*3,J*P+I,REPLACE(REPLACE(S,' ','   '),'H',H)FROM @,T
WHERE A<@N)SELECT S FROM T WHERE A=@N ORDER BY J

PHP 7，153字节

    function p($n){$r=["H H",HHH,"H H"];if(--$n)foreach(p($n)as$s){$r[+$i]=$r[$i+6*$p=3**$n]=str_pad($s,2*$p).$s;$r[3*$p+$i++]=$s.$s.$s;}ksort($r);return$r;}

使用默认配置运行（否php.ini）或在线尝试。

Perl，64个字节

//;$_ x=3,$.=s|.+|$&@{[$$_++/$.&1?$&:$"x$.]}$&|g for($_=H.$/)x$'

需要-p，输入取自标准输入。输出是Hs 的H。

在线尝试！

PHP（5.6+），94个字节

<?for(;$H>$e*=3or$e=($i+=$e&&print"$s
")<${$s=H}=3**$argn;)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

与-F命令行选项一起使用。假定解释器为默认值（-n）。由于使用了电源操作器，因此无法在5.6之前的版本上使用。

样品用法

$ echo 3|php -nF h-carpet.php
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

在线尝试！

CJam- 103 97 87 76字节

{H{ae_,S*}%}:Il~a:A];{A_W={)(a9*+:A;[[HIH][HHH][HIH]]{z~}%}{);:A;"H"}?}:H~N*

该程序执行非常冗长的“手工编码”递归。没有智能矩阵乘法。在整个递归过程中，在栈顶有一个数组，该数组收集从父调用获得的输出。在每组递归调用之后，都需要将递归调用的输出压缩在一起，以确保在程序末尾以线性方式打印堆栈时输出正确。递归递归的参数堆栈保留在变量中A。

在线尝试

K（ngn / k），18个字节

{~|/a<\:'a:1=!x#3}

在线尝试！

Japt，23个字节

_·£[X³XX³]Ãy c ·û}gQq)y

在线尝试！

开箱及其工作方式

Z{ZqR mXYZ{[Xp3 XXp3]} y c qR û}gQq)y

Z{    Declare a function that accepts a string...
  ZqR   Split by newline...
  mXYZ{   and map each row into...
    [Xp3 XXp3]  an array of [X.repeat(3), X, X.repeat(3)]
  }
  y   Transpose the resulting 2D array
  c   Flatten
  qR  Join with newline
  û   Center-pad each row to the longest
}
gQq)  Apply the above function to '"' recursively
y     Transpose the resulting 2D string

使用转置模式

III
 I 
III

比原始H模式要容易得多，至少在Japt中I可以通过字符串重复和中心填充来完成。

C ++ 11-138字节

但是，不确定此答案是否具有有效的语法。

#define A a?1:0
template<int N>struct H{H<N-1>h[9];H(int a):h{A,0,A,A,A,A,A,0,A}{}};template<>struct H<0>{char h;H(int a):h{a?'H':' '}{}};

不用工作代码

#include <iostream>

#define A a?1:0

template<int N>
struct H
{
  H<N-1> h[9];

  H(int a) : h{A,0,A,A,A,A,A,0,A}
  {}
};

template<>
struct H<0>
{
  char h;

  H(int a) : h{a?'H':' '}
  {}
};

int pow(int a, int b)
{
  int res=1;

  for (int i=1; i<=b; ++i)
    res *= a;

  return res;
}

template<int N>
char getHvalue(int i, int j, H<N> &hn)
{
  int n3=pow(3, N-1);

//std::cout << N << " " << i << " " << j << std::endl;

  return getHvalue(i%n3, j%n3, hn.h[i/n3*3+j/n3]);
}

template<>
char getHvalue<0>(int, int, H<0> &hn)
{
  return hn.h;
}

int main()
{
  H<0> h0(1);

  std::cout << getHvalue(0, 0, h0) << std::endl;

  std::cout << "\n====================\n" << std::endl;

  H<1> h1(1);

  for (int i=0; i<3; ++i) {
    for (int j=0; j<3; ++j)
      std::cout << getHvalue(i, j, h1);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<2> h2(1);

  for (int i=0; i<9; ++i) {
    for (int j=0; j<9; ++j)
      std::cout << getHvalue(i, j, h2);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<3> h3(1);

  for (int i=0; i<27; ++i) {
    for (int j=0; j<27; ++j)
      std::cout << getHvalue(i, j, h3);
    std::cout << std::endl;
  }

  return 0;
}