Desafio

Crie uma função ou programa que, quando fornecido um número inteiro size, faça o seguinte:

Se sizefor igual a 1, a saída

H H
HHH
H H

Se sizefor maior que 1, a saída

X X
XXX
X X

onde Xé a saída do programa / função parasize - 1

(Se preferir, você pode corresponder ao caso base 0, desde que você especifique em sua resposta)

Qualquer um dos seguintes formatos de saída é aceitável, o que for mais conveniente para você:

• Uma sequência da estrutura necessária com dois caracteres distintos correspondentes a Hespace

• Uma matriz bidimensional com a estrutura necessária, com quaisquer dois valores distintos correspondentes a Hespace

• Uma matriz / lista de cadeias, com uma linha da saída em cada cadeia, com quaisquer dois valores distintos correspondentes a Hespace

Os espaços à esquerda são permitidos, desde que haja uma quantidade constante de espaços à esquerda em cada linha. Os dois caracteres de saída distintos podem depender de qualquer coisa que você escolher, desde que sejam diferentes.

Especifique qual formato de saída seu código está retornando.

Casos de teste

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

Isso é código-golfe , então a contagem de bytes mais baixa para cada idioma vence!

Wolfram Language (Mathematica) , 46 bytes

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

Devolve uma matriz 2-D de 0s e 1s.

Experimente online!

Tela , 14 12 bytes

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

Experimente aqui!

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

Onde Iestá a entrada, Xé o padrão gerado pelo loop anterior ("H" para o primeiro loop) e <space>é o espaço vazio na primeira e terceira linha do padrão, incluído implicitamente por ＋.

-2 bytes graças ao dzaima !

MATL , 12 11 bytes

t:"[ACA]BX*

Dada a entrada n, isso gera uma matriz contendo 0e n.

Experimente online!

Para converter isso em uma matriz de caracteres He espaço, adicione g72*cno cabeçalho. Experimente online também!

Ou adicione ]1YCpara ver a matriz exibida graficamente. Experimente no MATL Online!

Explicação

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"

Execute e depure

Esta é a representação ascii do programa com comentários. Este programa constrói o H lateralmente e depois transpõe uma vez no final.

'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

Programa de 14 bytes de bônus - usa sua entrada como caractere de saída. Teoricamente, isso não produziria a forma correta aos 10 anos, pois possui 2 dígitos, mas a tentativa de executar isso trava meu navegador.

Ruby , 72 bytes

Saída é uma lista de cadeias, uma cadeia por linha.

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

Experimente online!

Haskell , 50 bytes

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

Experimente online!

Cria uma grade de 0 e 1. Um personagem a mais para espaços e Hs.

Haskell , 51 bytes

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

Experimente online!

Geléia , 17 16 15 bytes

381B«€s3Z€ẎF€µ¡

Este é um programa completo que imprime uma matriz 2D de 1 e 0 .

Experimente online! ou veja a saída com H e espaços.

APL (Dyalog Classic) , 14 bytes

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

Experimente online!

⎕ entrada avaliada f—

,⍳⎕⍴3 todas as n-tuplas com elementos de 0 1 2

2| mod 2

×/¨∘.≥⍨ forme uma matriz comparando todos os pares de tuplas aeb - se todos os elementos de a forem ≥ os elementos correspondentes de b, será a 1, caso contrário, 0

SOGL V0.12 , 13 bytes

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

Experimente aqui!

R , 64 bytes

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

Experimente online!

Reduz pelo produto Kronecker, como uma porta descarada da resposta de Luis Mendo .

O rodapé imprime bem o resultado, mas essa é uma função anônima que retorna um matrixde 1para He 0um espaço.

Java (OpenJDK 9) , 135 bytes

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

Experimente online!

Retorna um int[][]com 0para He 1para space. Isso na verdade "esculpe" uma parede de Hem vez de "empilhar" H.

Explicações

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

Experimente online!

Hexdump:

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

Esta é basicamente a mesma abordagem que o tapete de Sierpinski e The Fractal Plus no 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)]

Experimente online!

A função gera uma lista de strings.

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

Experimente online!

Usa o mesmo modelo que outros padrões de fractal 3 * 3:

• Tapete de Sierpinski
• Fractal X
• Fractal plus .

J , 25 22 bytes

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

Experimente 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"]!!)

Isso funciona apenas com a versão mais recente do Prelude, porque exporta <>de Data.Semigroup. Para executá-lo no TIO, adicione uma importação conforme feito aqui: Experimente 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

Edit: -9 bytes graças a @ Potato44.

Perl 5 , 46 44 43 41 40 bytes

1 contagem baseada. Usa 0e 1para He espaço, tem um líder 1(espaço)

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

Baseado em uma idéia clássica de mtve.

Experimente 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

A entrada é tomada como um número no buffer.

APL (Dyalog Unicode) , 38 34 bytes ^SBCS

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

A saída é uma matriz bidimensional com 1representação H e 0espaço representativo.

Experimente online!

Carvão , 30 29 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

H

Imprima o original H.

ＦＥＮＸ³ι«

Faça um loop sobre as primeiras sizepotências de 3.

Ｊ⁰¦⁰

Mova o cursor de volta à origem. Trimprecisa disso, pois a impressão original He a reflexão abaixo movem o cursor.

Ｃ⁰ι

Copie a iteração anterior para baixo, criando um dominó.

Ｃιι

Copie o resultado para baixo e para a direita, criando um tetromino.

Ｔ⊗ι⊗ι

Apare a tela em uma Lforma triomino.

‖ＯＯ→↓ι

Reflita a tela horizontalmente e verticalmente com sobreposição, concluindo a iteração.

O carvão é melhor em alguns fractais do que outros. Aqui está uma ideia semelhante, mas em quase metade do tamanho:

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

Experimente online! Link é a versão detalhada do código.

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

Experimente online!

-30 bytes graças ao recurso recursivo

O código do wrapper é para uma boa formatação. funciona bem se você removê-lo

PHP 7, 125 109 bytes

uma abordagem diferente: em vez de aninhar e achatar o resultado recursivamente, isso apenas percorre as linhas e colunas e usa um terceiro loop para descobrir se imprimir Hou_ .

Editar: economizou muito combinando os loops de linha / coluna a um, embora demorasse um pouco para corrigir a diminuição do loop interno. Requer PHP 7 para o operador de energia.

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

imprime o resultado. Executar como tubo com-nR .

função qualificada, 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;}

retorna uma única string. Execute com a configuração padrão (não php.ini).

Geléia , 25 bytes

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

Experimente online!

Embora isso seja mais longo que o envio existente do Jelly , ele tenta gerar cada caractere independentemente, apenas a partir da coordenada.

Em particular, se a coordenada é (x,y)(1-indexação), a primeira ligação retornos 0e 1corresponde a He , respectivamente.

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

Além disso, os 5 bytes ị⁾ HYsão usados ​​para formatação, portanto, este programa (20 bytes) também é válido (mas a saída não parece tão boa):

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

Execute com a configuração padrão (não php.ini) ou tente online .

Perl, 64 bytes

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

Requer -p, a entrada é retirada do stdin. A saída é um H de Hs.

Experimente online!

PHP (5.6 ou superior), 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;

Usado com a -Fopção de linha de comando. Assume os padrões do intérprete ( -n). Não funcionará em versões anteriores à 5.6, devido ao operador de energia.

Uso da amostra

$ 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

Experimente 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*

Este programa faz uma recursão "codificada à mão" bastante detalhada. Nenhuma multiplicação de matriz inteligente. Durante a recursão, no topo da pilha, há uma matriz que reúne a saída obtida com as chamadas pai. Logo após cada conjunto de chamadas recursivas, a saída das chamadas recursivas precisa ser compactada, para garantir que a saída esteja correta quando a pilha for impressa linearmente no final do programa. A pilha de argumentos a ser transmitida a recursividade é mantido na variável A.

Experimente on-line

K (ngn / k) , 18 bytes

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

Experimente online!

Japonês , 23 bytes

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

Experimente online!

Descompactado e como funciona

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

Usando o padrão transposto

III
 I 
III

é muito mais fácil de manusear do que o Hpadrão original , pelo menos em Japt, onde isso Ipode ser feito com repetição de cordas e preenchimento central.

C ++ 11 - 138 bytes

Não tenho certeza se esta resposta tem uma sintaxe válida aqui, no entanto.

#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 com código de trabalho

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