Encuentro fascinante cómo las letras "H" y "I" son muy similares. "H" es un trazo horizontal rodeado de dos trazos verticales; "I" es un trazo vertical rodeado de dos trazos horizontales (dependiendo de su fuente). Apuesto a que esto podría estar anidado ... ¿Sabes a qué me recuerda? Fractales !!!

Definamos la pirámide "IHIH" de la siguiente manera: la primera iteración es esta representación ASCII de la letra "I":

---
 |
---

La siguiente iteración tiene un trazo vertical a cada lado.

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

Si ve la "I" en el medio como un solo trazo horizontal, entonces esta segunda iteración es básicamente una "H". La tercera iteración agrega un trazo horizontal en la parte superior e inferior

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

Nuevamente, si ve la "H" en el medio como un solo trazo vertical, entonces esta iteración es básicamente una "I". Este patrón continúa, alternando entre "H" e "I" en cada iteración. Como referencia, aquí están las primeras 6 iteraciones:

1:
---
 |
---

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

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

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

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

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

El reto:

Escriba un programa o función que genere la enésima iteración de la pirámide IHIH y una nueva línea final opcional. Su entrada será un solo entero positivo en el formato razonable que desee. No es necesario que maneje entradas no válidas, por ejemplo, números enteros, números menores que 1, etc. Su programa debe, como mínimo, producir la salida correcta para entradas de hasta 20. Como se trata de código de golf , no se permiten lagunas estándar. ¡y la respuesta más corta en bytes gana!

Pyth , 50 40 31 25 bytes

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

Banco de pruebas.

Explicación

Este es un algoritmo recursivo.

En cada iteración, realizamos tres acciones:

1. anteponer y agregar un espacio a cada línea
2. transponer la matriz
3. anteponer y agregar a cada línea, ya sea "-"o "|"dependiendo del número de iteraciones.

Después de las iteraciones, se transpondrán las salidas impares. Por lo tanto, los transponemos.

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 bytes

Una solución recursiva:

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]

Llamado con print ("\n".join(i(int(sys.argv[1])))), donde el parámetro es el número de iteración de la pirámide IHIH.

Gracias a @DJMcMayhem por guardar 20 bytes. Tomar la idea detrás de esas sugerencias ahorró aún más 12 bytes. Gracias a @Maltysen por las sugerencias que recortaron algunos bytes más.

La función establece el delimitador den "|"y los espacios intermedios en " "(para iteraciones con números impares), se ocupa de regresar en el caso degenerado, luego restablece el delimitador en " "y los espacios intermedios "-"para iteraciones con números pares. La función devuelve una lista de cadenas para cada línea de la IHIH, habiendo incrustado el resultado de una llamada recursiva a la función en el lugar correcto dentro de la lista.

Cheddar , 186 177 165 154 148 131 bytes

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

Utiliza la recursividad. Agregará una explicación una vez hecho golf.

Pruébalo en línea!

Explicación

Este es un poco complejo también, mantén un seguimiento de todas las variables que estoy usando, pero intentaré que sea 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 `|`

Esto fue un dolor para el golf, pero es 55 bytes más corto que el original.

Python 2, 93 bytes

Leaky Nun ahorró 7 bytes.

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 bytes

Una solución iterativa (La recursión en Matricks es difícil ...)

Corre con 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 ;;

Explicación:

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 bytes

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 solución recursiva funciona tomando la iteración anterior, agregando el vcarácter a los lados, luego agregando el ccarácter a las esquinas y el hcarácter a lo largo de la parte superior e inferior. El conjunto de caracteres simplemente alterna cada iteración. Editar: guardado 2 bytes al regresar vcuando n=0.

Dyalog APL , 52 43 bytes

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

v h s←'|- 'asigna los tres caracteres a tres nombres ( v ertical, h orizontal, s pace)

⊃ el primero, es decir |

⍪ convertir en tabla 1 × 1

{... }⍣⎕obtenga información y aplique la función de refuerzo muchas veces

 v=⊃⍵: Si el carácter superior izquierdo del argumento es vertical, entonces:

  h⍪⍨ horizontales debajo

  h⍪ horizontales arriba

  s, espacios a la izquierda de

  ⍵,s el argumento con espacios a la derecha

 ⋄ más:

  v,⍨ verticales a la derecha de

  v, verticales a la izquierda de

  s⍪ espacios arriba

  ⍵⍪s el argumento con espacios debajo

TryAPL en línea!

Brachylog , 84 bytes

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

Pruébalo en línea!

Un puerto de mi respuesta en Pyth .

C, 110 bytes

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

Invocar como f(n). Para 111 bytes, podría hacer:

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

es decir, #defineguarda exactamente un byte.

Dyalog APL, 34 bytes

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

{... }⍣⍵⍪'|'Aplicar la función entre paréntesis ⍵comenzando con la matriz de caracteres 1x1 |. El resultado de cada aplicación es el argumento para la siguiente aplicación.

s b←' -|'~⊃⍵s es espacio y b es la barra que no está en la esquina superior izquierda del argumento ( ' -|'~'-'elimina la barra horizontal y deja el espacio y la barra vertical)

s,⍵,⊃s bagregar espacio a izquierda y derecha ( ⊃selecciona s del vector sb)

b,b,⍨⍉ transponer y agregar b a izquierda y derecha

Para números impares, esto deja el resultado transpuesto, por lo que se requiere una transposición final.

⍉⍣⍵⍵Tiempos de transposición (una vez sería suficiente, pero más corto para codificar de esta manera)

TryAPL en línea

Cheddar , 107 bytes

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

Pruébalo en línea!

Cheddar, 85 bytes

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

Mi primera respuesta de Cheddar. Pruébalo en línea!

Si trato de escribir r=(-n|>n).map(v->abs v).map, y luego r(y->r(x->…)), el intérprete falla. ; -;

APL (Dyalog Classic) , 34 bytes

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

Pruébalo en línea!

(usos ⎕io←1)

⍳⎕ es 1 2 ... N

(⌽,0,⊢) es un tren que lo convierte en -N ... -1 0 1 ... N

∘.( )⍨ ejecuta los paréntesis para cada par de coordenadas ⍺ ⍵

el tren (≤-(1+=)×2|⌈)o su equivalente dfn {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}produce una matriz como:

 ¯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+ ]crea estos índices válidos ⎕IO=1y selecciona los caracteres correspondientes

Ruby, 81 78 77 bytes

Esto se basa en la respuesta Python de Lynn . Sugerencias de golf bienvenidas.

Editar: 3 bytes gracias a Lynn. Correcciones y golf 1 byte gracias a Jordan.

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

No golfista:

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 bytes

Probablemente esta no sea la forma más inteligente de hacerlo: expandir una cadena por todos lados en npasos:

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

Uso: Guardar como g.m(¿tengo que agregar eso al conteo de bytes?) Y llamar, por ejemplo g(15).

Sin golf:

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 realidad , 48 45 44 bytes

Este es un intento de transferir mi respuesta de Ruby a En realidad. Esto es demasiado largo y las sugerencias de golf son muy apreciadas. Pruébalo en línea!

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

Aquí hay una versión de 46 bytes que separa las funciones anidadas para que podamos definir "| -"en menos bytes. Pruébalo en línea!

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

No golfista:

Primer algoritmo

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.

Segundo algoritmo

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.

Lienzo , 19 18 17 14 bytes

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

Pruébalo aquí!

Si se me permitiera emitir cualquier otra salida girada 90 °, los últimos 4 caracteres podrían eliminarse.

Explicación (algunos caracteres se han cambiado para parecer ~ monoespacio):

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

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

Pruébalo en línea!

-1 gracias a Dzaima ...

Esta es una solución iterativa.

Básicamente, esto se realiza creando el siguiente patrón:

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

Luego, en parejas, transponiendo cada elemento y agregando el relleno.

Al transponer después de cada iteración, terminamos creando una sola esquina del patrón.

Entonces, podemos usar los comandos de reflexión 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 bytes

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

Calcula matemáticamente el símbolo correcto en las coordenadas (i, j), donde ambas corren de -n a n. Humano formateado:

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 bytes

Golfé más de 100 bytes de mi primer enfoque y sigue siendo la respuesta más larga aquí.

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

Descompostura

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

sin 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 bytes

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

Pruébalo en línea!

Haskell , 110 bytes

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

Pruébalo en línea!

Explicación / Ungolfed

La función de ayuda gtoma un carácter y una lista de cadenas, luego preselecciona y agrega ese carácter a cada cadena:

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

A continuación, el operador (!)toma una función ( g), un número ( n) y un carácter ( c). Luego calcula la salida para n-1, le aplica la función gy agrega una cadena del mismo ancho que consiste en cs al principio y al final:

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

Con estos estamos listos para generar los resultados de forma recursiva, primero tenemos que cubrir el caso base:

f 0 = ["|"]

Y luego la recursividad:

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

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

TIO

Stax , 22 bytes

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este