Crie um "H" a partir de "H" s menores

73

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 é , então a contagem de bytes mais baixa para cada idioma vence!

Bazinga_9000
fonte
4
Perfeito para carvão provavelmente ... lol. Bem-vindo ao PPCG! : D
HyperNeutrino
10
Bem-vindo ao PPCG. Bom primeiro desafio!
Adám
Podemos usar 0 tamanhos baseados?
Adám
3
relacionado
ngn
11
Eu chamaria isso de "Sierpinski H"
mbomb007 12/0318

Respostas:

28

Wolfram Language (Mathematica) , 46 bytes

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

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

Experimente online!

Aninhar [ArrayFlatten @ {r = {#, 0, #}, {#, #, #}, r} e, 1, #] e [3] // MatrixForm

Aninhar [ArrayFlatten @ {r = {#, 0, #}, {#, #, #}, r} e, 1, #] e [5] // Imagem

alefalpha
fonte
17
o que diabos, claro, o Mathematica tem um built-in para matrizes aninhadas recursivas lol. +1
HyperNeutrino
11
@HyperNeutrino bem, obviamente
apenas ASCII
7
@HyperNeutrino Como isso é considerado um built-in? Apenas Nest(repetidamente) a função várias vezes. Como quaisquer outros envios (Jelly?) O ArrayFlattené ... bem, embutido, mas se comporta de maneira semelhante a um Flatten[#,{{1,3},{2,4}}]neste caso. (não testou) #
21209 user202729
6
Há um built-in para isso, mas por mais tempo. O Mathematica possui nomes longos de funções.
alephalpha
11
Como não pôde, dado seu triunfo no desafio atual ?
ojdo
21

Tela , 14 12 bytes

H;[⌐⌐∔*×∔;3*+

Experimente aqui!

Explicação:
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
    3*|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 !

hakr14
fonte
Resposta incrivelmente curta: O
NL628
19

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)
Luis Mendo
fonte
16

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.

recursivo
fonte
11

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!

Value Ink
fonte
Bem feito! A saída parece errada no início, mas é boa quando diminui o zoom.
Eric Duminil
10

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!

xnor
fonte
9

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

ngn
fonte
8

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.

Giuseppe
fonte
8

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
Olivier Grégoire
fonte
salvar 5 bytes, adicionando uma importação estática para Math.pow
Selim
4
@Selim a importação estática é necessária na contagem de bytes. Então eu perderia ... 19 bytes.
Olivier Grégoire
7

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.

DJMcMayhem
fonte
Isso é francês?
Stan Strum
6

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
FrownyFrog
fonte
6

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.

nimi
fonte
3
Você deve ser capaz de golf (#)para baixo para g#f=g<>f<>gse você usar GHC 8.4. Isso ocorre porque Semigroupagora está no prelúdio.
Potato44
@ Potato44: Tenho certeza de que isso ajudará em muitos desafios. Obrigado!
nimi
5

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!

Ton Hospel
fonte
11
A saída para n ≥ 3 não está correta.
Primo
@primo O programa estava correto, mas o TIO usa a versão UTF-8 dos caracteres especiais. I fixou o link para usar escapes em vez disso, mas o programa ainda funciona se você usar os caracteres literais reais
Ton Hospel
Não tenho ideia do porquê \321é necessário, qualquer personagem parece funcionar. //e $'também pode substituir //ge $`, mas não tenho certeza se isso leva a uma melhoria.
Primo
11
@primo Obrigado! Eu ainda estava trabalhando com o código derivado da antiga solução mtve, onde \321estava o complemento de bit .(usado para gerar outro padrão fractal). Mas eu larguei o complemento de bits, então é claro que não preciso mais disso. Eu usei //ge $ `para que eu possa testar facilmente o código a partir da linha de comando ( //e $'não levar a um ganho que eu possa ver, o byte ganho é desperdiçado com um espaço ou !mais)
Ton Hospel
5

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.

Chiel ten Brinke
fonte
O que preciso digitar, iniciando em um prompt do bash, assumindo que tenho o vim instalado, para ver o resultado?
Fabien
Digite vim, pressione enter, digite o número de entrada (por exemplo, 3) no buffer e, no modo normal, pressione a sequência de teclas da postagem.
Chiel ten Brinke 13/03/2019
Certifique-se de usar vim baunilha
Chiel ten Brinke
Houve um erro de digitação no código. Apenas consertei.
Chiel ten Brinke 13/03/2019
11
Trabalho! <kbd> I </kbd> é um capital i, não ell. :set nowrappara ver o resultado, por 4 e mais.
Fabien
4

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!

MJacquet
fonte
2
Bem-vindo ao PPCG! Você pode omitir f←e contar caracteres como 1 byte cada um: codegolf.meta.stackexchange.com/questions/9428/... É também considerada legal para receber a entrada de , ou seja, substituir ⍣⍵com ⍣⎕e soltar chaves do DFN exterior.
NGN
Obrigado! Eu nunca joguei APL formalmente antes, então isso deve ajudar.
precisa saber é o seguinte
1 1⍴1pode ser gravado à medida que ⍪1as parênteses ao redor do operador se tornam desnecessárias. Se você conhece os trens, eles podem ajudar muito aqui.
NGN
Além disso, é seu amigo: (⍵,(0×⍵),⍵)=>(⍵,⍵,⍨0×⍵)
Zacharý
4

Carvão , 30 29 bytes

HFENX³ι«J⁰¦⁰C⁰ιCιιT⊗ι⊗ι‖OO→↓ι

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

H

Imprima o original H.

FENX³ι«

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

J⁰¦⁰

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

C⁰ι

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

Cιι

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

T⊗ι⊗ι

Apare a tela em uma Lforma triomino.

‖OO→↓ι

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:

HFN«⟲C²⁶‖OOLX³ι

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

Neil
fonte
4

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

HyperNeutrino
fonte
4

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

Titus
fonte
11
%3==1pode ser substituído por %3&1.
Primo13/
3

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*çþ`
user202729
fonte
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
Razvan Socol
fonte
Esta é a minha primeira resposta no Code Golf, por favor, ajude-me se eu cometer algum erro. Além disso, meu idioma preferido é o Transact-SQL, que não é muito adequado para códigos curtos.
Razvan Socol
11
Bem-vindo ao PPCG e bom primeiro post! Para obter dicas sobre golfe no T-SQL, verifique este post!
caird coinheringaahing
Tentei adicionar um sqlfiddle, mas ele não funciona bem com variáveis ​​de tabela. Se eu usar tabelas normais, é ainda 1 byte menor: sqlfiddle.com/#!18/eb14e/2 . No entanto, a saída não está formatada corretamente pelo sqlfiddle, mas funciona bem no SSMS.
Razvan Socol
11
Você deve conseguir reduzir para 259 removendo alguns espaços em branco e
linhas
Eu só cheguei a 261. O que estou perdendo?
Razvan Socol
2

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 .

Titus
fonte
2

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!

primo
fonte
Contando com este site mudou, você não precisa contar -pmais (eu acho que é demasiado branda para perl, mas é assim que é agora)
Ton Hospel
2

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!

primo
fonte
11
Você pode salvar um byte: em $s.$s.$svez de $s.=$s.$s. E você não precisa de, <?em -Rvez de -F.
Titus
Obrigado pelo byte. Em relação a -R, você pode me mostrar o uso completo?
Primo10/
Assim como -nF: echo <input> | php -nR '<code>'. -ré quase o mesmo: php -nr '<code>' <arguments>.
Titus
Talvez eu seja estúpido demais para fazê-lo funcionar: / i.stack.imgur.com/jqpmk.png
primo
11
preg_filteré iterar cada linha enquanto preserva novas linhas, aproximadamente equivalente a join("\n",array_map(function(){...},split("\n",$s.$s.$s))), mas significativamente menos detalhada. Inicialmente, eu str_padmudei para sprintfporque é um byte mais curto:'"\0".str_pad($$i++/$i&1?"\0":"",$i)."\0"'
primo 13/03
1

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

Chiel ten Brinke
fonte
1

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.

Bubbler
fonte
0

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