Défi

Créez une fonction ou un programme qui, lorsqu'un entier est attribué size, effectue les opérations suivantes:

Si sizeest égal à 1, sortie

H H
HHH
H H

Si sizeest supérieur à 1, sortie

X X
XXX
X X

où Xest la sortie du programme / fonction poursize - 1

(Si vous préférez, vous pouvez faire correspondre le scénario de base à 0condition que vous le précisiez dans votre réponse)

Tous les formats de sortie suivants sont acceptables, selon ce qui vous convient le mieux:

• Une chaîne de la structure requise avec deux caractères distincts correspondant à Hetspace

• Un tableau à deux dimensions avec la structure requise, avec deux valeurs distinctes correspondant à Hetspace

• Un tableau / une liste de chaînes, avec une ligne de la sortie dans chaque chaîne, avec deux valeurs distinctes correspondant à Hetspace

Les espaces de début sont autorisés, tant qu'il y a un nombre constant d'espaces de début sur chaque ligne. Les deux caractères de sortie distincts peuvent dépendre de tout ce que vous choisissez, tant qu'ils sont différents.

Spécifiez le format de sortie renvoyé par votre code.

Cas de 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

Il s’agit d’un code-golf , le nombre d’octets le plus faible pour chaque langue a donc gagné!

Wolfram Language (Mathematica) , 46 octets

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

Retourne un tableau 2d de 0s et 1s.

Essayez-le en ligne!

Toile , 14 à 12 octets

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

Essayez-le ici!

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

Où Iest l'entrée, Xle motif généré par la boucle précédente ("H" pour la première boucle) et <space>l'espace vide de la première et de la troisième rangée du motif, ajouté implicitement par ＋.

-2 octets grâce à dzaima !

MATL , 12 à 11 octets

t:"[ACA]BX*

Avec une entrée donnée n, ceci produit une matrice contenant 0et n.

Essayez-le en ligne!

Pour convertir ceci en matrice de caractères Het espace ajouter g72*cdans l'en-tête. Essayez-le aussi en ligne!

Ou ajouter ]1YCpour voir la matrice affichée graphiquement. Essayez-le sur MATL Online!

Explication

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 octets

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

Exécuter et déboguer

Ceci est la représentation ascii du programme avec commentaires. Ce programme construit le H latéralement, puis se transpose une fois à la fin.

'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

Programme Bonus 14 octets - utilise son entrée comme caractère de sortie. Théoriquement, cela ne produirait pas la bonne forme à 10, car il a 2 chiffres, mais tenter de l'exécuter bloque mon navigateur.

Ruby , 72 octets

La sortie est une liste de chaînes, une chaîne par ligne.

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

Essayez-le en ligne!

Haskell , 50 octets

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

Essayez-le en ligne!

Fait une grille de 0 et de 1. Un caractère plus long pour les espaces et les H.

Haskell , 51 octets

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

Essayez-le en ligne!

Jelly , 17 16 15 octets

381B«€s3Z€ẎF€µ¡

C'est un programme complet qui imprime un tableau 2D de 1 et de 0 .

Essayez-le en ligne! ou voir la sortie avec H et les espaces.

APL (Dyalog Classic) , 14 octets

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

Essayez-le en ligne!

⎕ entrée évaluée n

,⍳⎕⍴3 tous les n-tuples avec des éléments de 0 1 2

2| mod 2

×/¨∘.≥⍨ forme une matrice en comparant chaque paire de tuples a et b - si tous les éléments de a sont ≥ les éléments correspondants de b, c'est un 1, sinon 0

SOGL V0.12 , 13 octets

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

Essayez-le ici!

R , 64 octets

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

Essayez-le en ligne!

Réduit par le produit Kronecker, un port sans vergogne de la réponse de Luis Mendo .

Le pied de page affiche le résultat bien, mais cela est une fonction anonyme qui retourne un matrixdes 1pour Het 0pour l' espace.

Java (OpenJDK 9) , 135 octets

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

Essayez-le en ligne!

Retourne un int[][]avec 0pour Het 1pour space. En fait, cela "sculpte" un mur de H's au lieu de "empiler" H.

Des explications

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 octets

éHÀñäLgvr PGï3PkyHGpH

Essayez-le en ligne!

Hexdump:

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

C'est fondamentalement la même approche que le tapis Sierpinski et The Fractal Plus sur Anarchy Golf.

Python 2 , 70 octets

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

Essayez-le en ligne!

La fonction génère une liste de chaînes.

Python 2 , 84 octets

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

Essayez-le en ligne!

Utilise le même modèle que les autres modèles fractals 3 * 3:

• Tapis Sierpinski
• Fractale x
• Fractal plus .

J , 25 22 octets

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

Essayez-le en ligne!

        */               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 octets

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

Cela ne fonctionne qu'avec la dernière version de Prelude, car il exporte <>depuis Data.Semigroup. Pour l'exécuter sur TIO, ajoutez une importation comme faite ici: Essayez-le en ligne!

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 octets grâce à @ Potato44.

Perl 5 , 46 44 43 41 40 octets

1 décompte basé. Usages 0et 1pour Het espace, a une avance 1(espace)

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

Basé sur une idée classique de mtve.

Essayez-le en ligne!

Vim - 66 56 54 octets

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'entrée est considérée comme un nombre dans la mémoire tampon.

APL (Dyalog Unicode) , 38 ^{SBCS de} 34 octets

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

La sortie est un tableau à 2 dimensions avec 1H et l' 0espace.

Essayez-le en ligne!

Charbon de bois , 30 29 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

H

Imprimez l'original H.

ＦＥＮＸ³ι«

Boucle sur les premières sizepuissances de 3.

Ｊ⁰¦⁰

Ramène le curseur à l'origine. Trima besoin de cela car l’impression originale de la Het la réflexion ci-dessous déplacent le curseur.

Ｃ⁰ι

Copiez l'itération précédente vers le bas pour créer un domino.

Ｃιι

Copiez le résultat vers le bas et à droite pour créer un tétromino.

Ｔ⊗ι⊗ι

Coupez la toile en Lforme de triomino.

‖ＯＯ→↓ι

Réfléchissez la toile horizontalement et verticalement avec un chevauchement, complétant l'itération.

Le charbon de bois est meilleur sur certaines fractales que sur d’autres. Voici une idée similaire, mais presque deux fois plus petite:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code.

Python 2 , 143 octets

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

Essayez-le en ligne!

-30 octets grâce à récursif

le code wrapper est pour une bonne mise en forme. cela fonctionne bien si vous l'enlevez

PHP 7, 125 109 octets

une approche différente: au lieu d’implémenter et d’aplatir le résultat de manière récursive, il suffit de parcourir les rangées et les colonnes et d’utiliser une troisième boucle pour savoir s’il faut imprimer Hou non _.

Edit: beaucoup de choses en combinant les boucles de lignes / colonnes à une, bien qu’il ait fallu un peu pour que la diminution de la boucle interne soit correcte. Requiert PHP 7 pour l'opérateur électrique.

Essayez-les en ligne !

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

affiche le résultat. Courez comme un tuyau avec -nR.

fonction qualifiée, 147 130 octets

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

renvoie une seule chaîne. Exécuter avec la configuration par défaut (non php.ini).

Gelée , 25 octets

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

Essayez-le en ligne!

Bien que cela soit plus long que la soumission Jelly existante , elle essaie de générer chaque caractère indépendamment à partir de la coordonnée.

En particulier, si la coordonnée est (x,y)(1-indexation), le premier lien retourne 0et 1correspond à Het respectivement.

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

De plus, les 5 octets ị⁾ HYétant utilisés pour le formatage, ce programme (20 octets) est également valide (mais le résultat n'est pas aussi beau):

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

T-SQL , 267 261 octets

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 octets

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

Exécutez avec la configuration par défaut (non php.ini) ou essayez-le en ligne .

Perl, 64 octets

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

Requiert -p, l'entrée provient de stdin. La sortie est un H de Hs.

Essayez-le en ligne!

PHP (5.6+), 94 octets

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

Utilisé avec l' -Foption de ligne de commande. Suppose que l’interprète utilise les valeurs par défaut ( -n). Ne fonctionnera pas sur les versions antérieures à 5.6, à cause de l'opérateur électrique.

Utilisation de l'échantillon

$ 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

Essayez-le en ligne!

CJam - 103 97 87 76 octets

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

Ce programme effectue une récursion assez verbeuse "codée à la main". Pas de multiplications matricielles intelligentes. Tout au long de la récursivité, au-dessus de la pile, il y a un tableau rassemblant les résultats obtenus à partir des appels parents. Juste après chaque ensemble d'appels récursifs, la sortie des appels récursifs doit être compressée pour que la sortie soit correcte lorsque la pile est imprimée linéairement à la fin du programme. La pile d'arguments transmise à la récursivité est conservée dans la variable A.

Essayer en ligne

K (ngn / k) , 18 octets

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

Essayez-le en ligne!

Japt , 23 octets

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

Essayez-le en ligne!

Déballé et comment ça marche

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

Utiliser le motif transposé

III
 I 
III

est beaucoup plus facile à manipuler que le Hmotif original , du moins dans Japt où l’ Ion peut le faire avec répétition de chaîne et remplissage central.

C ++ 11 - 138 octets

Pas sûr si cette réponse a une syntaxe valide ici cependant.

#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 avec code de travail

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