Thử thách

Tạo một hàm hoặc chương trình mà khi được cung cấp một số nguyên sizesẽ thực hiện như sau:

Nếu sizebằng 1, đầu ra

H H
HHH
H H

Nếu sizelớn hơn 1, đầu ra

X X
XXX
X X

nơi Xlà sản phẩm của chương trình / chức năng chosize - 1

(Nếu bạn thích, bạn có thể có trường hợp cơ sở tương ứng 0, miễn là bạn chỉ định trong câu trả lời của mình)

Bất kỳ định dạng đầu ra nào sau đây đều được chấp nhận, bất kỳ định dạng nào thuận tiện hơn cho bạn:

• Một chuỗi cấu trúc cần thiết với bất kỳ hai ký tự riêng biệt tương ứng với Hvàspace

• Một mảng hai chiều với cấu trúc được yêu cầu, với bất kỳ hai giá trị riêng biệt tương ứng với Hvàspace

• Một mảng / danh sách các chuỗi, với một dòng đầu ra trong mỗi chuỗi, với hai giá trị riêng biệt tương ứng với Hvàspace

Không gian hàng đầu được phép, miễn là có một số lượng không gian hàng đầu liên tục trên mỗi dòng. Hai ký tự đầu ra riêng biệt có thể phụ thuộc vào bất cứ thứ gì bạn chọn, miễn là chúng khác nhau.

Chỉ định định dạng đầu ra mà mã của bạn đang trả về.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy số byte thấp nhất cho mỗi ngôn ngữ sẽ thắng!

Ngôn ngữ Wolfram (Mathicala) , 46 byte

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

Trả về mảng 2d của 0s và 1s.

Hãy thử trực tuyến!

Canvas , 14 12 byte

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

Hãy thử nó ở đây!

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

Nơi Ilà đầu vào, Xlà mô hình được tạo ra bởi các vòng trước đó ( "H" cho vòng đầu tiên), và <space>là không gian trống trên hàng đầu tiên và thứ ba của mô hình, thêm ngầm bằng ＋.

-2 byte nhờ dzaima !

MATL , 12 11 byte

t:"[ACA]BX*

Cho đầu vào n, điều này đưa ra một ma trận chứa 0và n.

Hãy thử trực tuyến!

Để chuyển đổi nó thành một ma trận ký tự Hvà không gian thêm g72*cvào tiêu đề. Hãy thử trực tuyến quá!

Hoặc thêm ]1YCđể xem ma trận hiển thị đồ họa. Hãy thử nó tại MATL Online!

Giải trình

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 byte

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

Chạy và gỡ lỗi nó

Đây là đại diện ascii của chương trình với ý kiến. Chương trình này xây dựng H sang một bên, và sau đó chuyển đổi một lần vào cuối.

'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

Chương trình thưởng 14 byte - sử dụng đầu vào của nó làm ký tự đầu ra. Về mặt lý thuyết, điều này sẽ không tạo ra hình dạng đúng ở mức 10, vì nó có 2 chữ số, nhưng cố gắng chạy mà làm hỏng trình duyệt của tôi.

Ruby , 72 byte

Đầu ra là một danh sách các chuỗi, một chuỗi trên mỗi dòng.

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

Hãy thử trực tuyến!

Haskell , 50 byte

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

Hãy thử trực tuyến!

Tạo lưới 0 và 1. Một ký tự dài hơn cho không gian và H.

Haskell , 51 byte

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

Hãy thử trực tuyến!

Thạch , 17 16 15 byte

381B«€s3Z€ẎF€µ¡

Đây là một chương trình đầy đủ in một mảng 2D gồm 1 và 0 .

Hãy thử trực tuyến! hoặc xem đầu ra với H 's và dấu cách.

APL (Dyalog Classic) , 14 byte

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

Hãy thử trực tuyến!

⎕ đánh giá đầu vào n

,⍳⎕⍴3 tất cả các bộ dữ liệu có các phần tử từ 0 1 2

2| mod 2

×/¨∘.≥⍨ tạo thành một ma trận bằng cách so sánh mọi cặp tuple a và b - nếu tất cả các phần tử của a là elements các phần tử tương ứng của b, thì đó là 1, nếu không thì 0

SOGL V0.12 , 13 byte

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

Hãy thử nó ở đây!

R , 64 byte

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

Hãy thử trực tuyến!

Giảm bởi sản phẩm Kronecker, như một cổng không biết xấu hổ của câu trả lời của Luis Mendo .

Chân in kết quả độc đáo, nhưng đây là một chức năng ẩn danh mà trả về một matrixcủa 1cho Hvà 0cho không gian.

Java (OpenJDK 9) , 135 byte

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

Hãy thử trực tuyến!

Trả về int[][]với 0cho Hvà 1cho space. Điều này thực sự "khắc" một bức tường Hthay vì "đóng cọc" H.

Giải thích

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 byte

éHÀñäLgvr PGï3PkyHGpH

Hãy thử trực tuyến!

Hexdump:

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

Về cơ bản, đây là cách tiếp cận chính xác giống như thảm Sierpinki và The Fractal Plus trên Anarchy Golf.

Python 2 , 70 byte

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

Hãy thử trực tuyến!

Hàm xuất ra một danh sách các chuỗi.

Python 2 , 84 byte

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

Hãy thử trực tuyến!

Sử dụng cùng một mẫu với các mẫu fractal 3 * 3 khác:

• Thảm Sierpinki
• Fractal X
• Cộng với Fractal .

J , 25 22 byte

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

Hãy thử trực tuyến!

        */               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 byte

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

Điều này chỉ hoạt động với phiên bản mới nhất Prelude, bởi vì nó xuất khẩu <>từ Data.Semigroup. Để chạy nó trên TIO, hãy thêm một lần nhập như được thực hiện tại đây: Hãy thử trực tuyến!

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

Chỉnh sửa: -9 byte nhờ @ Potato44.

Perl 5 , 46 44 43 41 40 byte

Đếm 1 dựa. Sử dụng 0và 1cho Hvà không gian, có một 1(không gian) hàng đầu

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

Dựa trên một ý tưởng cổ điển của mtve.

Hãy thử trực tuyến!

Vim - 66 56 54 byte

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

Đầu vào được lấy dưới dạng số trong bộ đệm.

APL (Dyalog Unicode) , 38 34 byte ^SBCS

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

Đầu ra là một mảng 2 chiều với 1đại diện cho H và 0đại diện cho không gian.

Hãy thử trực tuyến!

Than , 30 29 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

H

In bản gốc H.

ＦＥＮＸ³ι«

Lặp lại các sizequyền hạn đầu tiên của 3.

Ｊ⁰¦⁰

Di chuyển con trỏ trở lại điểm gốc. Trimcần điều này, vì cả bản in gốc Hvà phản chiếu bên dưới đều di chuyển con trỏ.

Ｃ⁰ι

Sao chép lần lặp trước xuống dưới, tạo ra một domino.

Ｃιι

Sao chép kết quả xuống và phải, tạo ra một tetromino.

Ｔ⊗ι⊗ι

Cắt vải xuống một Lhình triomino.

‖ＯＯ→↓ι

Phản chiếu khung vẽ theo chiều ngang và chiều dọc với sự chồng chéo, hoàn thành việc lặp lại.

Than là tốt hơn ở một số fractals hơn những người khác. Đây là một ý tưởng tương tự, nhưng với kích thước gần một nửa:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Python 2 , 143 byte

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

Hãy thử trực tuyến!

-30 byte nhờ đệ quy

mã bao bọc là định dạng đẹp. nó hoạt động tốt nếu bạn loại bỏ nó

PHP 7, 125 109 byte

một cách tiếp cận khác: Thay vì lồng và làm phẳng kết quả theo cách đệ quy, điều này chỉ lặp qua các hàng và cột và sử dụng vòng lặp thứ 3 để tìm hiểu xem có nên in Hhay không _.

Chỉnh sửa: Đã lưu rất nhiều bằng cách kết hợp các vòng lặp hàng / cột thành một, mặc dù phải mất một chút để có được mức giảm cho vòng lặp bên trong chính xác. Yêu cầu PHP 7 cho toán tử điện.

Hãy thử chúng trực tuyến !

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=_;

in kết quả. Chạy như ống với -nR.

chức năng đủ điều kiện, 147 130 byte

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

trả về một chuỗi đơn Chạy với cấu hình mặc định (không php.ini).

Thạch , 25 byte

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

Hãy thử trực tuyến!

Mặc dù điều này dài hơn trình đệ trình Jelly hiện có , nhưng nó cố gắng tạo ra từng ký tự một cách độc lập chỉ từ tọa độ.

Cụ thể, nếu tọa độ là (x,y)(lập chỉ mục 1), liên kết đầu tiên trả về 0và 1tương ứng Hvà tương ứng.

,                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.

Ngoài ra, 5 byte ị⁾ HYđược sử dụng để định dạng, vì vậy chương trình này (20 byte) cũng hợp lệ (nhưng đầu ra trông không đẹp mắt):

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

T-SQL , 267 261 byte

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 byte

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

Chạy với cấu hình mặc định (không php.ini) hoặc thử trực tuyến .

Perl, 64 byte

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

Yêu cầu -p, đầu vào được lấy từ stdin. Đầu ra là một H của Hs.

Hãy thử trực tuyến!

PHP (5.6+), 94 byte

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

Được sử dụng với -Ftùy chọn dòng lệnh. Giả sử thông dịch mặc định ( -n). Sẽ không hoạt động trên các phiên bản trước 5.6, do nhà điều hành điện.

Sử dụng mẫu

$ 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

Hãy thử trực tuyến!

CJam - 103 97 87 76 byte

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

Chương trình này thực hiện một đệ quy "mã hóa" khá dài dòng. Không nhân ma trận thông minh. Trong suốt quá trình đệ quy, trên đầu ngăn xếp có một mảng tập hợp đầu ra thu được từ các lệnh gọi cha. Ngay sau mỗi bộ cuộc gọi đệ quy, đầu ra của các cuộc gọi đệ quy cần được nén lại với nhau, để đảm bảo đầu ra chính xác khi ngăn xếp được in tuyến tính ở cuối chương trình. Chồng các đối số được truyền xuống đệ quy được giữ trong biến A.

Thử trực tuyến

K (ngn / k) , 18 byte

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

Hãy thử trực tuyến!

Japt , 23 byte

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

Hãy thử trực tuyến!

Giải nén & Cách thức hoạt động

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

Sử dụng mô hình chuyển đổi

III
 I 
III

dễ xử lý hơn nhiều so với Hmẫu ban đầu , ít nhất là trong Japt, nơi Icó thể được thực hiện với lặp lại chuỗi và đệm trung tâm.

C ++ 11 - 138 byte

Không chắc chắn nếu câu trả lời này có một cú pháp hợp lệ ở đây tuy nhiên.

#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':' '}{}};

Ung thư với mã làm việc

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