ท้าทาย

สร้างฟังก์ชั่นหรือโปรแกรมที่เมื่อได้รับจำนวนเต็ม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,#]&

ส่งคืนอาร์เรย์ 2 มิติของ0s และ1s

ลองออนไลน์!

Canvasขนาด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นี้เอาท์พุทเมทริกซ์ที่มีและ0n

ลองออนไลน์!

หากต้องการแปลงให้เป็นเมทริกซ์อักขระของHและช่องว่างจะเพิ่มg72*cในส่วนหัว ลองออนไลน์ด้วย!

หรือเพิ่ม]1YCเพื่อดูเมทริกซ์แสดงกราฟิก ลองที่MATL Online!

คำอธิบาย

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 หลัก แต่พยายามเรียกใช้ที่ทำให้เบราว์เซอร์ของฉันขัดข้อง

Ruby , 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€µ¡

นี้เป็นโปรแกรมเต็มรูปแบบที่พิมพ์อาร์เรย์ 2 มิติ1 'และ0 ' s

ลองออนไลน์! หรือดูผลลัพธ์ด้วยHและช่องว่าง

APL (Dyalog Classic)ขนาด 14 ไบต์

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

ลองออนไลน์!

⎕ การประเมินการป้อนข้อมูล n

,⍳⎕⍴3 n-tuples ทั้งหมดที่มีองค์ประกอบตั้งแต่ 0 1 2

2| mod 2

×/¨∘.≥⍨ จัดทำเมทริกซ์โดยการเปรียบเทียบ tuples 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))

ลองออนไลน์!

ลดด้วยผลิตภัณฑ์ Kronecker เป็นพอร์ตไร้ยางอายของคำตอบที่หลุยส์ Mendo ของ

ส่วนท้ายพิมพ์ผลอย่าง แต่นี้เป็นฟังก์ชั่นที่ไม่ระบุชื่อที่ส่งกลับ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[][]ด้วย0สำหรับHและสำหรับ1 spaceนี้จริง "แกะสลัก" กำแพงH's แทน 'ซ้อน' H' s

คำอธิบาย

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

ลองออนไลน์!

hexdump:

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

นี่เป็นวิธีการเดียวกันกับพรม SierpinskiและThe Fractal Plusบน Anarchy Golf

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:

• พรม Sierpinski
• เศษส่วน 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และการสะท้อนด้านล่างเลื่อนเคอร์เซอร์

Ｃ⁰ι

คัดลอกการทำซ้ำก่อนหน้าลงด้านล่างสร้างโดมิโน

Ｃιι

คัดลอกผลลัพธ์ลงและขวาสร้าง tetromino

Ｔ⊗ι⊗ι

ตัดแต่งผืนผ้าใบลงไปที่Lรูปทรงสามเหลี่ยม

‖ＯＯ→↓ι

สะท้อนผืนผ้าใบในแนวนอนและแนวตั้งด้วยการซ้อนทับทำให้ซ้ำได้

ถ่านจะดีกว่าที่แฟร็กทัลบางกว่าคนอื่น นี่เป็นแนวคิดที่คล้ายกัน แต่ในเกือบครึ่งขนาด:

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 ไบต์ขอบคุณที่เกิดซ้ำ

รหัส wrapper สำหรับการจัดรูปแบบที่ดี มันทำงานได้ดีถ้าคุณลบมัน

PHP 7, 125 109 ไบต์

วิธีการที่แตกต่าง: แทนที่จะทำรังและทำให้ผลลัพธ์แบนซ้ำการวนซ้ำจะวนซ้ำไปตามแถวและคอลัมน์และใช้ลูปที่ 3 เพื่อค้นหาว่าจะพิมพ์Hหรือ_หรือ

แก้ไข: บันทึกจำนวนมากด้วยการรวมลูปแถว / คอลัมน์เข้ากับหนึ่งแม้ว่าจะใช้เวลาสักเล็กน้อยเพื่อให้การลดลงของการวนซ้ำภายในถูกต้อง ต้องการ 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ทำงานเป็นท่อด้วย

ฟังก์ชั่นที่ผ่านการรับรอง147 130 ไบต์

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

ลองออนไลน์!

แม้ว่านี่จะนานกว่าการส่งเยลลี่ที่มีอยู่แต่ก็พยายามสร้างตัวละครแต่ละตัวอย่างอิสระจากพิกัด

โดยเฉพาะอย่างยิ่งหากพิกัดคือ(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 , 267 261 ไบต์

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อินพุตถูกนำมาจาก stdin เอาต์พุตคือ H ของHs

ลองออนไลน์!

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*

โปรแกรมนี้ทำการเรียกซ้ำแบบ "handcoded" ที่ค่อนข้างละเอียด ไม่มีการคูณสมาร์ทเมทริกซ์ ตลอดการเรียกซ้ำที่ด้านบนของสแต็กจะมีอาร์เรย์ที่รวบรวมเอาต์พุตที่ได้รับจากการเรียกพาเรนต์ หลังจากเรียกชุดเกิดซ้ำแต่ละครั้งเอาต์พุตของการเรียกซ้ำจะต้องถูกซิปเข้าด้วยกันเพื่อให้แน่ใจว่าเอาต์พุตถูกต้องเมื่อสแต็กถูกพิมพ์เชิงเส้นตรงที่ส่วนท้ายของโปรแกรม สแต็คของอาร์กิวเมนต์ที่ถูกส่งผ่านการเรียกซ้ำถูกเก็บไว้ในตัวแปร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

การใช้รูปแบบ transposed

III
 I 
III

ง่ายต่อการจัดการมากกว่าHรูปแบบดั้งเดิมอย่างน้อยใน Japtapt ที่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':' '}{}};

Ungolfed ด้วยรหัสการทำงาน

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