Trovo affascinante come le lettere "H" e "I" siano molto simili. "H" è un tratto orizzontale circondato da due tratti verticali; "I" è un tratto verticale circondato da due tratti orizzontali (a seconda del tipo di carattere). Scommetto che questo potrebbe essere nidificato ... Sai cosa mi ricorda? Frattali !!!

Definiamo la piramide "IHIH" come segue: La prima iterazione è questa rappresentazione ASCII della lettera "I":

---
 |
---

L'iterazione successiva ha un tratto verticale su entrambi i lati.

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

Se vedi l'io al centro come un singolo tratto orizzontale, questa seconda iterazione è fondamentalmente una "H". La terza iterazione aggiunge un tratto orizzontale in alto e in basso

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

Ancora una volta, se vedi la "H" al centro come un singolo tratto verticale, questa iterazione è fondamentalmente un "io". Questo schema continua, alternando "H" se "I" ad ogni iterazione. Per riferimento, ecco le prime 6 iterazioni:

1:
---
 |
---

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

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

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

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

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

La sfida:

Scrivi un programma o una funzione che genera l' ennesima iterazione della piramide IHIH e una nuova riga finale opzionale. Il tuo input sarà un singolo intero positivo in qualunque formato ragionevole tu voglia. Non è necessario gestire input non validi, ad esempio numeri non interi, numeri inferiori a 1, ecc. Il programma deve almeno produrre l'output corretto per input fino a 20. Dato che si tratta di code-golf , non sono ammesse scappatoie standard e la risposta più breve in byte vince!

Pyth , 50 40 31 25 byte

j @ Do, J + * \ - K + 2lheN + jR * 2; IT * \ - KJR "||" + * dK + J * DKQ]] \ | 
LXR "| -") CbjyW% * \ Q2uy + K - jR * 2 + 2lhG +; GKQ \] | 
"- |" juCGQuC + K * @ H + JR 2 3yH + *; GKQ \ |
"- |" j @ CBujR * @ H2CjR * 2; GQ \ |

Suite di test.

Spiegazione

Questo è un algoritmo ricorsivo.

In ogni iterazione, eseguiamo tre azioni:

1. anteporre e aggiungere uno spazio a ciascuna riga
2. trasporre l'array
3. anteporre e aggiungere a ciascuna riga "-"o in "|"base al numero di iterazioni.

Dopo le iterazioni, le uscite dispari verranno trasposte. Pertanto, li trasponiamo.

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

Una soluzione ricorsiva:

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]

Chiamato con print ("\n".join(i(int(sys.argv[1])))), dove il parametro è il numero di iterazione della piramide IHIH.

Grazie a @DJMcMayhem per aver salvato 20 byte. L'idea alla base di questi suggerimenti ha ulteriormente salvato altri 12 byte. Grazie a @Maltysen per i suggerimenti che hanno ridotto alcuni byte.

La funzione imposta il delimitatore dsu "|"e gli spazi intermedi su " "(per iterazioni con numeri dispari), si occupa di ritornare nel caso degenerato, quindi reimposta il delimitatore su " "e gli spazi intermedi su "-"per iterazioni con numero pari. La funzione restituisce un elenco di stringhe per ogni linea di IHIH, avendo incorporato il risultato di una chiamata ricorsiva alla funzione nel posto giusto all'interno dell'elenco.

Cheddar , 186 177 165 154 148 131 byte

(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 la ricorsione. Aggiungerà spiegazione una volta fatto il golf.

Provalo online!

Spiegazione

Anche questo è un po 'complesso per tenere traccia di tutte le variabili che sto usando, ma proverò a mantenerlo semplice:

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

Questo è stato un dolore per il golf, ma i suoi 55 byte sono più brevi rispetto all'originale.

Python 2, 93 byte

Leaky Nun ha salvato 7 byte.

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)

Matrick , 80 62 byte

Una soluzione iterativa (La ricorsione in Matricks è difficile ...)

Corri con python matricks.py ihih.txt [[]] <input> --asciiprint

K124; FIQ% 2: v; b [M124: Q * 2 + 3: 1;]; un {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 ;;

Spiegazione:

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 byte

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 soluzione ricorsiva funziona prendendo l'iterazione precedente, aggiungendo il vcarattere ai lati, quindi aggiungendo il ccarattere agli angoli e il hcarattere lungo la parte superiore e inferiore. L'insieme di caratteri alterna semplicemente ogni iterazione. Modifica: salvato 2 byte restituendo vquando n=0.

Dyalog APL , 52 43 byte

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

v h s←'|- 'assegna i tre personaggi a tre nomi ( v ertical, h orizzontale, s ritmo)

⊃ il primo, cioè |

⍪ trasforma in 1 × 1 tabella

{... }⍣⎕ottieni input e applica la funzione controvento più volte

 v=⊃⍵: se il carattere in alto a sinistra dell'argomento è verticale, allora:

  h⍪⍨ orizzontali di seguito

  h⍪ orizzontali sopra

  s, spazi a sinistra di

  ⍵,s l'argomento con spazi a destra

 ⋄ altro:

  v,⍨ verticali a destra di

  v, verticali a sinistra di

  s⍪ spazi sopra

  ⍵⍪s l'argomento con gli spazi sottostanti

ProvaAPL online!

Brachylog , 84 byte

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

Provalo online!

Una porta della mia risposta in Pyth .

C, 110 byte

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

Invoke as f(n). Per 111 byte, potrei fare:

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

cioè, #definesalva esattamente un byte.

Dyalog APL, 34 byte

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

{... }⍣⍵⍪'|'Applica la funzione tra parentesi graffe a ⍵partire da 1x1 matrice di caratteri |. Il risultato di ogni applicazione è l'argomento per l'applicazione successiva.

s b←' -|'~⊃⍵s è spazio e b è la barra non nell'angolo in alto a sinistra dell'argomento ( ' -|'~'-'rimuove la barra orizzontale e lascia spazio e barra verticale)

s,⍵,⊃s b aggiungi spazio a sinistra e a destra (⊃ seleziona s dal vettore sb)

b,b,⍨⍉ trasporre e aggiungere b a sinistra e a destra

Per i numeri dispari questo traspone il risultato, quindi è necessaria una trasposizione finale.

⍉⍣⍵ Trasporre ⍵Tempi di (una volta sarebbe sufficiente, ma più breve per codificare in questo modo)

TryAPL online

Cheddar , 107 byte

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

Provalo online!

Cheddar, 85 byte

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

La mia prima risposta Cheddar. Provalo online!

Se provo a scrivere r=(-n|>n).map(v->abs v).map, quindi r(y->r(x->…))l'interprete si arresta in modo anomalo. ; -;

APL (Dyalog Classic) , 34 byte

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

Provalo online!

(usa ⎕io←1)

⍳⎕ è 1 2 ... N

(⌽,0,⊢) è un treno che lo trasforma -N ... -1 0 1 ... N

∘.( )⍨ esegue le parentesi per ogni coppia di coordinate ⍺ ⍵

il treno (≤-(1+=)×2|⌈)o il suo equivalente dfn {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}produce una matrice come:

 ¯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+ ]rende questi indici validi ⎕IO=1e seleziona i caratteri corrispondenti

Rubino, 81 78 77 byte

Questo si basa sulla risposta Python di Lynn . Suggerimenti di golf benvenuti.

Modifica: 3 byte grazie a Lynn. Correzioni e golf 1 byte grazie alla Giordania.

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

Questo probabilmente non è il modo più intelligente per farlo: espandere una stringa su tutti i lati in npassaggi:

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

Utilizzo: Salva con nome g.m(devo aggiungerlo al conteggio byte?) E chiama ad esg(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

In realtà , 48 45 44 byte

Questo è un tentativo di portare la mia risposta di Ruby a In realtà. È troppo lungo e i suggerimenti per il golf sono molto apprezzati. Provalo online!

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

Ecco una versione a 46 byte che separa le funzioni nidificate in modo che possiamo definire "| -"in meno byte. Provalo online!

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

Ungolfing:

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

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

Tela , 19 18 17 14 byte

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

Provalo qui!

Se avessi il permesso di produrre ogni altro output ruotato di 90 °, gli ultimi 4 caratteri potrebbero essere rimossi.

Spiegazione (alcuni personaggi sono stati cambiati per sembrare ~ 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 byte

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

Provalo online!

-1 grazie a Dzaima ...

Questa è una soluzione iterativa.

Essenzialmente Questo viene creato creando il seguente modello:

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

Quindi, a coppie, trasponendo ogni elemento insieme e aggiungendo l'imbottitura.

Trasponendo dopo ogni iterazione, finiamo per creare un singolo angolo del pattern.

Quindi, possiamo usare i comandi di riflessione di 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 byte

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

Calcola matematicamente il simbolo corretto alle coordinate (i, j), dove entrambi vanno da -n a n. Formato umano:

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 byte

ho golfato oltre 100 byte dal mio primo approccio ed è ancora la risposta più lunga qui.

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

abbattersi

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

ungolfed

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 byte

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

Provalo online!

Haskell , 110 byte

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

Provalo online!

Spiegazione / Ungolfed

La funzione helper gaccetta un carattere e un elenco di stringhe, quindi pre e aggiunge quel carattere a ciascuna stringa:

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

Successivamente l'operatore (!)prende una funzione ( g), un numero ( n) e un carattere ( c). Quindi calcola l'output per n-1, applica la funzione gad esso e aggiunge una stringa della stessa larghezza composta da cs all'inizio e alla fine:

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

Con questi siamo pronti a generare gli output in modo ricorsivo, prima dobbiamo coprire il case base:

f 0 = ["|"]

E poi la ricorsione:

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

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

TIO

Stax , 22 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo