Cree una "H" a partir de "H" más pequeñas

73

Desafío

Cree una función o programa que, cuando se le da un número entero size , haga lo siguiente:

Si sizees igual a 1, salida

H H
HHH
H H

Si sizees mayor que 1, salida

X X
XXX
X X

donde Xes la salida del programa / función parasize - 1

(Si lo prefiere, puede hacer que el caso base corresponda a 0 , siempre que especifique en su respuesta)

Cualquiera de los siguientes formatos de salida son aceptables, el que sea más conveniente para usted:

  • Una cadena de la estructura requerida con dos caracteres distintos correspondientes a Hyspace

  • Una matriz bidimensional con la estructura requerida, con dos valores distintos correspondientes a Hyspace

  • Una matriz / lista de cadenas, con una línea de salida en cada cadena, con dos valores distintos correspondientes a Hyspace

Se permiten espacios iniciales, siempre que haya una cantidad constante de espacios iniciales en cada línea. Los dos caracteres de salida distintos pueden depender de cualquier cosa que elija, siempre que sean diferentes.

Especifique qué formato de salida está devolviendo su código.

Casos de prueba

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

Este es el , por lo que gana el conteo de bytes más bajo para cada idioma.

Bazinga_9000
fuente
44
Perfecto para carbón probablemente ... jajaja. ¡Bienvenido también a PPCG! : D
HyperNeutrino
10
Bienvenido a PPCG. ¡Buen primer desafío!
Adám
¿Podemos usar tamaños basados ​​en 0?
Adám
3
relacionado
ngn
1
Yo llamaría a esto un "Sierpinski H"
mbomb007

Respuestas:

28

Wolfram Language (Mathematica) , 46 bytes

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

Devuelve una matriz 2d de 0sy 1s.

Pruébalo en línea!

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

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

alephalpha
fuente
17
qué diablos, por supuesto, Mathematica tiene una función incorporada para matrices anidadas recursivas jajaja. +1
HyperNeutrino
1
@HyperNeutrino, obviamente
solo
77
@HyperNeutrino ¿Cómo se considera esto incorporado? Solo Nest(repetidamente) la función varias veces. Al igual que cualquier otra presentación (Jelly?) El ArrayFlattenestá ... bueno, integrado, pero se comporta de manera similar a un Flatten[#,{{1,3},{2,4}}]en este caso. (no probado)
usuario202729
66
Hay una función incorporada para esto, pero más larga. Mathematica tiene nombres de funciones largos.
alephalpha
1
¿Cómo podría no hacerlo, dado su triunfo en el desafío optimista ?
ojdo
21

Lienzo , 14 12 bytes

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

Pruébalo aquí!

Explicación:
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)                                                |

Donde Iestá la entrada, Xes el patrón generado por el bucle anterior ("H" para el primer bucle), y <space>es el espacio vacío en la primera y tercera fila del patrón, agregado implícitamente por .

-2 bytes gracias a dzaima !

hakr14
fuente
Respuesta increíblemente corta: O
NL628
19

MATL , 12 11 bytes

t:"[ACA]BX*

Dada la entrada n, esto genera una matriz que contiene 0yn .

Pruébalo en línea!

Para convertir esto en una matriz de caracteres Hy espacio, agregue g72*cel encabezado. ¡Pruébalo en línea también!

O agregue ]1YCpara ver la matriz que se muestra gráficamente. ¡Pruébalo en MATL Online!

Explicación

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
fuente
16

Stax , 16 15 bytes

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

Ejecutar y depurarlo

Esta es la representación ascii del programa con comentarios. Este programa construye la H lateralmente y luego se transpone una vez al 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 adicional de 14 bytes : utiliza su entrada como el carácter de salida. Teóricamente, esto no produciría la forma correcta en 10, ya que tiene 2 dígitos, pero el intento de ejecutarlo bloquea mi navegador.

recursivo
fuente
11

Rubí , 72 bytes

La salida es una lista de cadenas, una cadena por línea.

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

Pruébalo en línea!

Tinta de valor
fuente
¡Bien hecho! La salida se ve mal en tio al principio, pero está bien cuando se aleja.
Eric Duminil
9

APL (Dyalog Classic) , 14 bytes

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

Pruébalo en línea!

entrada evaluada

,⍳⎕⍴3 todas las n-tuplas con elementos de 0 1 2

2| mod 2

×/¨∘.≥⍨ formar una matriz comparando cada par de tuplas a y b - si todos los elementos de a son ≥ los elementos correspondientes de b, es un 1, de lo contrario 0

ngn
fuente
8

R , 64 bytes

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

Pruébalo en línea!

Reduce por producto Kronecker, como un puerto descarado de la respuesta de Luis Mendo .

El pie de página imprime el resultado muy bien, pero esto es una función anónima que devuelve una matrixde 1para Hy 0por el espacio.

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

Pruébalo en línea!

Devuelve un int[][]con 0for Hy 1for space. Esto realmente "talla" una pared de H's en lugar de "amontonar"H .

Explicaciones

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
fuente
ahorre 5 bytes agregando una importación estática para Math.pow
Selim
44
@Selim, la importación estática se requiere en el recuento de bytes. Entonces perdería ... 19 bytes.
Olivier Grégoire
6

J , 25 22 bytes

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

Pruébalo en línea!

        */               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
fuente
6

Haskell, 73 67 64 55 bytes

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

Esto funciona solo con la última versión de Prelude, porque exporta <>desde Data.Semigroup. Para ejecutarlo en TIO, agregue una importación como se hace aquí: ¡ Pruébelo en línea!

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

Editar: -9 bytes gracias a @ Potato44.

nimi
fuente
3
Usted debe ser capaz de campo de (#)abajo a g#f=g<>f<>gsi se utiliza GHC 8.4. Esto se debe a Semigroupque ahora está en el preludio.
Patata44
@ Potato44: Estoy bastante seguro de que esto ayudará en muchos desafíos. ¡Gracias!
nimi
5

Perl 5 , 46 44 43 41 40 bytes

1 recuento basado. Usos 0y 1para Hy espacio, tiene un líder 1(espacio)

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

Basado en una idea clásica de mtve.

Pruébalo en línea!

Ton Hospel
fuente
1
La salida para n ≥ 3 no es del todo correcta.
primo
@primo El programa era correcto pero TIO usa la versión UTF-8 de los caracteres especiales. Arreglé el enlace para usar escapes en su lugar, pero el programa aún funciona si usas los caracteres literales reales
Ton Hospel el
No tengo idea de por qué \321es necesario, cualquier personaje parece funcionar. //y $'también puede reemplazar //gy $`, pero no estoy seguro de que conduzca a una mejora.
primo
1
@primo Gracias! Todavía estaba trabajando a partir del código derivado de la antigua solución mtve donde \321estaba el complemento de bits .(usado para generar otro patrón fractal). Pero dejé caer el complemento de bits, así que, por supuesto, ya no lo necesito. Utilicé //gy $ `para poder probar fácilmente el código desde la línea de comandos ( //y $'no llevar a una ganancia que pueda ver, el byte obtenido se desperdicia con un espacio o de !nuevo)
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

La entrada se toma como un número en el búfer.

Chiel ten Brinke
fuente
¿Qué debo escribir, comenzando desde un indicador de bash, suponiendo que tengo instalado vim, para ver el resultado?
Fabien
Escriba vim, presione enter, escriba el número de entrada (por ejemplo, 3) en el búfer y luego, desde el modo normal, presione la secuencia de teclas de la publicación.
Chiel ten Brinke
Asegúrese de usar Vanilla Vim
Chiel ten Brinke
Había un error tipográfico en el código. Solo lo arreglé.
Chiel ten Brinke
1
¡Trabajos! <kbd> I </kbd> es una i mayúscula, no ell. :set nowrappara ver el resultado, para 4 y más.
Fabien
4

APL (Dyalog Unicode) , 38 34 bytes SBCS

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

La salida es una matriz bidimensional con 1representación de H y0 representa el espacio.

Pruébalo en línea!

MJacquet
fuente
2
Bienvenido a PPCG! Puede omitir f←y contar caracteres como 1 byte cada uno: codegolf.meta.stackexchange.com/questions/9428/… También se considera legal tomar la entrada , es decir, reemplazar⍣⍵ con ⍣⎕y soltar las llaves externas de dfn.
ngn
¡Gracias! En realidad nunca antes había practicado golf APL formalmente, así que esto debería ayudar.
MJacquet
1 1⍴1puede escribirse como ⍪1y luego los parens alrededor del operador se vuelven innecesarios. Si estás familiarizado con los trenes , pueden ayudar mucho aquí.
ngn
Además, es tu amigo: (⍵,(0×⍵),⍵)=>(⍵,⍵,⍨0×⍵)
Zacharý
4

Carbón , 30 29 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

H

Imprime el original H.

FENX³ι«

Recorre los primeros sizepoderes de 3.

J⁰¦⁰

Mueva el cursor de regreso al origen. Trimnecesita esto, ya que tanto la impresión original Hcomo la reflexión a continuación mueven el cursor.

C⁰ι

Copie la iteración anterior hacia abajo, creando un dominó.

Cιι

Copie el resultado hacia abajo y hacia la derecha, creando un tetromino.

T⊗ι⊗ι

Recorte el lienzo hasta una Lforma triomino.

‖OO→↓ι

Refleje el lienzo horizontal y verticalmente con superposición, completando la iteración.

El carbón es mejor en algunos fractales que en otros. Aquí hay una idea similar, pero en casi la mitad del tamaño:

HFN«⟲C²⁶‖OOLX³ι

Pruébalo en línea! El enlace es a la versión detallada del código.

Neil
fuente
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

Pruébalo en línea!

-30 bytes gracias a recursivo

El código del contenedor es para un buen formato. funciona bien si lo quitas

Hiperneutrino
fuente
Algunos campos de golf
recursivo el
4

PHP 7, 125 109 bytes

Un enfoque diferente: en lugar de anidar y aplanar el resultado de forma recursiva, esto solo recorre las filas y columnas y utiliza un tercer ciclo para averiguar si imprimir Ho_ .

Editar: ahorró mucho combinando los bucles de fila / columna en uno, aunque tomó un poco obtener la disminución correcta del bucle interno. Requiere PHP 7 para el operador de energía.

¡Pruébalos en línea !


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 el resultado. Corre como tubería con-nR .

función calificada, 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;}

devuelve una sola cadena. Ejecutar con la configuración predeterminada (no php.ini).

Tito
fuente
1
%3==1puede ser reemplazado con %3&1.
primo
3

Jalea , 25 bytes

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

Pruébalo en línea!


Aunque esto es más largo que la presentación Jelly existente , intenta generar cada personaje independientemente de la coordenada.

En particular, si la coordenada es (x,y)(indexación 1), el primer enlace regresa 0y 1corresponde a Hy 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.

Además, los 5 bytes ị⁾ HYse usan para formatear, por lo que este programa (20 bytes) también es válido (pero el resultado no se ve tan bien):

,’b3U×"3S_4A1e
3*çþ`
usuario202729
fuente
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
fuente
Esta es mi primera respuesta en Code Golf, así que, por favor, ayúdenme si cometí algún error. Además, mi idioma preferido es Transact-SQL, que no es muy adecuado para código corto.
Razvan Socol
1
¡Bienvenido a PPCG y buen primer post! Para consejos sobre golf en T-SQL, ¡asegúrate de revisar esta publicación!
caird coinheringaahing
Intenté agregar un sqlfiddle, pero no funciona bien con las variables de tabla. Si uso tablas normales, es incluso 1 byte más corto: sqlfiddle.com/#!18/eb14e/2 . Sin embargo, el resultado no está formateado correctamente por sqlfiddle, pero funciona bien en SSMS.
Razvan Socol
1
Debería poder reducir esto a 259 eliminando algunos espacios en blanco y
saltos de
Solo llegué al 261. ¿Qué me estoy perdiendo?
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;}

Ejecute con la configuración predeterminada (no php.ini) o pruébelo en línea .

Tito
fuente
2

Perl, 64 bytes

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

Requiere -p, la entrada se toma de stdin. La salida es una H de Hs.

Pruébalo en línea!

primo
fuente
Contar en este sitio ha cambiado, ya no es necesario contar -p(creo que es demasiado indulgente para Perl, pero así es ahora)
Ton Hospel
2

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;

Usado con la -Fopción de línea de comando. Asume los valores predeterminados del intérprete ( -n). No funcionará en versiones anteriores a 5.6, debido al operador de energía.

Uso de la muestra

$ 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

Pruébalo en línea!

primo
fuente
1
Puede guardar un byte: en $s.$s.$slugar de $s.=$s.$s. Y no necesitas <?con en -Rlugar de -F.
Titus
Gracias por el byte. En cuanto a -R, ¿me puede mostrar el uso completo?
primo
Al igual que -nF: echo <input> | php -nR '<code>'. -res casi lo mismo: php -nr '<code>' <arguments>.
Titus
Tal vez soy demasiado estúpido para que funcione: / i.stack.imgur.com/jqpmk.png
primo
1
preg_filteres iterar cada línea mientras se preservan las nuevas líneas, aproximadamente equivalentes a join("\n",array_map(function(){...},split("\n",$s.$s.$s))), pero significativamente menos detalladas. Inicialmente tuve str_padpero cambié a sprintfporque es un byte más corto:'"\0".str_pad($$i++/$i&1?"\0":"",$i)."\0"'
primo
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 realiza una recursión "codificada a mano" bastante detallada. No hay multiplicaciones de matrices inteligentes. A lo largo de la recursión, en la parte superior de la pila hay una matriz que recopila la salida obtenida de las llamadas primarias. Justo después de cada conjunto de llamadas recursivas, la salida de las llamadas recursivas debe comprimirse para asegurarse de que la salida sea correcta cuando la pila se imprime linealmente al final del programa. La pila de argumentos que se pasa por la recursividad se mantiene en la variable A.

Probar en línea

Chiel ten Brinke
fuente
1

Japt , 23 bytes

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

Pruébalo en línea!

Desempaquetado y cómo 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 el patrón transpuesto

III
 I 
III

es mucho más fácil de manejar que el Hpatrón original , al menos en Japt, donde Ise puede hacer con repetición de cadena y relleno central.

Bubbler
fuente
0

C ++ 11 - 138 bytes

Sin embargo, no estoy seguro si esta respuesta tiene una sintaxis válida aquí.

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

Sin golfing con código de trabajo

#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
fuente