A pirâmide IHIH


34

Acho fascinante como as letras "H" e "I" são muito semelhantes. "H" é um traço horizontal cercado por dois traços verticais; "I" é um traço vertical cercado por dois traços horizontais (dependendo da fonte). Aposto que isso pode ser aninhado ... Você sabe o que isso me lembra? Fractais !!!

Vamos definir a pirâmide "IHIH" da seguinte forma: A primeira iteração é essa representação ASCII da letra "I":

---
 |
---

A próxima iteração tem um traço vertical em ambos os lados.

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

Se você visualizar o "I" no meio como um único traço horizontal, essa segunda iteração será basicamente um "H". A terceira iteração adiciona um traço horizontal nas partes superior e inferior

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

Novamente, se você visualizar o "H" no meio como um único golpe vertical, essa iteração é basicamente um "I". Esse padrão continua, alternando entre "H" e "I" em todas as iterações. Para referência, aqui estão as 6 primeiras iterações:

1:
---
 |
---

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

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

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

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

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

O desafio:

Escreva um programa ou função que produza a n- ésima iteração da pirâmide IHIH e uma nova linha opcional à direita. Sua entrada será um número inteiro positivo único, em qualquer formato razoável que você desejar. Você não precisa lidar com entradas inválidas, por exemplo, números não inteiros, números menores que 1 etc. Seu programa deve, no mínimo, produzir a saída correta para entradas de até 20. Como esse é um , brechas padrão não são permitidas. e a resposta mais curta em bytes vence!


É aceitável se eu devolver uma flecha de cordas uma ou cada fila?
Rohan Jhunjhunwala

Não cumpriu completamente os critérios do desafio, mas fez algo legal por acidente ... Experimente online!
Magic Octopus Urn

Respostas:


7

Pitão , 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 \ |

Suíte de teste.

Explicação

Este é um algoritmo recursivo.

Em cada iteração, realizamos três ações:

  1. acrescentar e acrescentar um espaço a cada linha
  2. transpor a matriz
  3. Anexar e anexar a cada linha "-"ou "|"dependendo do número de iterações.

Após as iterações, as saídas com números ímpares serão transpostas. Portanto, nós os transpomos.

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

Adoro a ideia de transponder.
Titus

12

Python, 165 145 133 123 bytes

Uma solução 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]

Chamado com print ("\n".join(i(int(sys.argv[1])))), em que o parâmetro é o número de iteração da pirâmide IHIH.

Obrigado a @DJMcMayhem por salvar 20 bytes. Levar a idéia por trás dessas sugestões economizou mais 12 bytes. Obrigado a @Maltysen pelas sugestões que cortaram mais alguns bytes.

A função define o delimitador dcomo "|"e os espaços intermediários como " "(para iterações de números ímpares), lida com o retorno no caso degenerado e, em seguida, redefine o delimitador " "e os espaços intermediários "-"para iterações de número par. A função retorna uma lista de cadeias de caracteres para cada linha do IHIH, incorporando o resultado de uma chamada recursiva à função no lugar certo da lista.


2
Boa resposta e bem-vindo ao site! Você não precisa unir as linhas; uma lista de strings é boa. Algumas dicas: altere as linhas 2 e 3 para if e<1:return'|'(sem nova linha entre elas) e remova o "else" e remova o recuo extra.
DJMcMayhem

1
você pode tirar o espaço depois return. Além disso, você pode mesclar as linhas sem ifs com ponto e vírgula, e economizar no recuo
Maltysen

1
Eu editei sua resposta. Sinta-se à vontade para reverter minhas edições, se você não gostar.
Leaky Nun

10

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

Usa recursão. Adicionará uma explicação depois de terminar o golfe.

Experimente online!

Explicação

Este é um pouco complexo também para acompanhar todas as variáveis ​​que estou usando, mas vou tentar simplificar:

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

Isso foi um problema para o golfe, mas seus 55 bytes são menores que o original.


8

Python 2, 93 bytes

Freira com vazamento economizou 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)

Formulário fechado: o: o
Freira Furada

Ah, claro: no começo eu precisava int(x/2.)porque estava tomando, range(-n,n+1)mas agora posso usá-las. Obrigado!
21416 Lynn

Especifiquei o Python 2 no cabeçalho porque simplesmente dizer "Python" geralmente significa que o código funciona no Python 2 ou no Python 3, o que não é o caso aqui.
Mego

7

Matrizes , 80 62 bytes

Uma solução iterativa (recursão em Matricks é difícil ...)

Correr com 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 ;;

Explicação:

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

1
Uau, iterativo! Estou impressionado.
Conor O'Brien

O @ ConorO'Brien Matricks foi criado para redimensionar a matriz dinâmica, por isso não é tão impressionante, mas, de qualquer forma, obrigado!
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>

A solução recursiva funciona com a iteração anterior, adicionando o vcaractere aos lados e, em seguida, adicionando o ccaractere aos cantos e o hcaractere na parte superior e inferior. O conjunto de caracteres simplesmente alterna cada iteração. Editar: salvou 2 bytes retornando vquando n=0.


4

Dyalog APL , 52 43 bytes

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

v h s←'|- 'Atribui a três caracteres para três nomes ( v ertical, h orizontal, é ritmo)

o primeiro, ou seja |

transformar em 1 × 1 tabela

{... }⍣⎕obtenha informações e aplique a função chave que muitas vezes

v=⊃⍵: se o caractere superior esquerdo do argumento for vertical, então:

  h⍪⍨ horizontais abaixo

  h⍪ horizontais acima

  s, espaços à esquerda de

  ⍵,s o argumento com espaços à direita

outro:

  v,⍨ verticais à direita de

  v, verticais à esquerda de

  s⍪ espaços acima

  ⍵⍪s o argumento com espaços abaixo

TryAPL online!



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, eu poderia fazer:

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

isto é, #definesalva exatamente um byte.


3

Dyalog APL, 34 bytes

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

{... }⍣⍵⍪'|'Aplicar função nos tempos entre chaves , começando com a matriz de caracteres 1x1 |. O resultado de cada aplicativo é o argumento para o próximo aplicativo.

s b←' -|'~⊃⍵s é espaço eb é a barra que não está no canto superior esquerdo do argumento ( ' -|'~'-'remove a barra horizontal e deixa espaço e barra vertical)

s,⍵,⊃s badicione espaço à esquerda e à direita ( seleciona s do vetor sb)

b,b,⍨⍉ transponha e adicione b à esquerda e à direita

Para números ímpares, isso deixa o resultado transposto, portanto é necessária uma transposição final.

⍉⍣⍵Tempos de transposição (uma vez seria suficiente, mas mais curto para codificar dessa maneira)

TryAPL online


Bem-vindo ao PPCG!
Stephen

Obrigado! Tentando juntar à festa agora, muita diversão resolver estes :)
Gil


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

Minha primeira resposta Cheddar. Experimente online!

Se eu tentar escrever r=(-n|>n).map(v->abs v).mape r(y->r(x->…)), em seguida , o intérprete trava. ; -;


Você pode transformar v->abs vem (abs)(por exemplo r.map((abs))) qual retornará uma função que tenha o comportamento da função abs. por exemplo (+)(1,2)-> 3. (^)(2,6)-> 64. Também grande wow em mim outgolfing em quase 50%
Downgoat

Não, eu tentei isso: Runtime Error: `abs` has no behavior for types `Number` and `Number` (porque maprecebe tanto o elemento e seu índice, presumivelmente.)
Lynn

ah: / eu estava prestes a corrigir esse bug hoje> _>
Downgoat 21/08/16

2

APL (Dyalog Classic) , 34 bytes

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

Experimente online!

(usos ⎕io←1)

⍳⎕ é 1 2 ... N

(⌽,0,⊢) é um trem que o transforma em -N ... -1 0 1 ... N

∘.( )⍨ executa os parênteses para cada par de coordenadas ⍺ ⍵

o trem (≤-(1+=)×2|⌈)ou seu equivalente dfn {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}produz uma 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+ ]cria esses índices válidos ⎕IO=1e seleciona os caracteres correspondentes


1

Ruby, 81 78 77 bytes

Isso é baseado na resposta Python de Lynn . Sugestões de golfe são bem-vindas.

Edit: 3 bytes graças a Lynn. Correções e golfe 1 byte graças à Jordânia.

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

Você pode .map(&:abs)?
Lynn

@ Lynn Bem visto. Alguma outra sugestão?
Sherlock9

O primeiro *não está fazendo nada. Você pode usar em *""vez de .join. Além disso, o uso penvolve cada linha entre aspas (que chama inspectseus argumentos), o que pode desqualificá-lo.
Jordan

Além disso, você pode remover os parênteses em torno de &:abs( map &:abs). Você pode fazer algo com s em Array#productvez de maps aninhados , mas isso dificulta as quebras de linha.
Jordânia

@ Jordânia Suas primeiras quatro dicas funcionam, mas r.product(r).map(no entanto, isso funciona) é mais longo e não parece permitir quebras de linha com muita facilidade.
Sherlock9

1

MATLAB, 168 163 bytes

Provavelmente, essa não é a maneira mais inteligente de fazer isso: expandir uma string por todos os lados em netapas:

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: Salvar como g.m(preciso adicionar isso à contagem de bytes?) E chamar, por exemplo g(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

Você pode substituir ' 'por 0(o Matlab trata char 0 como um espaço) e '-' por 45. O nome do arquivo não precisa ser incluído na contagem de bytes
Luis Mendo

1

Na verdade , 48 45 44 bytes

Esta é uma tentativa de portar minha resposta Ruby para Actually. Isso é muito longo e as sugestões de golfe são muito apreciadas. Experimente online!

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

Aqui está uma versão de 46 bytes que separa as funções aninhadas para que possamos definir "| -"em menos bytes. Experimente online!

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

Ungolfing:

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

u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£Mé maior do que o que você possui atualmente (em 2 bytes), mas você pode encontrar alguma inspiração para maneiras de torná-lo mais curto que eu não estou vendo.
Mego

1

Tela , 19 18 17 14 bytes

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

Experimente aqui!

Se eu tivesse permissão para produzir todas as outras saídas giradas em 90 °, os últimos 4 caracteres poderiam ser removidos.

Explicação (alguns caracteres foram alterados para parecer ~ monoespaços):

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

Eu perderia 6 bytes se eles soltassem essa restrição também: P.
Magic Octopus Urn

@MagicOctopusUrn wellp, marca que -5 bytes para mim: p (Poderia seu benefício resposta de um circuito de transposição, bem como?)
dzaima

minha implementação é um loop de transposição: D.
Magic Octopus Urn

1

05AB1E , 29 28 bytes

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

Experimente online!

-1 graças a Dzaima ...

Esta é uma solução iterativa.


Essencialmente Isso é feito criando o seguinte padrão:

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

Em seguida, em pares, transponha cada elemento e adicione o preenchimento.

Ao transpor após cada iteração, acabamos criando um único canto do padrão.

Em seguida, podemos usar os comandos de reflexão do 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.

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 matematicamente o símbolo correto nas coordenadas (i, j), onde ambos correm de -n a n. Formato humano:

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

@ Adám Obrigado pelo ponteiro para esse tópico!
Greg Martin

0

PHP, 166 bytes

joguei mais de 100 bytes na minha primeira abordagem e ainda é a resposta mais longa aqui.

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

demolir

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

destroçado

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

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

Experimente online!


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

Experimente online!

Explicação / Ungolfed

A função auxiliar gpega um caractere e uma lista de seqüências de caracteres e, em seguida, pré e anexa esse caractere a cada sequência:

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

Em seguida, o operador (!)assume uma função ( g), um número ( n) e um caractere ( c). Em seguida, calcula a saída para n-1, aplica a função ga ela e adiciona uma string da mesma largura que consiste em cs no início e no final:

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

Com isso, estamos prontos para gerar os resultados recursivamente, primeiro precisamos cobrir o caso base:

f 0 = ["|"]

E então a recursão:

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


0

Stax , 22 bytes

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.