Sfida

Creare una funzione o un programma che, quando viene assegnato un numero intero size, procede come segue:

Se sizeè uguale a 1, output

H H
HHH
H H

Se sizeè maggiore di 1, output

X X
XXX
X X

dove Xè l'output del programma / funzione persize - 1

(Se preferisci, potresti avere il caso base corrispondente 0, purché specifichi nella tua risposta)

Uno dei seguenti formati di output è accettabile, a seconda di quale sia più conveniente per te:

• Una stringa della struttura richiesta con due caratteri distinti corrispondenti a Hespace

• Un array bidimensionale con la struttura richiesta, con due valori distinti corrispondenti a Hespace

• Un array / elenco di stringhe, con una riga dell'output in ciascuna stringa, con due valori distinti corrispondenti a Hespace

Gli spazi iniziali sono consentiti, purché vi sia una quantità costante di spazi iniziali su ciascuna linea. I due caratteri di output distinti possono dipendere da qualsiasi cosa tu scelga, purché diversi.

Specifica quale formato di output restituisce il tuo codice.

Casi test

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

Questo è code-golf , quindi vince il conteggio di byte più basso per ogni lingua!

Wolfram Language (Mathematica) , 46 byte

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

Restituisce un array 2d di 0s e 1s.

Provalo online!

Tela , 14 12 byte

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

Provalo qui!

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

Dov'è Il'input, Xè il pattern generato dal loop precedente ("H" per il primo loop), ed <space>è lo spazio vuoto sulla prima e terza riga del pattern, aggiunto implicitamente da ＋.

-2 byte grazie a dzaima !

MATL , 12 11 byte

t:"[ACA]BX*

Dato input n, questo genera una matrice contenente 0e n.

Provalo online!

Per convertire questo in una matrice di caratteri di He spazio aggiungere g72*cnell'intestazione. Provalo anche online!

Oppure aggiungi ]1YCper vedere la matrice visualizzata graficamente. Provalo su MATL Online!

Spiegazione

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 byte

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

Esegui ed esegui il debug

Questa è la rappresentazione ASCII del programma con commenti. Questo programma costruisce la H lateralmente e poi traspone una volta alla fine.

'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

Programma bonus da 14 byte - usa il suo input come carattere di output. Teoricamente, questo non produrrebbe la forma giusta a 10, poiché ha 2 cifre, ma il tentativo di eseguire si blocca il mio browser.

Rubino , 72 byte

L'output è un elenco di stringhe, una stringa per riga.

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

Provalo online!

Haskell , 50 byte

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

Provalo online!

Crea una griglia di 0 e 1. Un personaggio in più per gli spazi e gli H.

Haskell , 51 byte

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

Provalo online!

Gelatina , 17 16 15 byte

381B«€s3Z€ẎF€µ¡

Questo è un programma completo che stampa un array 2D di 1 'e 0 '.

Provalo online! oppure vedi l'output con H e spazi.

APL (Dyalog Classic) , 14 byte

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

Provalo online!

⎕ input valutato n

,⍳⎕⍴3 tutte le n-tuple con elementi da 0 1 2

2| mod 2

×/¨∘.≥⍨ forma una matrice confrontando ogni coppia di tuple a e b - se tutti gli elementi di a sono ≥ gli elementi corrispondenti di b, è un 1, altrimenti 0

SOGL V0.12 , 13 byte

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

Provalo qui!

R , 64 byte

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

Provalo online!

Riduce dal prodotto Kronecker, come un porto spudorato della risposta di Luis Mendo .

Il piè di pagina stampa bene il risultato, ma questa è una funzione anonima che restituisce un valore matrixdi 1for He 0per spazio.

Java (OpenJDK 9) , 135 byte

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

Provalo online!

Restituisce un int[][]con 0per He 1per space. Questo in realtà "scolpisce" un muro di H"invece di" accatastare " H.

spiegazioni

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 byte

éHÀñäLgvr PGï3PkyHGpH

Provalo online!

hexdump:

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

Questo è sostanzialmente lo stesso approccio del tappeto Sierpinski e The Fractal Plus su Anarchy Golf.

Python 2 , 70 byte

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

Provalo online!

La funzione genera un elenco di stringhe.

Python 2 , 84 byte

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

Provalo online!

Utilizza lo stesso modello degli altri schemi frattali 3 * 3:

• Tappeto Sierpinski
• Frattale X
• Frattale Plus .

J , 25 22 byte

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

Provalo 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 byte

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

Funziona solo con l'ultima versione di Prelude, perché esporta <>da Data.Semigroup. Per eseguirlo su TIO, aggiungi un'importazione come fatto qui: provalo 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

Modifica: -9 byte grazie a @ Potato44.

Perl 5 , 46 44 43 41 40 byte

1 conteggio basato. Usi 0e 1per He spazio, ha un vantaggio 1(spazio)

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

Basato su un'idea classica di mtve.

Provalo online!

Vim - 66 56 54 byte

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

L'input viene preso come numero nel buffer.

APL (Dyalog Unicode) , 38 34 byte ^SBCS

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

L'output è un array bidimensionale che 1rappresenta H e 0rappresenta lo spazio.

Provalo online!

Carbone , 30 29 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

H

Stampa l'originale H.

ＦＥＮＸ³ι«

Passa sopra i primi sizepoteri di 3.

Ｊ⁰¦⁰

Riporta il cursore sull'origine. Trimserve questo, poiché sia ​​la stampa originale del Hche il riflesso in basso spostano il cursore.

Ｃ⁰ι

Copia la precedente iterazione verso il basso, creando un domino.

Ｃιι

Copia il risultato verso il basso e verso destra, creando un tetromino.

Ｔ⊗ι⊗ι

Taglia la tela fino a Lformare un triomino.

‖ＯＯ→↓ι

Rifletti la tela in orizzontale e in verticale con sovrapposizioni, completando l'iterazione.

Il carbone è meglio in alcuni frattali di altri. Ecco un'idea simile, ma in quasi la metà delle dimensioni:

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

Python 2 , 143 byte

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

Provalo online!

-30 byte grazie a ricorsivo

il codice wrapper è per una buona formattazione. funziona bene se lo rimuovi

PHP 7, 125 109 byte

un approccio diverso: invece di annidare e appiattire il risultato in modo ricorsivo, questo scorre semplicemente attraverso le righe e le colonne e utilizza un terzo ciclo per scoprire se stampare Ho _.

Modifica: salvato molto combinando i loop di riga / colonna in uno, anche se ci è voluto un po 'per ottenere la riduzione corretta per il loop interno. Richiede PHP 7 per l'operatore elettrico.

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

stampa il risultato. Esegui come pipe con -nR.

funzione qualificata, 147 130 byte

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

restituisce una singola stringa. Esegui con la configurazione predefinita (no php.ini).

Gelatina , 25 byte

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

Provalo online!

Anche se questo è più lungo dell'invio di Jelly esistente , cerca di generare ogni personaggio indipendentemente dalle coordinate.

In particolare, se la coordinata è (x,y)(1-indicizzazione), il primo collegamento ritorna 0e 1corrisponde He rispettivamente a e .

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

Inoltre, i 5 byte ị⁾ HYvengono utilizzati per la formattazione, quindi anche questo programma (20 byte) è valido (ma l'output non sembra carino):

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

T-SQL , 267 261 byte

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 byte

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

Esegui con la configurazione predefinita (no php.ini) o provalo online .

Perl, 64 byte

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

Richiede -p, l'input è preso dallo stdin. L'output è una H di Hs.

Provalo online!

PHP (5.6+), 94 byte

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

Utilizzato con l' -Fopzione della riga di comando. Presuppone i valori predefiniti dell'interprete ( -n). Non funzionerà su versioni precedenti alla 5.6, a causa dell'operatore di potenza.

Utilizzo del campione

$ 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

Provalo online!

CJam - 103 97 87 76 byte

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

Questo programma esegue una ricorsione "codificata a mano" piuttosto dettagliata. Nessuna moltiplicazione della matrice intelligente. Durante la ricorsione, in cima allo stack c'è un array che raccoglie l'output ottenuto dalle chiamate principali. Subito dopo ogni serie di chiamate ricorsive l'output delle chiamate ricorsive deve essere compresso insieme, per assicurarsi che l'output sia corretto quando lo stack viene stampato in modo lineare alla fine del programma. Lo stack di argomenti trasmessi durante la ricorsione viene mantenuto nella variabile A.

Prova online

K (ngn / k) , 18 byte

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

Provalo online!

Japt , 23 byte

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

Provalo online!

Disimballato e come funziona

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 il modello trasposto

III
 I 
III

è molto più facile da gestire rispetto al Hmodello originale , almeno in Japt dove Ipuò essere fatto con la ripetizione delle corde e l'imbottitura centrale.

C ++ 11 - 138 byte

Tuttavia, non sono sicuro che questa risposta abbia una sintassi valida qui.

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

Non registrato con codice funzionante

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