Herausforderung

Erstellen Sie eine Funktion oder ein Programm, das bei Angabe einer Ganzzahl sizeFolgendes ausführt:

Wenn sizegleich 1 ist, wird ausgegeben

H H
HHH
H H

Wenn sizegrößer als 1, wird ausgegeben

X X
XXX
X X

wo Xist die Ausgabe des Programms / der Funktion fürsize - 1

(Wenn Sie es vorziehen, können Sie den Basisfall entsprechen 0, solange Sie in Ihrer Antwort angeben)

Die folgenden Ausgabeformate sind zulässig, je nachdem, was für Sie am bequemsten ist:

• Eine Zeichenfolge der erforderlichen Struktur mit zwei unterschiedlichen Zeichen, die Hund entsprechenspace

• Ein zweidimensionales Array mit der erforderlichen Struktur, mit je zwei verschiedenen Werten entsprechen Hundspace

• Ein Array / Liste von Zeichenketten, mit einer Zeile des Ausgangssignals in jedem Strang, mit je zwei verschiedene Werte entsprechen Hundspace

Führende Leerzeichen sind zulässig, solange in jeder Zeile eine konstante Anzahl von führenden Leerzeichen vorhanden ist. Die zwei verschiedenen Ausgabezeichen können von beliebigen Elementen abhängen, sofern sie unterschiedlich sind.

Geben Sie an, welches Ausgabeformat Ihr Code zurückgibt.

Testfälle

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

Das ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl für jede Sprache!

Wolfram Language (Mathematica) , 46 Byte

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

Gibt ein 2D-Array von 0s und 1s zurück.

Probieren Sie es online!

Canvas , 14 12 Bytes

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

Probieren Sie es hier aus!

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

Wo Iist die Eingabe, Xist das von der vorherigen Schleife erzeugte Muster ("H" für die erste Schleife) und <space>ist der leere Raum in der ersten und dritten Reihe des Musters, implizit hinzugefügt von ＋.

-2 Bytes dank dzaima !

MATL , 12 11 Bytes

t:"[ACA]BX*

Bei Eingabe nwird eine Matrix ausgegeben, die 0und enthält n.

Probieren Sie es online!

Um dies in eine Zeichenmatrix von Hund ein Leerzeichen umzuwandeln, fügen Sie g72*cden Header hinzu. Probieren Sie es auch online aus!

Oder fügen Sie hinzu ]1YC, um die Matrix grafisch anzuzeigen. Probieren Sie es bei MATL Online!

Erläuterung

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 Bytes

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

Führen Sie es aus und debuggen Sie es

Dies ist die ASCII-Darstellung des Programms mit Kommentaren. Dieses Programm baut das H seitwärts auf und transponiert am Ende einmal.

'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

Bonus 14-Byte-Programm - verwendet seine Eingabe als Ausgabezeichen. Theoretisch würde dies bei 10 nicht die richtige Form ergeben, da es 2 Ziffern hat, aber der Versuch, es auszuführen, stürzt mein Browser ab.

Ruby , 72 Bytes

Die Ausgabe ist eine Liste von Zeichenfolgen, eine Zeichenfolge pro Zeile.

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

Probieren Sie es online!

Haskell , 50 Bytes

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

Probieren Sie es online!

Erzeugt ein Raster aus Nullen und Einsen. Ein Zeichen länger für Leerzeichen und Hs.

Haskell , 51 Bytes

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

Probieren Sie es online!

Jelly , 17 16 15 Bytes

381B«€s3Z€ẎF€µ¡

Dies ist ein vollständiges Programm, das ein 2D-Array mit 1 und 0 ausgibt.

Probieren Sie es online! oder siehe die Ausgabe mit H und Leerzeichen.

APL (Dyalog Classic) , 14 Byte

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

Probieren Sie es online!

⎕ ausgewerteter Eingang n

,⍳⎕⍴3 alle n-Tupel mit Elementen von 0 1 2

2| mod 2

×/¨∘.≥⍨ Bilden Sie eine Matrix, indem Sie jedes Tupelpaar a und b vergleichen. Wenn alle Elemente von a ≥ den entsprechenden Elementen von b sind, ist es eine 1, andernfalls 0

SOGL V0.12 , 13 Bytes

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

Probieren Sie es hier aus!

R , 64 Bytes

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

Probieren Sie es online!

Reduziert nach Kronecker-Produkt, als schamlose Portierung von Luis Mendos Antwort .

Die Fußzeile gibt das Ergebnis gut aus, dies ist jedoch eine anonyme Funktion, die ein matrixvon 1für Hund 0für Leerzeichen zurückgibt .

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

Probieren Sie es online!

Gibt ein int[][]mit 0für Hund 1für zurück space. Dies "schnitzt" tatsächlich eine Wand von H's, anstatt' s zu "stapeln" H.

Erklärungen

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 Bytes

éHÀñäLgvr PGï3PkyHGpH

Probieren Sie es online!

Hexdump:

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

Dies ist im Grunde derselbe Ansatz wie der Sierpinski-Teppich und The Fractal Plus bei Anarchy Golf.

Python 2 , 70 Bytes

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

Probieren Sie es online!

Die Funktion gibt eine Liste von Zeichenfolgen aus.

Python 2 , 84 Bytes

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

Probieren Sie es online!

Verwendet dieselbe Vorlage wie andere 3 * 3-Fraktalmuster:

• Sierpinski-Teppich
• Fraktale X
• Fraktale plus .

J , 25 22 Bytes

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

Probieren Sie es online!

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

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

Dies funktioniert nur mit der neuesten Version von Prelude, weil es exportiert <>aus Data.Semigroup. Fügen Sie hier einen Import hinzu, um es auf TIO auszuführen: Probieren Sie es online aus!

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

Edit: -9 Bytes dank @ Potato44.

Perl 5 , 46 44 43 41 40 Bytes

1 basiertes Zählen. Verwendet 0und 1für Hund Raum, hat eine führende 1(Raum)

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

Basierend auf einer klassischen Idee von mtve.

Probieren Sie es online!

Vim - 66 56 54 Bytes

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

Die Eingabe wird als Zahl in den Puffer übernommen.

APL (Dyalog Unicode) , 38 ^{SBCS mit} 34 Bytes

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

Die Ausgabe ist ein zweidimensionales Array, 1das H und 0Raum darstellt.

Probieren Sie es online!

Kohle , 30 29 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

H

Drucken Sie das Original H.

ＦＥＮＸ³ι«

Schleife über die ersten sizePotenzen von 3.

Ｊ⁰¦⁰

Bewegen Sie den Cursor zurück zum Ursprung. TrimDies ist erforderlich, da sowohl der Originaldruck Hals auch die Reflexion darunter den Cursor bewegen.

Ｃ⁰ι

Kopieren Sie die vorherige Iteration nach unten und erstellen Sie ein Domino.

Ｃιι

Kopieren Sie das Ergebnis nach unten und rechts und erstellen Sie einen Tetromino.

Ｔ⊗ι⊗ι

Schneiden Sie die Leinwand auf eine LTriomino-Form.

‖ＯＯ→↓ι

Spiegeln Sie die Leinwand horizontal und vertikal mit Überlappung, um die Iteration abzuschließen.

Holzkohle ist in einigen Fraktalen besser als in anderen. Hier ist eine ähnliche Idee, aber fast halb so groß:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes.

Python 2 , 143 Bytes

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

Probieren Sie es online!

-30 bytes dank rekursiv

Wrapper-Code ist für eine schöne Formatierung. Es funktioniert gut, wenn Sie es entfernen

PHP 7, 125 109 Bytes

Ein anderer Ansatz: Anstatt das Ergebnis rekursiv zu verschachteln und zu reduzieren, durchläuft dies nur die Zeilen und Spalten und verwendet eine dritte Schleife, um herauszufinden, ob Hoder gedruckt werden soll _.

Bearbeiten: Es wurde viel gespart, indem die Zeilen- / Spaltenschleifen zu einer kombiniert wurden, obwohl es ein bisschen gedauert hat, bis die Verringerung für die innere Schleife korrekt war. Benötigt PHP 7 für den Power Operator.

Probiere sie online aus !

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

druckt das Ergebnis aus. Als Rohr mit laufen lassen -nR.

qualifizierte Funktion, 147 130 Bytes

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

Gibt eine einzelne Zeichenfolge zurück. Führen Sie die Standardkonfiguration aus (Nein php.ini).

Gelee , 25 Bytes

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

Probieren Sie es online!

Obwohl dies länger ist als die vorhandene Jelly-Übermittlung , wird versucht, jedes Zeichen unabhängig von der Koordinate zu generieren.

Insbesondere dann , wenn die Koordinate (x,y)(1-Indexierung), das erste Glied zurückkehrt 0und 1entspricht Hund jeweils.

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

Außerdem werden die 5 Bytes ị⁾ HYfür die Formatierung verwendet, sodass dieses Programm (20 Bytes) ebenfalls gültig ist (aber die Ausgabe sieht nicht so gut aus):

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

T-SQL , 267 261 Bytes

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 Bytes

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

Führen Sie die Standardkonfiguration aus (Nein php.ini) oder versuchen Sie es online .

Perl, 64 Bytes

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

Benötigt -pwird die Eingabe von stdin übernommen. Die Ausgabe ist ein H von Hs.

Probieren Sie es online!

PHP (5.6+), 94 Bytes

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

Wird mit der -FBefehlszeilenoption verwendet. Übernimmt die Standardeinstellungen des Interpreters ( -n). Funktioniert aufgrund des Netzbetreibers nicht mit Versionen vor 5.6.

Beispielnutzung

$ 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

Probieren Sie es online!

CJam - 103 97 87 76 Bytes

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

Dieses Programm führt eine recht ausführliche "handcodierte" Rekursion durch. Keine intelligenten Matrixmultiplikationen. Während der Rekursion befindet sich oben auf dem Stapel ein Array, in dem die Ausgabe der übergeordneten Aufrufe gesammelt wird. Direkt nach jedem Satz rekursiver Aufrufe muss die Ausgabe der rekursiven Aufrufe komprimiert werden, um sicherzustellen, dass die Ausgabe korrekt ist, wenn der Stapel am Ende des Programms linear gedruckt wird. Der Stapel der Argumente, die in der Rekursion übergeben werden, wird in der Variablen gespeichert A.

Versuchen Sie es online

K (ngn / k) , 18 Bytes

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

Probieren Sie es online!

Japt , 23 Bytes

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

Probieren Sie es online!

Ausgepackt und wie es funktioniert

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

Verwenden des transponierten Musters

III
 I 
III

ist weitaus einfacher zu handhaben als das Originalmuster H, zumindest in Japt, wo das Imit String Repeat und Center-Padding gemacht werden kann.

C ++ 11 - 138 Bytes

Ich bin mir jedoch nicht sicher, ob diese Antwort hier eine gültige Syntax hat.

#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 mit Arbeitscode

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