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 código de golf , por lo que gana el conteo de bytes más bajo para cada idioma.

Wolfram Language (Mathematica) , 46 bytes

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

Devuelve una matriz 2d de 0sy 1s.

Pruébalo en línea!

Lienzo , 14 12 bytes

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

Pruébalo aquí!

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

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 !

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)

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.

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!

Haskell , 50 bytes

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

Pruébalo en línea!

Hace una cuadrícula de 0 y 1. Un personaje más largo para espacios y H's.

Haskell , 51 bytes

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

Pruébalo en línea!

Jalea , 17 16 15 bytes

381B«€s3Z€ẎF€µ¡

Este es un programa completo que imprime una matriz 2D de 1 y 0 .

Pruébalo en línea! o vea la salida con H 'sy espacios.

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

SOGL V0.12 , 13 bytes

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

Pruébalo aquí!

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.

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

V , 22 bytes

éHÀñäLgvr PGï3PkyHGpH

Pruébalo en línea!

Hexdump:

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

Este es básicamente el mismo enfoque que la alfombra Sierpinski y The Fractal Plus en 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)]

Pruébalo en línea!

La función genera una lista de cadenas.

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

Pruébalo en línea!

Utiliza la misma plantilla que otros patrones fractales 3 * 3:

• Alfombra Sierpinski
• Fractal X
• Fractal plus .

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

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.

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!

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.

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!

Carbón , 30 29 bytes

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

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

H

Imprime el original H.

ＦＥＮＸ³ι«

Recorre los primeros sizepoderes de 3.

Ｊ⁰¦⁰

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.

Ｃ⁰ι

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

Ｃιι

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

Ｔ⊗ι⊗ι

Recorte el lienzo hasta una Lforma triomino.

‖ＯＯ→↓ι

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:

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

Pruébalo en línea! El enlace es a la versión detallada del 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

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

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

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*çþ`

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

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

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!

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!

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

K (ngn / k) , 18 bytes

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

Pruébalo en línea!

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.

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