Wyzwanie

Utwórz funkcję lub program, który po otrzymaniu liczby całkowitej sizewykonuje następujące czynności:

Jeśli sizejest równe 1, wyjście

H H
HHH
H H

Jeśli sizejest większy niż 1, wyjście

X X
XXX
X X

gdzie Xjest wyjściem programu / funkcji dlasize - 1

(Jeśli wolisz, możesz dopasować przypadek podstawowy 0, o ile podasz w odpowiedzi)

Dowolny z poniższych formatów wyjściowych jest akceptowalny, w zależności od tego, który jest dla Ciebie wygodniejszy:

• Ciąg wymaganej struktury z dowolnymi dwoma odrębnymi znakami odpowiadającymi Hispace

• Dwuwymiarowa tablica o wymaganej strukturze, z dowolnymi dwoma odrębnymi wartościami odpowiadającymi Hispace

• Tablica / lista ciągów, z jednym wierszem wyniku w każdym ciągu, z dowolnymi dwoma odrębnymi wartościami odpowiadającymi Hispace

Dopuszczalne spacje są dozwolone, o ile na każdej linii znajduje się stała ilość spacji wiodących. Dwa różne znaki wyjściowe mogą być zależne od wszystkiego, co wybierzesz, o ile są one różne.

Określ format wyjściowy, który zwraca kod.

Przypadki testowe

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

To jest golf golfowy , więc wygrywa najniższa liczba bajtów dla każdego języka!

Wolfram Language (Mathematica) , 46 bajtów

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

Zwraca tablicę 2d 0s i 1s.

Wypróbuj online!

Płótno , 14 12 bajtów

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

Wypróbuj tutaj!

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

Gdzie Ijest wejście, Xjest wzorcem wygenerowanym przez poprzednią pętlę („H” dla pierwszej pętli) i <space>jest pustą przestrzenią w pierwszym i trzecim rzędzie wzorca, dodaną domyślnie przez ＋.

-2 bajty dzięki dzaima !

MATL , 12 11 bajtów

t:"[ACA]BX*

Biorąc pod uwagę dane wejściowe n, tworzy to macierz zawierającą 0i n.

Wypróbuj online!

Aby przekonwertować to na macierz znaków Hi spację, dodaj g72*cnagłówek. Wypróbuj też online!

Lub dodaj, ]1YCaby zobaczyć matrycę wyświetlaną graficznie. Wypróbuj w MATL Online!

Wyjaśnienie

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 bajtów

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

Uruchom i debuguj

Jest to ascii reprezentacja programu z komentarzami. Ten program buduje literę H na boki, a następnie transponuje raz na końcu.

'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

Dodatkowy 14-bajtowy program - wykorzystuje jego dane wejściowe jako znak wyjściowy. Teoretycznie nie dałoby to prawidłowego kształtu przy 10, ponieważ ma 2 cyfry, ale próba uruchomienia powoduje awarię mojej przeglądarki.

Rubinowy , 72 bajty

Dane wyjściowe to lista ciągów, jeden ciąg w wierszu.

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

Wypróbuj online!

Haskell , 50 bajtów

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

Wypróbuj online!

Tworzy siatkę zer i jedynek. Jedna postać dłużej na spacje i litery H.

Haskell , 51 bajtów

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

Wypróbuj online!

Galaretka , 17 16 15 bajtów

381B«€s3Z€ẎF€µ¡

Jest to pełny program, który wypisuje tablicę 2D 1 i 0 .

Wypróbuj online! lub zobacz wynik z literami H i spacjami.

APL (Dyalog Classic) , 14 bajtów

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

Wypróbuj online!

⎕ oceniane wejście n

,⍳⎕⍴3 wszystkie n-krotki z elementami od 0 1 2

2| mod 2

×/¨∘.≥⍨ utwórz macierz, porównując każdą parę krotek a i b - jeśli wszystkie elementy a są ≥ odpowiadającymi elementami b, jest to 1, w przeciwnym razie 0

SOGL V0.12 , 13 bajtów

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

Wypróbuj tutaj!

R , 64 bajty

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

Wypróbuj online!

Redukuje produkt Kronecker, jako bezwstydny port odpowiedzi Luisa Mendo .

Stopka drukuje wynik ładnie, ale jest to anonimowa funkcja, która zwraca matrixz 1za Hi 0dla przestrzeni.

Java (OpenJDK 9) , 135 bajtów

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

Wypróbuj online!

Zwraca int[][]z 0za Hi 1za space. To faktycznie „rzeźbi” ścianę Hzamiast „palowania” H.

Objaśnienia

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 bajtów

éHÀñäLgvr PGï3PkyHGpH

Wypróbuj online!

Hexdump:

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

Jest to w zasadzie dokładnie to samo podejście, co dywan Sierpińskiego i The Fractal Plus na Anarchy Golf.

Python 2 , 70 bajtów

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

Wypróbuj online!

Funkcja wyświetla listę ciągów znaków.

Python 2 , 84 bajtów

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

Wypróbuj online!

Używa tego samego szablonu, co inne wzory fraktalne 3 * 3:

• Dywan Sierpińskiego
• Fraktal X
• Fractal plus .

J , 25 22 bajtów

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

Wypróbuj 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 bajtów

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

Działa to tylko z najnowszą wersją Prelude, ponieważ eksportuje <>z Data.Semigroup. Aby uruchomić go na TIO, dodaj import, tak jak tutaj: Wypróbuj online!

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

Edycja: -9 bajtów dzięki @ Potato44.

Perl 5 , 46 44 43 41 40 bajtów

1 liczenie. Wykorzystuje 0i 1dla Hi przestrzeń, ma wiodącą 1(przestrzeń)

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

Oparty na klasycznym pomyśle mtve.

Wypróbuj online!

Vim - 66 56 54 bajtów

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

Dane wejściowe są traktowane jako liczba w buforze.

APL (Dyalog Unicode) , 38 34 bajtów ^SBCS

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

Dane wyjściowe to tablica dwuwymiarowa z 1 reprezentacją H i 0przestrzenią.

Wypróbuj online!

Węgiel drzewny , 30 29 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

H

Wydrukuj oryginał H.

ＦＥＮＸ³ι«

Pętla nad pierwszymi sizepotęgami 3.

Ｊ⁰¦⁰

Przesuń kursor z powrotem do początku. Trimpotrzebuje tego, ponieważ zarówno oryginalny wydruk, jak Hi odbicie poniżej poruszają kursorem.

Ｃ⁰ι

Skopiuj poprzednią iterację w dół, tworząc domino.

Ｃιι

Skopiuj wynik w dół i w prawo, tworząc tetromino.

Ｔ⊗ι⊗ι

Przytnij płótno do Lkształtu triomino.

‖ＯＯ→↓ι

Odbij płótno poziomo i pionowo z zakładką, wykonując iterację.

Węgiel drzewny jest lepszy w niektórych fraktalach niż w innych. Oto podobny pomysł, ale w prawie połowie wielkości:

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

Wypróbuj online! Link jest do pełnej wersji kodu.

Python 2 , 143 bajty

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

Wypróbuj online!

-30 bajtów dzięki rekursywnemu

kod opakowania służy do dobrego formatowania. działa dobrze, jeśli go usuniesz

PHP 7, 125 109 bajtów

inne podejście: Zamiast rekurencyjnie zagnieżdżać i spłaszczać wynik, po prostu pętle przechodzą przez wiersze i kolumny i wykorzystują trzecią pętlę, aby dowiedzieć się, czy wydrukować, Hczy _.

Edycja: Dużo zaoszczędziłem, łącząc pętle wierszy / kolumn w jedną, choć zajęło trochę czasu, aby uzyskać prawidłowe zmniejszenie wewnętrznej pętli. Wymaga PHP 7 dla operatora mocy.

Wypróbuj je online !

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

wypisuje wynik. Uruchom jako potok z -nR.

funkcja kwalifikowana, 147 130 bajtów

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

zwraca pojedynczy ciąg. Uruchom z domyślną konfiguracją (nie php.ini).

Galaretka , 25 bajtów

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

Wypróbuj online!

Chociaż jest to dłuższe niż dotychczasowe zgłoszenie galaretki , próbuje wygenerować każdą postać niezależnie tylko od współrzędnej.

W szczególności, jeżeli jest współrzędna (x,y)(1 indeksowania), pierwszy powraca łącza 0i 1odpowiada Hi , odpowiednio.

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

Ponadto 5 bajtów ị⁾ HYsłuży do formatowania, więc ten program (20 bajtów) jest również poprawny (ale dane wyjściowe nie wyglądają tak ładnie):

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

T-SQL , 267 261 bajtów

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 bajty

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

Uruchom z domyślną konfiguracją (nie php.ini) lub spróbuj online .

Perl, 64 bajty

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

Wymaga -p, dane wejściowe są pobierane ze standardowego wejścia. Dane wyjściowe to H Hs.

Wypróbuj online!

PHP (5.6+), 94 bajty

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

Używany z -Fopcją wiersza poleceń. Zakłada domyślne wartości interpretera ( -n). Nie działa w wersjach wcześniejszych niż 5.6, ze względu na operatora mocy.

Przykładowe użycie

$ 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

Wypróbuj online!

CJam - 103 97 87 76 bajtów

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

Ten program wykonuje dość pełną rekursję „ręcznie”. Brak inteligentnego mnożenia macierzy. W trakcie rekurencji na szczycie stosu znajduje się tablica gromadząca dane wyjściowe uzyskane z wywołań nadrzędnych. Zaraz po każdym zestawie wywołań rekurencyjnych dane wyjściowe wywołań rekurencyjnych muszą zostać spakowane razem, aby upewnić się, że dane wyjściowe są prawidłowe, gdy stos jest drukowany liniowo na końcu programu. Stos argumentów przekazywanych w rekursji jest przechowywany w zmiennej A.

Wypróbuj online

K (ngn / k) , 18 bajtów

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

Wypróbuj online!

Japt , 23 bajty

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

Wypróbuj online!

Rozpakowane i jak to działa

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

Korzystanie z transponowanego wzoru

III
 I 
III

jest znacznie łatwiejszy w obsłudze niż oryginalny Hwzór, przynajmniej w Japt, gdzie Imożna to zrobić za pomocą powtórzenia struny i środkowego wypełnienia.

C ++ 11–138 bajtów

Nie jestem jednak pewien, czy ta odpowiedź ma poprawną składnię tutaj.

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

Niegolfowany z działającym kodem

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