Votre tâche: étant donné un entier n, générez un motif hexagonal incorporé en suivant les règles ci-dessous, jusqu'à la nième profondeur.

Un hexagone intégré a la forme de base de ceci: ( n=0)

 __      
/  \
\__/

Hexagones intégrés n=1et n=2:

  ____    
 /  \ \
/\__/  \
\      /
 \____/

    ________    
   /  \ \   \
  /\__/  \   \
 /\      /    \
/  \____/      \
\              /
 \            /
  \          /
   \________/

La longueur de chaque côté est 2 fois la longueur du même côté dans la profondeur précédente multipliée par deux. Les côtés supérieur et inférieur sont de 2 caractères lorsque n=0et le reste commence par 1 caractère. Les longueurs des côtés non supérieur-inférieur doivent être 2^nlongues ( OEIS: A000079 ) et les côtés supérieur et inférieur doivent suivre la règle 2^(n+1)(même OEIS).

Les hexagones actuels sont indexés 0, vous pouvez choisir d'utiliser un index 1 si vous le souhaitez.

Il s'agit de code-golf , donc la réponse la plus courte l'emporte!

Fusain , 40 29 octets

11 octets économisés grâce à @Neil en changeant la boucle while en une boucle for parmi d'autres astuces

ＦＮ«ＡＸ²ιβ×__β↓↘β←↙β↑←×__β↖β→↗β

Essayez-le en ligne!

Explication (obsolète)

Ce programme commence par générer le plus grand hexagone, puis fait les plus petits un par un dans une boucle while (indexé 1). Pour référence,α est le numéro d'entrée, βest la variable qui contient 2^(α-1)et ιest la variable d'itération dans la boucle.

Ｎα                        # Take input and store in α
Ｗα«                       # While α do:
 ×_Ｘ²ι                    #  Write "_"*(2**ι); this forms the top edge of the hexagon
 ↓                         #  Go down
 ＡＸ²⁻ι¹β                 #  Assign 2**(ι-1) to β
 ↘β←                       #  Write \ β times in a SE direction (top right edge) and then go left
 ↙β↑                       #  Write / β times in a SW direction (bottom right edge) and then go up
 ←×_Ｘ²ι                   #  Write the bottom edge
 ↖β→↗β                    #  Just like before, write the top and bottom left edges
 Ａ⁻α¹α                    #  Decrement α
                          # Now the pointer is at the top left corner of the hexagon,
                          # from where the other smaller hexagons will soon be generated

Haskell , 230 217 207 octets

ÉDITER:

• -13 octets: @xnor a vu que mon #pouvait être juste max.
• -10 octets: Et aussi cela zipWithet ppourrait être fusionné en un ?opérateur, et que j'avais (en quelque sorte!) Réimplémenté replicate.

mprend un Integeret retourne un String.

m n=unlines.foldr1 o$((2^n)&).(2^)<$>[0..n]
l&t|a<-c[l,2*t]" _",b<-[c[l-i,1,2*t+2*i-2,1,l-i]" / \\ "|i<-[1..t]]=a:b++r(r<$>o[a]b)
c=(concat.).z replicate
o=max?' '?""
f?e=z f.(++repeat e)
r=reverse
z=zipWith

Essayez-le en ligne!

Comment ça fonctionne

• mest la fonction principale. Il utilise &pour générer les hexagones avec un rembourrage approprié, puis les plie avec o.
• l&tgénère un petit hexagone de longueur latérale t, rembourré à l'intérieur d'un grand de longueur latérale l, sous forme de liste de Stringlignes.
  • a est la ligne supérieure de l'hexagone, avec les traits de soulignement.
  • best une liste des autres lignes dans la moitié supérieure de l'hexagone. Les lignes de bsont centrées dans le rembourrage, qui est rectangulaire; cela permet à la prochaine étape de fonctionner.
  • La moitié inférieure de l'hexagone est asuperposé au - dessus de bà o, alors inversée ( à la fois l' ordre de lignes et dans chaque ligne).
• cprend deux arguments, une liste de longueurs et une chaîne, et génère une chaîne qui a autant de copies de chaque caractère dans l'original que la longueur correspondante, par exemple c[1,3,2]"abc" == "abbbcc". Il est utilisé &pour générer les lignes.
• o prend deux arguments représentant des images sous forme de listes de lignes et superpose le premier, le plus petit au-dessus du second.
  • Il est utilisé à la fois pour combiner des hexagones et pour ajouter le fond à chaque hexagone.
  • Il fonctionne essentiellement en utilisant ?deux fois pour remplir la première image avec une infinité d'espaces vers le bas et vers la droite, puis en zippant les caractères correspondants avec max, qui sélectionne le caractère non-espace s'il y en a un.
• (f?e)l mremplit une liste len ajoutant une infinité d'éléments «e», puis zippe la liste résultante et la liste mavec la ffonction.

JavaScript (ES6), 258 octets

f=(n,s=` `.repeat(1<<n),p=(n?f(n-1):`


`).replace(/(.*)\n/g,s+`$1 `+s)+s,t=`_`.repeat(2<<n))=>(s+t+s+`
`+s.replace(/ /g,"$'/$'$'  $`$`$`$`\\$'\n")).replace(/ /g,(c,i)=>p[i+(1<<n>>1)])+s.replace(/ /g,"$`\\$`$`  $'$'$'$'/$`\n").replace(/ +\/( *)\n$/,t+`/$1
`)

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Explication: Pour les hexagones après le premier, l'hexagone précédent est d'abord généré et complété de chaque côté (cela dépend de la sortie qui est un rectangle). (Pour le premier titre, un remplissage factice est créé.) Les côtés supérieur et supérieur de l'hexagone sont générés et tous les espaces fusionnés avec l'hexagone précédent. (Il y a une astuce pour aligner les hexagones; ce serait plus facile si des marges supplémentaires étaient autorisées.) Les côtés inférieurs de l'hexagone sont générés de manière analogue aux côtés supérieurs, et le bas de l'hexagone est ensuite rempli. Il faut prendre soin de renvoyer une sortie rectangulaire, y compris une nouvelle ligne de fin, pour que la récursivité fonctionne.

PHP, 337 octets

0 Indexation

$h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v));for(;1+$c;$c--)for($i=0;$i<$e=2**$c*2+1;$i++){$z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1;$h[$i]=substr_replace($h[$i],$s=str_pad(!$y?$z|$x?"\\":"":"/",$e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),$z|!$i?"_":" ").(!$y?$z|$x?"/":"":"\\"),$v-$z-$y*$i-$x*($e-$i),strlen($s));}echo join("\n",$h);

Essayez-le en ligne!

Étendu

$h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v)); # fill array with maximal width
for(;1+$c;$c--)  # greatest hexagon to lowest
for($i=0;$i<$e=2**$c*2+1;$i++){ # loop through the rows
    $z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1; # booleans last first ad second half
    $h[$i]=substr_replace($h[$i], # replace substring
    $s=str_pad(
        $z?"\\":($y?"/":($x?"\\":"")),
        $e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),
        $z|!$i?"_":" "
        ).(!$z?!$y?$x?"/":"":"\\":"/"), # with string for smaller hexagon
    $v-$z-$y*$i-$x*($e-$i), # at offset
    strlen($s));
}
echo join("\n",$h); # Output