Créer un «H» à partir de petits «H»

73

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

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 , le nombre d’octets le plus faible pour chaque langue a donc gagné!

Bazinga_9000
la source
4
Parfait pour le charbon de bois probablement ... lol. Bienvenue aussi à PPCG! : D
HyperNeutrino
10
Bienvenue chez PPCG. Beau premier challenge!
Adám
Peut-on utiliser 0 tailles basées?
Adám
3
liées
ngn
1
Je l'appellerais un "Sierpinski H"
mbomb007

Réponses:

28

Wolfram Language (Mathematica) , 46 octets

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

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

Essayez-le en ligne!

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

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

Alephalpha
la source
17
Mathematica a une fonction intégrée pour les tableaux imbriqués récursifs lol. +1
HyperNeutrino
1
@HyperNeutrino bien évidemment
ASCII seulement
7
@HyperNeutrino Comment cela est-il considéré comme intégré? Juste Nest(plusieurs fois) la fonction plusieurs fois. Comme toutes les autres soumissions (Jelly?) Le ArrayFlatten... est ... bien intégré, mais il se comporte un peu comme Flatten[#,{{1,3},{2,4}}]dans ce cas. (n'a pas testé)
user202729
6
Il y a un construit pour cela, mais plus longtemps. Mathematica a des noms de fonction longs.
Alephalpha
1
Comment pourrait-il ne pas, compte tenu de son triomphe au défi upgoat ?
Ojdo
21

Toile , 14 à 12 octets

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

Essayez-le ici!

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

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 !

hakr14
la source
Réponse étonnamment courte: O
NL628
19

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

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.

récursif
la source
11

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!

Valeur d'encre
la source
Bien joué! La sortie semble fausse sur tio au début, mais c’est bien quand on fait un zoom arrière.
Eric Duminil
10

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!

Xnor
la source
9

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

ngn
la source
8

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.

Giuseppe
la source
8

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
Olivier Grégoire
la source
économiser 5 octets en ajoutant une importation statique pour Math.pow
Selim
4
@Selim l'importation statique est requise dans le nombre d'octets. Donc, je perdrais ... 19 octets.
Olivier Grégoire
7

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.

DJMcMayhem
la source
Est-ce français?
Stan Strum
6

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
FrownyFrog
la source
6

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.

nimi
la source
3
Vous devriez être en mesure de jouer au golf (#)jusqu'à g#f=g<>f<>gsi vous utilisez GHC 8.4. C'est parce que Semigroupc'est maintenant dans le prélude.
Potato44
@ Potato44: Je suis sûr que cela aidera dans beaucoup de défis. Merci!
nimi
5

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!

Ton Hospel
la source
1
La sortie pour n ≥ 3 n'est pas tout à fait correcte.
primo
@primo Le programme était correct mais TIO utilise la version UTF-8 des caractères spéciaux. J'ai corrigé le lien pour utiliser des échappements à la place, mais le programme fonctionne toujours si vous utilisez les caractères littéraux réels
Ton Hospel
Je ne sais pas pourquoi \321est nécessaire, tout personnage semble fonctionner. //et $'peut également remplacer //get $`, mais je ne suis pas sûr que cela mène à une amélioration.
primo
1
@primo Merci! Je travaillais toujours à partir d'un code dérivé de l'ancienne solution mtve où se \321trouvait le complément de bits de .(utilisé pour générer un autre motif fractal). Mais j'ai abandonné le bit-complément, bien entendu, je n'en ai plus besoin. J'ai utilisé //get $ `afin que je puisse facilement tester le code depuis la ligne de commande ( //et $'ne mène pas à un gain que je peux voir, l'octet gagné est perdu avec un espace ou !encore)
Ton Hospel
5

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.

Chiel ten Brinke
la source
Que dois-je taper, à partir d'une invite bash, en supposant que vim soit installé, pour voir le résultat?
Fabien
Tapez vim, appuyez sur enter, tapez le numéro d'entrée (par exemple 3) dans la mémoire tampon puis, en mode normal, appuyez sur la séquence de touches de la poste.
Chiel ten Brinke
Assurez-vous d'utiliser vanille vim
Chiel ten Brinke
Il y avait une faute de frappe dans le code. Je viens de le réparer.
Chiel ten Brinke
1
Travaux! <kbd> I </ kbd> est une capitale, pas une brique. :set nowrappour voir le résultat, pour 4 et plus.
Fabien
4

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!

MJacquet
la source
2
Bienvenue chez PPCG! Vous pouvez omettre f←et compter les caractères comme 1 octet chacun: codegolf.meta.stackexchange.com/questions/9428/… Il est également considéré comme légal de prendre des entrées , c'est-à-dire de les remplacer ⍣⍵par ⍣⎕des accolades du dfn extérieur.
ngn
Merci! Je n'ai jamais joué officiellement à l'APL auparavant, alors cela devrait aider.
MJacquet
1 1⍴1peut être écrit au fur ⍪1et à mesure que les parens autour de l'opérateur deviennent inutiles. Si vous connaissez les trains , ils peuvent beaucoup vous aider ici.
ngn
Aussi, est votre ami: (⍵,(0×⍵),⍵)=>(⍵,⍵,⍨0×⍵)
Zacharý
4

Charbon de bois , 30 29 octets

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

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

H

Imprimez l'original H.

FENX³ι«

Boucle sur les premières sizepuissances de 3.

J⁰¦⁰

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.

C⁰ι

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

Cιι

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

T⊗ι⊗ι

Coupez la toile en Lforme de triomino.

‖OO→↓ι

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:

HFN«⟲C²⁶‖OOLX³ι

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

Neil
la source
4

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

HyperNeutrino
la source
Quelques golfs
récursif du
4

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

Titus
la source
1
%3==1peut être remplacé par %3&1.
Primo
3

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*çþ`
utilisateur202729
la source
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
Razvan Socol
la source
Ceci est ma première réponse sur Code Golf, alors aidez-moi si je fais des erreurs. De plus, ma langue préférée est Transact-SQL, qui ne convient pas très bien aux codes courts.
Razvan Socol
1
Bienvenue sur PPCG et bon premier post! Pour des conseils sur le golf dans T-SQL, consultez ce post!
Caird coinheringaahing
J'ai essayé d'ajouter un sqlfiddle, mais cela ne fonctionne pas bien avec les variables de table. Si j'utilise des tables normales, c'est encore plus court d'un octet: sqlfiddle.com/#!18/eb14e/2 . Cependant, la sortie n'est pas formatée correctement par sqlfiddle, mais cela fonctionne bien dans SSMS.
Razvan Socol
1
Vous devriez pouvoir réduire ce nombre à 259 en supprimant certains espaces et
sauts de
Je n'ai eu que 261. Qu'est-ce qui me manque?
Razvan Socol
2

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 .

Titus
la source
2

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!

primo
la source
Compter sur ce site a changé, vous n'avez plus besoin de compter -p(je pense que c'est trop clément pour perl, mais c'est comme ça maintenant)
Ton Hospel
2

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!

primo
la source
1
Vous pouvez sauvegarder un octet: $s.$s.$sau lieu de $s.=$s.$s. Et vous n’avez pas besoin de <?au -Rlieu de -F.
Titus
Merci pour l'octet. En ce qui concerne -R, pouvez-vous me montrer l'utilisation complète?
primo
Tout comme -nF: echo <input> | php -nR '<code>'. -rest presque le même: php -nr '<code>' <arguments>.
Titus
Peut-être que je suis trop stupide pour que ça marche: / i.stack.imgur.com/jqpmk.png
primo
1
preg_filterconsiste à itérer chaque ligne tout en préservant les nouvelles lignes, à peu près équivalentes à join("\n",array_map(function(){...},split("\n",$s.$s.$s))), mais nettement moins verbeuses. J'avais initialement str_padmais changé pour sprintfparce que c'est un octet plus court:'"\0".str_pad($$i++/$i&1?"\0":"",$i)."\0"'
primo
1

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

Chiel ten Brinke
la source
1

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.

Barboteur
la source
0

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;
}
Tsathoggua
la source