La pirámide de IHIH

34

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 , no se permiten lagunas estándar. ¡y la respuesta más corta en bytes gana!

DJMcMayhem
fuente
¿Es aceptable si devuelvo una flecha de cadenas un fror cada fila?
Rohan Jhunjhunwala
No cumplió con los criterios de desafío, pero hizo algo genial por accidente ... ¡ Pruébelo en línea!
Urna mágica del pulpo

Respuestas:

7

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
Monja permeable
fuente
Me encanta la idea de la transponcion.
Tito
12

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.

Simon
fuente
2
Buena respuesta, y bienvenido al sitio! No necesita unir las líneas, una lista de cadenas está bien. Un par de consejos: cambie las líneas 2 y 3 a if e<1:return'|'(sin nueva línea entre ellas), luego elimine el "else" y elimine la sangría adicional.
DJMcMayhem
1
Puedes sacar el espacio después return. Además, puede fusionar las líneas sin ifs con punto y coma, y ​​guardar en la sangría
Maltysen
1
He editado tu respuesta. Siéntete libre de revertir mis ediciones si no te gustan.
Leaky Nun
10

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.

Downgoat
fuente
8

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)
Lynn
fuente
Forma cerrada: o: o
Leaky Nun
Ahh, por supuesto: al principio lo necesitaba int(x/2.)porque estaba tomando range(-n,n+1)pero ahora solo puedo usarlos. ¡Gracias!
Lynn
Especifiqué Python 2 en el encabezado porque simplemente decir "Python" generalmente significa que el código funciona en Python 2 o Python 3, que no es el caso aquí.
Mego
7

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
Azul
fuente
1
Wow, iterativo! Estoy impresionado.
Conor O'Brien
@ ConorO'Brien Matricks se creó para cambiar el tamaño de la matriz dinámica, por lo que no es TAN impresionante, ¡pero gracias de todos modos!
Azul
5

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.

Neil
fuente
4

Dyalog APL , 52 43 bytes

{v=⊃⍵:h⍪⍨hs,⍵,sv,⍨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!

Adán
fuente
3

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.

Lynn
fuente
3

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

Gil
fuente
Bienvenido a PPCG!
Stephen
¡Gracias! Intentando unirme a la fiesta ahora, es muy divertido resolverlos :)
Gil
2

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!

Monja permeable
fuente
2

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

Lynn
fuente
Puede convertirlo v->abs ven (abs)(por ejemplo r.map((abs))) que devolverá una función que tiene el comportamiento de la función abs. por ejemplo (+)(1,2)-> 3. (^)(2,6)-> 64. También gran sorpresa en superarme en casi un 50%
Downgoat
No, lo intenté: Runtime Error: `abs` has no behavior for types `Number` and `Number` (porque maprecibe tanto el elemento como su índice, presumiblemente).
Lynn
ah: / Estaba a punto de arreglar ese error hoy> _>
Downgoat
2

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

ngn
fuente
1

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
Sherlock9
fuente
Puedes .map(&:abs)?
Lynn
@ Lynn Bien visto. ¿Cualquier otra sugerencia?
Sherlock9
El primero *no está haciendo nada. Puedes usar en *""lugar de .join. Además, el uso prodea cada línea con comillas (recurre inspecta sus argumentos), lo que podría descalificarlo.
Jordan
Además, puede eliminar los paréntesis alrededor &:abs( map &:abs). Es posible que pueda hacer algo en Array#productlugar de maps anidados , pero hará que los saltos de línea sean difíciles.
Jordan
@Jordan Sus primeros cuatro consejos funcionan, pero r.product(r).map(sin embargo, eso funciona) es más largo y no parece permitir saltos de línea muy fácilmente.
Sherlock9
1

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
Wauzl
fuente
Puede reemplazar ' 'por 0(Matlab trata char 0 como un espacio) y '-' por 45. Nombre de archivo no tiene que ser incluido en el recuento de bytes
Luis Mendo
1

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.
Sherlock9
fuente
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£Mes más largo de lo que tiene actualmente (en 2 bytes), pero es posible que encuentre alguna inspiración para hacerlo más corto que no veo.
Mego
1

Lienzo , 19 18 17 14 bytes

|╶[ e↷l|*e}╶[↷

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°
dzaima
fuente
Perdería 6 bytes si aflojan esa restricción también: P.
Urna de pulpo mágico
@MagicOctopusUrn wellp, haz eso -5 bytes para mí: p (¿tu respuesta podría beneficiarse también de un bucle de transposición?)
dzaima
mi implementación es un bucle de transposición: D.
Magic Octopus Urn
1

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.
Urna de pulpo mágico
fuente
0

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}]
Greg Martin
fuente
@ Adám ¡Gracias por el puntero a ese hilo!
Greg Martin
0

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;
}
Titus
fuente
0

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!

Xcali
fuente
0

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 ) ' '
ბიმო
fuente
0

J , 37 bytes

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

TIO

jayprich
fuente
0

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

recursivo
fuente