Saya menemukan betapa menariknya huruf "H" dan "Saya" sangat mirip. "H" adalah goresan horizontal yang dikelilingi oleh dua goresan vertikal; "I" adalah goresan vertikal yang dikelilingi oleh dua goresan horizontal (tergantung font Anda). Saya yakin ini bisa disarangkan ... Anda tahu apa yang mengingatkan saya? Fraktal !!!

Mari kita mendefinisikan piramida "IHIH" sebagai berikut: Iterasi pertama adalah representasi ASCII dari huruf "I":

---
 |
---

Iterasi berikutnya memiliki stroke vertikal di kedua sisi.

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

Jika Anda melihat "I" di tengah sebagai satu pukulan horizontal tunggal, maka iterasi kedua ini pada dasarnya adalah "H". Iterasi ketiga menambahkan goresan horizontal di bagian atas dan bawah

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

Sekali lagi, jika Anda melihat "H" di tengah sebagai stroke vertikal tunggal, maka iterasi ini pada dasarnya adalah "I". Pola ini berlanjut, bergantian antara "H" dan "I" pada setiap iterasi. Untuk referensi, berikut adalah 6 iterasi pertama:

1:
---
 |
---

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

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

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

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

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

Tantangan:

Menulis sebuah program atau fungsi yang output n'th iterasi dari piramida IHIH, dan baris baru opsional. Masukan Anda akan menjadi bilangan bulat positif tunggal dalam format wajar apa pun yang Anda inginkan. Anda tidak harus menangani input yang tidak valid, misalnya non-integer, angka lebih kecil dari 1, dll. Program Anda paling tidak harus menghasilkan output yang tepat untuk input hingga 20. Karena ini adalah kode-golf , celah standar tidak diperbolehkan dan jawaban tersingkat dalam byte menang!

Pyth , 50 40 31 25 byte

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

Penjelasan

Ini adalah algoritma rekursif.

Dalam setiap iterasi, kami melakukan tiga tindakan:

1. tambahkan dan tambahkan spasi untuk setiap baris
2. transpos array
3. tambahkan dan tambahkan ke setiap baris baik "-"atau "|"tergantung pada jumlah iterasi.

Setelah iterasi, output bernomor ganjil akan dialihkan. Karena itu, kami memindahkannya.

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 byte

Solusi rekursif:

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]

Disebut dengan print ("\n".join(i(int(sys.argv[1])))), di mana parameter adalah nomor iterasi dari piramida IHIH.

Terima kasih kepada @DJMcMayhem karena telah menghemat 20 byte. Mengambil ide di balik saran-saran tersebut selanjutnya menyelamatkan 12 byte lagi. Terima kasih kepada @Maltysen untuk saran yang memangkas beberapa byte lagi.

Fungsi mengatur pembatas dke "|"dan ruang intervensi ke " "(untuk iterasi ganjil), berurusan dengan pengembalian dalam kasus degenerasi, kemudian mengatur ulang pembatas ke " "dan ruang intervensi ke "-"untuk iterasi genap genap. Fungsi mengembalikan daftar string untuk setiap baris IHIH, setelah menyematkan hasil dari panggilan rekursif ke fungsi di tempat yang tepat dalam daftar.

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

Gunakan rekursi. Akan menambah penjelasan begitu selesai bermain golf.

Cobalah online!

Penjelasan

Yang ini agak rumit juga melacak semua variabel yang saya gunakan, tetapi saya akan mencoba membuatnya tetap sederhana:

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

Ini menyakitkan untuk golf tetapi 55 byte lebih pendek dari aslinya.

Python 2, 93 byte

Leaky Nun menghemat 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)

Matricks , 80 62 byte

Solusi berulang (Rekursi dalam Matricks sulit ...)

Jalankan dengan 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 ;;

Penjelasan:

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>

Solusi rekursif bekerja dengan mengambil iterasi sebelumnya, menambahkan vkarakter ke samping, lalu menambahkan ckarakter ke sudut-sudut dan hkarakter di sepanjang bagian atas dan bawah. Himpunan karakter hanya bergantian setiap iterasi. Sunting: Disimpan 2 byte dengan mengembalikan vkapan n=0.

Dyalog APL , 52 43 byte

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

v h s←'|- 'ditunjuk tiga karakter untuk tiga nama ( v ertical, h orizontal, s kecepatan)

⊃ yang pertama, yaitu |

⍪ buat menjadi 1 × 1 meja

{... }⍣⎕dapatkan input dan terapkan fungsi bracing yang berulang kali

 v=⊃⍵: jika karakter kiri atas argumen adalah vertikal, maka:

  h⍪⍨ horizontal di bawah ini

  h⍪ horizontal di atas

  s, spasi di sebelah kiri

  ⍵,s argumen dengan spasi di sebelah kanan

 ⋄ lain:

  v,⍨ vertikal ke kanan

  v, vertikal ke kiri

  s⍪ ruang di atas

  ⍵⍪s argumen dengan spasi di bawah ini

TryAPL online!

Brachylog , 84 byte

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

Cobalah online!

Port jawaban saya di 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]);}

Diminta sebagai f(n). Untuk 111 byte, saya bisa melakukan:

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

yaitu, #definemenyimpan tepat satu byte.

Dyalog APL, 34 byte

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

{... }⍣⍵⍪'|'Terapkan fungsi dalam kurung kurawal ⍵mulai dengan 1x1 matriks karakter |. Hasil dari setiap aplikasi adalah argumen untuk aplikasi berikutnya.

s b←' -|'~⊃⍵ s adalah ruang dan b adalah bilah tidak di sudut kiri atas argumen (' -|'~'-' menghilangkan bilah horizontal dan meninggalkan ruang serta bilah vertikal)

s,⍵,⊃s b tambahkan ruang ke kiri dan kanan (⊃ mengambil s dari vektor sb)

b,b,⍨⍉ transpos dan tambahkan b ke kiri dan kanan

Untuk bilangan ganjil, ini meninggalkan hasil yang ditransformasikan, sehingga transpos akhir diperlukan.

⍉⍣⍵Atur ulang ⍵waktu (satu kali sudah cukup, tetapi lebih pendek untuk kode dengan cara ini)

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

Cobalah 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

Jawaban Cheddar pertamaku. Cobalah online!

Jika saya mencoba menulis r=(-n|>n).map(v->abs v).map, dan kemudian r(y->r(x->…)), penerjemah macet. ; -;

APL (Dyalog Classic) , 34 byte

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

Cobalah online!

(menggunakan ⎕io←1)

⍳⎕ aku s 1 2 ... N

(⌽,0,⊢) adalah kereta yang mengubahnya menjadi -N ... -1 0 1 ... N

∘.( )⍨ mengeksekusi tanda kurung untuk setiap pasangan koordinat ⍺ ⍵

kereta (≤-(1+=)×2|⌈)atau yang setara dfn {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}menghasilkan matriks seperti:

 ¯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+ ]membuat indeks yang valid ini ⎕IO=1dan mengambil karakter yang sesuai

Ruby, 81 78 77 byte

Ini didasarkan pada jawaban Lynn Python . Saran golf diterima.

Sunting: 3 byte berkat Lynn. Koreksi dan golf 1 byte berkat Jordan.

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

Tidak melakukan pelanggaran:

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

Ini mungkin bukan cara paling cerdas untuk melakukannya: Memperluas string di semua sisi dalam nlangkah-langkah:

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

Penggunaan: Simpan sebagai g.m(apakah saya harus menambahkannya ke jumlah byte?) Dan memanggil misg(15) .

Tidak Disatukan:

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

Sebenarnya , 48 45 44 byte

Ini adalah upaya untuk mengirim jawaban Ruby saya ke Actually. Ini terlalu lama dan saran bermain golf sangat dihargai. Cobalah online!

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

Ini adalah versi 46-byte yang memisahkan fungsi-fungsi yang disarangkan sehingga kita dapat mendefinisikan "| -"dalam lebih sedikit byte. Cobalah online!

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

Tidak melakukan pelanggaran:

Algoritma pertama

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.

Algoritma kedua

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.

Kanvas , 19 18 17 14 byte

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

Coba di sini!

Jika saya diizinkan untuk mengeluarkan setiap keluaran lainnya yang diputar 90 °, 4 karakter terakhir dapat dihapus.

Penjelasan (beberapa karakter telah diubah agar terlihat ~ 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.∞.∊

Cobalah online!

-1 terima kasih kepada Dzaima ...

Ini adalah solusi berulang.

Intinya Ini dibuat dengan membuat pola berikut:

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

Kemudian, berpasangan, transposing setiap elemen bersama-sama dan menambahkan padding.

Dengan transposing setelah setiap iterasi, kita akhirnya menciptakan satu sudut pola.

Kemudian, kita bisa menggunakan perintah refleksi 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}]

Secara matematis menghitung simbol yang benar pada koordinat (i, j), di mana keduanya berjalan dari -n ke n. Manusia diformat:

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

bermain golf lebih dari 100 byte dari pendekatan pertama saya dan itu masih jawaban terpanjang di sini.

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

kerusakan

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

Cobalah 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

Cobalah online!

Penjelasan / Tidak Diundang

Fungsi helper gmengambil karakter dan daftar string, lalu mendahului dan menambahkan karakter itu ke setiap string:

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

Selanjutnya operator (!)mengambil fungsi ( g), angka ( n) dan karakter ( c). Kemudian menghitung output untuk n-1, menerapkan fungsi guntuk itu dan menambahkan string dengan lebar yang sama yang terdiri dari cs ke awal dan akhir:

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

Dengan ini kami siap untuk menghasilkan output secara rekursif, pertama-tama kita perlu membahas kasus dasar:

f 0 = ["|"]

Dan kemudian rekursi:

-- 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ä≤δ₧߃

Jalankan dan debug itu

Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

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

Jalankan yang ini