Je trouve cela fascinant de voir à quel point les lettres "H" et "I" sont très similaires. "H" est un trait horizontal entouré de deux traits verticaux; "I" est un trait vertical entouré de deux traits horizontaux (selon votre police). Je parie que cela pourrait être imbriqué ... Vous savez ce que cela me rappelle? Fractales !!!

Définissons la pyramide "IHIH" comme suit: La première itération est cette représentation ASCII de la lettre "I":

---
 |
---

La prochaine itération a un trait vertical de chaque côté.

|   |
|---|
| | |
|---|
|   |

Si vous considérez le "I" au milieu comme un trait horizontal unique, cette seconde itération est fondamentalement un "H". La troisième itération ajoute un trait horizontal en haut et en bas

-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

Encore une fois, si vous considérez le "H" au milieu comme un trait vertical unique, cette itération est fondamentalement un "I". Ce motif continue, alternant entre "H" et "I" à chaque itération. Pour référence, voici les 6 premières itérations:

1:
---
 |
---

2:
|   |
|---|
| | |
|---|
|   |

3:
-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

4:
|       |
|-------|
| |   | |
| |---| |
| | | | |
| |---| |
| |   | |
|-------|
|       |

5:
-----------
 |       |
 |-------|
 | |   | |
 | |---| |
 | | | | |
 | |---| |
 | |   | |
 |-------|
 |       |
-----------

6:
|           |
|-----------|
| |       | |
| |-------| |
| | |   | | |
| | |---| | |
| | | | | | |
| | |---| | |
| | |   | | |
| |-------| |
| |       | |
|-----------|
|           |

Le défi:

Ecrivez un programme ou une fonction générant la nième itération de la pyramide IHIH et une nouvelle ligne de fin optionnelle. Votre entrée sera un entier positif unique, quel que soit le format raisonnable que vous souhaitez. Vous n'avez pas besoin de gérer des entrées non valides, par exemple des nombres non entiers, des nombres inférieurs à 1, etc. Votre programme doit au moins produire la sortie correcte pour les entrées allant jusqu'à 20. S'agissant de code-golf , les échappements standard ne sont pas autorisés. et la réponse la plus courte en octets gagne!

Pyth , 50 40 31 25 octets

j @ su, J + * \ - K + 2lheN + jR * 2; eN * \ - KjR "||" + * dK + J * dKQ]] \ | 
LXR "| -") CbjyW% Q2uy + K * \ - + 2lhG + jR * 2; GKQ] \ | 
juCGQuC + K * @ "- |" H + 3yH + jR * 2; GKQ \ |
j @ CBujR * @ "- |" H2CjR * 2; GQ \ |

Suite de tests.

Explication

Ceci est un algorithme récursif.

A chaque itération, nous effectuons trois actions:

1. ajouter et ajouter un espace à chaque ligne
2. transposer le tableau
3. prepend et ajout à chaque ligne soit "-"ou en "|"fonction du nombre d'itérations.

Après les itérations, les sorties impaires seront transposées. Par conséquent, nous les transposons.

j@CBujR*@"-|"H2CjR*2;GQ\|   input: Q
j@CBujR*@"-|"H2CjR*2;GQ\|Q  implicit filling of arguments


    u                 Q\|   for Q times, starting with "|", G as current output,
                            H as number of iterations:

                jR*2;G          prepend and append a space to each line
                                (using each line as separator, join [" "," "])
               C                transpose
     jR*      2                 prepend and append the following to each line:
        @"-|"H                      the H-th element of the string "-|" (modular indexing)

 @CB                     Q  select the Q-th element from [output,
                            transposed output] (modular indexing)
j                           join by newlines

Python, 165 145 133 123 octets

Une solution récursive:

def i(e):
 d="|";a=e*2;x=d+" "*(a-1)+d
 if e<1:return d
 if e%2:d,x=[" ","-"*(a+1)]
 return[x]+[d+z+d for z in i(e-1)]+[x]

Appelé avec print ("\n".join(i(int(sys.argv[1])))), où le paramètre est le numéro d'itération de la pyramide IHIH.

Merci à @DJMcMayhem pour la sauvegarde de 20 octets. En prenant l’idée derrière ces suggestions, nous avons encore économisé 12 octets supplémentaires. Merci à @Maltysen pour les suggestions qui ont coupé quelques octets supplémentaires.

La fonction définit le délimiteur dsur "|"et les espaces intermédiaires sur " "(pour les itérations impaires), traite le retour dans le cas dégénéré, puis réinitialise le délimiteur " "et les espaces intermédiaires sur "-"des itérations paires. La fonction renvoie une liste de chaînes pour chaque ligne de l'IHIH, après avoir incorporé le résultat d'un appel récursif à la fonction au bon endroit dans la liste.

Cheddar , 186 177 165 154 148 131 octets

(n,b?,c?,q?,g=s->(n-=1)<0?s:g((q=(c=s.lines[0].len)%4>2?b='|'+" "*c+"|":b='-'*(c+2))+"\n"+s.sub(/^|$/gm,q?'|':' ')+"\n"+b))->g("|")

Utilise la récursivité. Ajoutera une explication une fois le golf terminé.

Essayez-le en ligne!

Explication

Celui-ci est un peu complexe aussi, gardez une trace de toutes les variables que j'utilise mais je vais essayer de rester simple:

(
 n,    // Input
 b?,   // Stores row to add to top/bottom
 c?,   // Width of string 
 q?,   // false if I-ifying. true if not
 g=
   s->          // Main logic, s is generated string
    (n-=1)<0 ? s :   // Decrease input each iteration. Stop when 0
    g(               // Recurse with....
      (
        q= (         // Set `q` true if h-ifying. false if I-ifying
         c=s.lines[0].len    // Set `c` to width of string
        ) % 4>2 ?
        b='|'+" "*c+"|" :    // Set `b` to top/bottom row adding
        b='-'*(c+2)          // `*` is repeat, c is from before
      ) + "\n" + 
        s.sub(/^|$/gm,       // Add the following to beginning/end of each line
          q?'|':' '          // if H-ifying, add `|`s if I-ifying add spaces
        ) + "\n" + b         // Add bottom row, generated from before
    )
) -> g("|")     // Middle item is `|`

C’était pénible pour le golf mais ses 55 octets sont plus courts que l’original.

Python 2, 93 octets

Fuite Nun sauvé 7 octets.

r=range(input()+1)
r=r[:0:-1]+r
for y in r:print''.join('| -'[[x%2,y%2+1][x&-2<y]]for x in r)

Matricks , 80 62 octets

Une solution itérative (La récursion dans Matricks est difficile ...)

Courir avec python matricks.py ihih.txt [[]] <input> --asciiprint

k124; FiQ% 2: v; b [m124: Q * 2 + 3: 1;]; a {z: Q * 2 + 1;} ;: b; v [m45: 1: Q * 2 + 3;] ; u {zQ * 2 + 1:;} ;;: 1: n ;;
k124; FiQ% 2: v; b [m124: Q * 2 + 3: 2;]; B1;: b; v [m45: 2: Q * 2 + 3;]; V1 ;;: 1: n ;;

Explication:

k124;                 # Set the matrix to '|'
F...:1:n;;            # Repeat input times, (Q is iteration variable)
  iQ%2:...:...;       # if statement, check if Q is odd or even
                      # Q is even,
    b;                # Make space to the left
    v[m45:2:Q*2+3;];  # Set the top 2 rows to '-'s
    V1;               # Rotate the matrix up 1 unit, moving the topmost row to the bottom
                      # Q is odd,
    v;                # Make space above
    b[m124:Q*2+3:2;]; # Set the 2 left columns to '|'s
    B1;               # Rotate the matrix left 1 unit, moving the leftmost row to the right

JavaScript (ES6), 92 90 octets

f=
(n,[h,c,v]=n&1?`-- `:` ||`)=>n?(c+=h.repeat(n+n-1)+c)+`
${f(n-1).replace(/^|$/gm,v)}
`+c:v
;

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

La solution récursive fonctionne en prenant l'itération précédente, en ajoutant le vcaractère sur les côtés, puis en ajoutant le ccaractère dans les coins et le hcaractère en haut et en bas. L'ensemble de caractères alterne simplement à chaque itération. Edit: 2 octets enregistrés en retournant vquand n=0.

Dyalog APL , 52 43 octets

{v=⊃⍵:h⍪⍨h⍪s,⍵,s⋄v,⍨v,s⍪⍵⍪s}⍣⎕⍪⊃v h s←'|- '

v h s←'|- 'attribue les trois personnages à trois noms ( v ertical, h orizontal, s rythme)

⊃ le premier, à savoir |

⍪ faire en 1 × 1 table

{... }⍣⎕avoir son mot à dire et appliquer la fonction doublée plusieurs fois

 v=⊃⍵: si le caractère en haut à gauche de l'argument est une verticale, alors:

  h⍪⍨ horizontales ci-dessous

  h⍪ horizontales ci-dessus

  s, espaces à gauche de

  ⍵,s l'argument avec des espaces à droite

 ⋄ autre:

  v,⍨ verticales à droite de

  v, verticales à gauche de

  s⍪ espaces ci-dessus

  ⍵⍪s l'argument avec des espaces ci-dessous

TryAPL en ligne!

Brachylog , 84 octets

,[[["|"]]:?:1]i:1:zi:ca~@nw
hh~m["-|":B]:ramggL," "ggS,?:Sz:ca:Srz:caz:Lz:ca:Lrz:ca.

Essayez-le en ligne!

Un portage de ma réponse en Pyth .

C, 110 octets

#define R(A,B,C)for(A=n,B=1;A<=n;putchar(C),A-=B|=-!A)
f(n,y,x,w,v){R(y,w,10)R(x,v,"| -"[x/2*2<y?y%2+1:x%2]);}

Invoquer comme f(n). Pour 111 octets, je pourrais faire:

f(n,y,x,w,v){for(y=n,w=1;y<=n;y-=w|=-!y,puts(""))for(x=n,v=1;x<=n;x-=v|=-!x)putchar("| -"[x/2*2<y?y%2+1:x%2]);}

c'est-à-dire que l' #defineenregistre exactement un octet.

Dyalog APL, 34 octets

{⍉⍣⍵{b,b,⍨⍉s,⍵,⊃s b←' -|'~⊃⍵}⍣⍵⍪'|'}

{... }⍣⍵⍪'|'Appliquer la fonction entre accolades à ⍵partir de la matrice de caractère 1x1| . Le résultat de chaque application est l'argument de la prochaine application.

s b←' -|'~⊃⍵s est l'espace et b est la barre pas dans le coin supérieur gauche de l'argument ( ' -|'~'-'supprime la barre horizontale et laisse l'espace et la barre verticale)

s,⍵,⊃s bajouter un espace à gauche et à droite ( ⊃sélections s du vecteur sb)

b,b,⍨⍉ transposer et ajouter b à gauche et à droite

Pour les nombres impairs, le résultat est transposé, une transposition finale est donc requise.

⍉⍣⍵Transposez ⍵fois (une fois suffirait, mais plus court pour coder de cette façon)

TryAPL en ligne

Cheddar , 107 octets

(n,g=n->n?(f->f(f(g(n-1)," ").turn(1),n%2?"-":"|"))((a,b)->a.map(i->b+i+b)):["|"])->(n%2?g(n).turn(1):g(n))

Essayez-le en ligne!

Cheddar, 85 octets

(n,r=(-n|>n).map(v->abs v))->r.map(y->r.map(x->"| -"[(x&-2)<y?y%2+1:x%2]).fuse).vfuse

Ma première réponse au cheddar. Essayez-le en ligne!

Si j'essaie d'écrire r=(-n|>n).map(v->abs v).map, et alors r(y->r(x->…)), l'interprète se bloque. ; -;

APL (Dyalog Classic) , 34 octets

'- |'[2+∘.(≤-(1+=)×2|⌈)⍨(⌽,0,⊢)⍳⎕]

Essayez-le en ligne!

(les usages ⎕io←1 )

⍳⎕ est 1 2 ... N

(⌽,0,⊢) est un train qui le transforme en -N ... -1 0 1 ... N

∘.( )⍨ exécute les parenthèses pour chaque paire de coordonnées ⍺ ⍵

le train (≤-(1+=)×2|⌈)ou son équivalent en dfn {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}produit une matrice du type:

 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
  0  1  0  0  0  0  0  0  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  1  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  0  0  0  0  0  0  1  0
 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

'- |'[2+ ]rend ces index valides ⎕IO=1et choisit les caractères correspondants

Ruby, 81 78 77 octets

Ceci est basé sur la réponse de Lynn en Python . Les suggestions de golf sont les bienvenues.

Edit: 3 octets grâce à Lynn. Corrections et golf 1 octet grâce à Jordan.

->n{r=(-n..n).map &:abs;r.map{|y|puts r.map{|x|"| -"[x&-2<y ?y%2+1:x%2]}*""}}

Ungolfing:

def f(n)
  r = -n..n            # Range from -n to n (inclusive)
  r = r.map{|i|i.abs}  # Turns every element of r positive
  r.each do |y|
    s = ""             # a line of the fractal
    r.each do |x|      # build up the fractal based on x and y
      if x/2*2 < y
        s += " -"[y%2]
      else
        s += "| "[x%2]
      end
    end
    puts s             # print the line
  end
end

MATLAB, 168 163 octets

Ce n'est probablement pas la façon la plus intelligente de le faire: Développer une chaîne de tous les côtés par nétapes:

function s=g(n);s='|';for m=1:n;if mod(m,2);a=45;b=a;c=0;else a='|';b=0;c=a;end;s=[a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];s(:,end+1)=s(:,1);s(end+1,:)=s(1,:);end

Utilisation: Enregistrer sous g.m(dois-je l’ajouter au nombre d’octets?) Et appeler par exempleg(15) .

Ungolfed:

function s=g(n)

% // Initialize s
s = '|';

for m=1:n
   % // Decide if odd or even number and which symbol to add where
   if mod(m,2)
      a=45;b=a;c=0; % // char(45) is '-' and char(0) is ' ' (thx to Luis Mendo)
   else
      a='|';b=0;c=a;
   end
      % // Add symbols at top and left to s
      s = [a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];
      % // Add symbols at right and bottom to s
      s(:,end+1) = s(:,1);
      s(end+1,:) = s(1,:);
end

En fait , 48 45 44 octets

Ceci est une tentative de porter ma réponse Ruby à En fait. C'est trop long et les suggestions de golf sont très appréciées.Essayez-le en ligne!

u;±ux♂A╗╜`╝╜";2@%2╛%u╛(2±&<I'-' '|++E"£MΣ.`M

Voici une version de 46 octets qui sépare les fonctions imbriquées afin que nous puissions définir "| -" moins d’octets. Essayez-le en ligne!

u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£MΣ."%£M

Ungolfing:

Premier algorithme

u         Increment implicit input.
;±u       Duplicate, negate, increment. Stack: [-n n+1]
x♂A       Range [-n, n+1). Abs(x) over the range.
╗         Save list to register 0. Let's call it res.
╜         Push res so we can iterate over it.
  `         Start function (with y from map() at the end)
  ╝         Save y to register 1.
  ╜         Push res so we can iterate over it.
    "         Start function as string (with x from map() at the end)
    ;         Duplicate x.
    2@%       x mod 2.
    2╛%u      y mod 2 + 1.
    ╛(2±&<I   If x&-2 < y, then y%2+1, else x%2.
    '-' '|++  Push "| -" (We're inside a string right now,
                          so we need to push each char individually)
    E         Grab index of "| -"
    "£        End string and turn into function.
  M         Map over res.
  Σ.        sum() (into a string) and print.
  `         End function.
M         Map over res.

Deuxième algorithme

u;±ux♂A╗╜                  Create res as before.
`;2@%2╛%u╛(2±&<I"| -"E`#   The inner function from the first algorithm put into a list.
                             The only change to the function is the definition of "| -".
"╝╜  £MΣ."                 Most of the outer function from the first algorithm as a string.
   %r      %               %-formats the list into the outer function.
            £M             Turns the string into a function, maps over res.

Toile , 19 18 17 14 octets

|╶［ ｅ↷ｌ|＊ｅ｝╶［↷

Essayez-le ici!

Si je pouvais sortir toutes les deux sorties tournées de 90 °, les 4 derniers caractères pourraient être supprimés.

Explication (certains caractères ont été modifiés pour ressembler à ~ monospace):

|               push "|" - the canvas
 ╶[       }     repeat input times
    e             encase the canvas in spaces horizontally
     ↷            rotate the canvas 90°
      l|*         push "-" repeated the canvas height times vertically
         e        and encase the canvas if two of those horizontally
           ╶[   repeat input times
             ↷    rotate the canvas 90°

05AB1E , 29 28 octets

„|-S¹>∍ƶćsvy‚˜.Bζ}¹Fζ}»R.∞.∊

Essayez-le en ligne!

-1 grâce à Dzaima ...

C'est une solution itérative.

Ceci est essentiellement réalisé en créant le motif suivant:

['|','--','|||',...]

Ensuite, par paire, transposez chaque élément ensemble et ajoutez le rembourrage.

En transposant après chaque itération, on crée un seul coin du motif.

Ensuite, nous pouvons utiliser les commandes de réflexion de 05AB1E.

„|-S                         # Push ['|','-']
    ¹>∍                      # Extended to input length.
       ƶ                     # Each element multiplied by its index.
        ćs                   # Extract head of list, swap remainder to top.
          v      }           # For each element in the '|-' list...
           y‚˜               # Wrap current 2D array with new entry, flatten.
              .Bζ            # Pad and transpose, leaving it transposed for the next addition.
                 }           # End loop.
                  ¹Fζ}       # Transpose N times.
                      »R     # Bring it all together into a newline string, reverse.
                        .∞.∊ # Mirror horizontally, then vertically with overlap.

Mathematica, 158 164 octets

f[n_]:=Print/@StringJoin/@Map[{{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}}[[##]]&@@#&,Table[{1+i~Mod~2, 1+j~Mod~2, 2+Sign[Abs[i]-Abs[j]]}, {i,-n,n}, {j,-n,n}],{2}]

Calcule mathématiquement le symbole correct aux coordonnées (i, j), où les deux vont de -n à n. Humain formaté:

f[n_]:=Print/@
 StringJoin/@
  Map[
   {{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}[[##]]&@@#&,
   Table[{1+i~Mod~2,1+j~Mod~2,2+Sign[Abs[i]-Abs[j]]},{i,-n,n},{j,-n,n}],
   {2}]

PHP, 166 octets

J'ai joué au golf à plus de 100 octets de ma première approche et c'est toujours la réponse la plus longue ici.

function i($n){for($m=['|'];$k++<$n;){array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));foreach($m as$i=>&$r)$r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;}return$m;}

panne

function h($n)
{
    for($m=['|'];$k++<$n;)
    {
        array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));
        foreach($m as$i=>&$r)
            $r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;
    }
    return$m;
}

non-golfé

function ihih($n)
{
    $m=['|'];                   // iteration 0
    for($k=1;$k<=$n;$k++)       // loop $k from 1 to $n
    {
        $f=$k&1;                        // flag for odd iterations
        // add lines:
        $r=str_repeat(' -'[$f],2*$k-1); // new line: ' ' for even, '-' for odd iterations
        $m[]=$r;                                // append
        array_unshift($m,$r);                   // prepend
        // add columns:
        foreach($m as$i=>&$r)           // for each line
        {
            $c='| '[$f];                        // '|' for even, ' ' for odd iterations
            if($f && (!$i || $i==2*$k)) $c='-'; // '-' in corners for odd iterations
            $r=$c.$r.$c;                        // prepend and append character
        }
    }
    return $m;
}

Perl 5 , 150 octets

sub h{my$i=pop;my$c=$i%2?$":'|';return(map{"$c$_$c"}h($i-1)),$i%2?'-'x($i*2+1):$c.$"x($i*2-1).$c if$i;()}say for reverse(@q=h<>),$q[0]=~s/---/ | /r,@q

Essayez-le en ligne!

Haskell , 110 octets

f 0=["|"]
f n|odd n=g ' '!n$'-'|1>0=g '|'$id!n$' '
g c=map$(c:).(++[c])
(g!n)c|p<-g.f$n-1=(:p)<>pure$c<$head p

Essayez-le en ligne!

Explication / Ungolfed

La fonction d'assistance gprend un caractère et une liste de chaînes, puis elle ajoute et ajoute ce caractère à chaque chaîne:

g c = map (\s-> [c] ++ s ++ [c])

Suivant l'opérateur (!)prend une fonction ( g), un nombre ( n) et un caractère ( c). Il calcule ensuite la sortie pour n-1, lui applique la fonction get ajoute une chaîne de même largeur composée de cs au début et à la fin:

(g ! n) c | prev <- g $ f (n-1), ln <- [c | _ <- head p]
          = [ln] ++ prev ++ [ln]

Avec ceux-ci, nous sommes prêts à générer les sorties de manière récursive. Nous devons d'abord couvrir le cas de base:

f 0 = ["|"]

Et puis la récursion:

-- for odd n: the previous output needs a space at the end and beginning and then a string of '-' characters at the top and bottom
f n | odd n     = (g ' ' ! n) '-'
-- for even n: the previous output needs a line of spaces at the top and bottom and then each line needs to be enclosed with '|' characters
    | otherwise = g '|' $ (id ! n ) ' '

J , 37 octets

f=:{&' |-'@*@(-:@=+<-2&|@>.)"{~@:|@i:

TIO

Stax , 22 octets

âeò↕\┐▄┤╚╬8φ8Δ☺Pä≤δ₧߃

Exécuter et déboguer

Déballé, non golfé et commenté, cela ressemble à ceci.

'|          string literal "|"
{           begin block to repeat
  . |G      push " |", then jump to trailing `}` below 
  '-z2lG    push ["-",[]], then jump to trailing `}` below again
}N          repeat block according to number specified in input
m           output each row in grid

}           goto target - `G` from above jumps to here
  i@        modularly index into pair using iteration index
  ~         push to input stack
  {;|Sm     surround each row with the extracted element
  M         transpose grid

Exécuter celui-ci