Мені здається захоплюючим, як букви «Н» і «Я» дуже схожі. «Н» - горизонтальний хід, оточений двома вертикальними штрихами; "Я" - це вертикальний штрих, оточений двома горизонтальними штрихами (залежно від вашого шрифту). Гадаю, що це може бути вкладене ... Ви знаєте, про що це мені нагадує? Фрактали !!!

Давайте визначимо піраміду "IHIH" наступним чином: Перша ітерація - це представлення ASCII букви "Я":

---
 |
---

Наступна ітерація має вертикальний хід з обох боків.

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

Якщо ви розглядаєте "Я" посередині як єдиний горизонтальний штрих, то ця друга ітерація в основному є "Н". Третя ітерація додає горизонтальний штрих вгорі і внизу

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

Знову ж таки, якщо ви бачите "H" посередині як єдиний вертикальний штрих, то ця ітерація в основному є "Я". Ця закономірність продовжується, чергуючи між "H" і "Я" на кожній ітерації. Для довідки, ось перші 6 ітерацій:

1:
---
 |
---

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

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

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

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

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

Змагання:

Напишіть програму або функцію, яка виводить N- ту ітерацію піраміди IHIH та необов'язковий кінцевий новий рядок. Вашим входом буде одне додатне ціле число в будь-якому розумному форматі. Вам не доведеться обробляти недійсні введення, наприклад, не цілі числа, числа менші за 1 і т. Д. Ваша програма повинна принаймні створювати правильний вихід для входів до 20. Оскільки це код-гольф , стандартні лазівки не дозволені і найкоротша відповідь у байтах виграє!

Pyth , 50 40 31 25 байт

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

Тестовий набір.

Пояснення

Це рекурсивний алгоритм.

У кожній ітерації ми виконуємо три дії:

1. додайте та додайте пробіл до кожного рядка
2. транспонірувати масив
3. додайте та додайте до кожного рядка "-"або "|"залежно від кількості ітерацій.

Після ітерацій будуть перенесені непарні виходи. Тому ми їх перекладаємо.

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 байт

Рекурсивне рішення:

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]

Викликається з print ("\n".join(i(int(sys.argv[1])))), де параметром є ітераційний номер піраміди IHIH.

Дякуємо @DJMcMayhem за збереження 20 байт. Ідея цих пропозицій додатково зберегла ще 12 байт. Дякуємо @Maltysen за пропозиції, які обрізали ще кілька байтів.

Функція встановлює роздільник , dщоб "|"і проміжні простору до " "(для непарних ітерацій), має справу з поверненням в виродженим випадку, а потім скидає роздільник до " "і проміжним просторів , в "-"протягом парних ітерацій. Функція повертає список рядків для кожного рядка IHIH, вбудувавши результат рекурсивного виклику до функції в потрібному місці в списку.

Чеддар , 186 177 165 154 148 131 байт

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

Використовується рекурсія. Додамо пояснення після того, як зробили гольф.

Спробуйте в Інтернеті!

Пояснення

Цей склад є занадто складним, але слідкуйте за всіма змінними, які я використовую, але я спробую зробити це простим:

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

Це було болем для гольфу, але його 55 байт коротше, ніж оригінально.

Python 2, 93 байт

Leaky Nun зберегла 7 байт.

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)

Матриці , 80 62 байт

Ітераційне рішення (Рекурсія в матрицях складна ...)

Бігайте з 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 ;;

Пояснення:

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 байт

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>

Рекурсивне рішення працює, приймаючи попередню ітерацію, додаючи vсимвол у сторони, потім додаючи cсимвол у кути та hсимвол у верхній і нижній частині. Набір символів просто чергує кожну ітерацію. Редагувати: збережено 2 байти, повернувшись vколи n=0.

Діялог APL , 52 43 байти

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

v h s←'|- 'призначає трьом символам три імені ( v ertical, h orizontal, s pace)

⊃ перший, тобто |

⍪ скласти в 1 × 1 стіл

{... }⍣⎕отримати введення та застосувати функцію дужки, яка багато разів

 v=⊃⍵: якщо верхній лівий символ аргументу вертикальний, то:

  h⍪⍨ горизонталі внизу

  h⍪ горизонталі вгорі

  s, пробіли зліва від

  ⍵,s аргумент з пробілами праворуч

 ⋄ ще:

  v,⍨ вертикалі праворуч від

  v, вертикалі зліва від

  s⍪ пробіли нагорі

  ⍵⍪s аргумент із пробілами внизу

СпробуйтеAPAP онлайн!

Брахілог , 84 байти

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

Спробуйте в Інтернеті!

Порт моєї відповіді в Pyth .

C, 110 байт

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

Викликати як f(n) . Для 111 байт я міг зробити:

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

тобто #defineзберігає рівно один байт.

Діалог APL, 34 байти

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

{... }⍣⍵⍪'|'Застосувати функцію в дужки ⍵раз, починаючи з матриці символів 1x1| . Результатом кожної програми є аргумент для наступної програми.

s b←' -|'~⊃⍵ s - пробіл, а b - смуга не у верхньому лівому куті аргументу (' -|'~'-' видаляє горизонтальну смугу та залишає простір та вертикальну смугу)

s,⍵,⊃s b додайте пробіл вліво і вправо (⊃ вибирає s з векторного sb)

b,b,⍨⍉ перемістити та додати b вліво та вправо

Для непарних чисел це залишає результат переміщеним, тому потрібно остаточне переміщення.

⍉⍣⍵Перенесіть ⍵часи (одного разу буде достатньо, але коротше це кодувати)

СпробуйтеAPL онлайн

Чеддар , 107 байт

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

Спробуйте в Інтернеті!

Чеддар, 85 байт

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

Моя перша відповідь Чеддара. Спробуйте в Інтернеті!

Якщо я спробую написати r=(-n|>n).map(v->abs v).map, а значить r(y->r(x->…)), перекладач розбивається. ; -;

APL (Dyalog Classic) , 34 байти

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

Спробуйте в Інтернеті!

(використовує ⎕io←1)

⍳⎕ є 1 2 ... N

(⌽,0,⊢) - потяг, який перетворює його -N ... -1 0 1 ... N

∘.( )⍨ виконує дужки для кожної пари координат ⍺ ⍵

поїзд (≤-(1+=)×2|⌈)або його dfn-еквівалент {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}виробляє матрицю на зразок:

 ¯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+ ]робить ці дійсні індекси у ⎕IO=1та вибирає відповідні символи

Рубі, 81 78 77 байт

Це ґрунтується на відповіді Пінтона Пітона . Пропозиції з гольфу вітаються.

Редагувати: 3 байти завдяки Лінн. Виправлення та гольф 1 байт завдяки Йорданії.

->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 байт

Це, мабуть, не найрозумніший спосіб зробити це: Розширення рядка з усіх боків nкроками:

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

Використання: Зберегти як g.m (чи потрібно це додати до числа байтів?) Та дзвоніть, наприклад g(15).

Безголівки:

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

Власне , 48 45 44 байт

Це спроба надіслати мою відповідь Рубі фактично. Це занадто довго, і пропозиції з гольфу дуже вдячні. Спробуйте в Інтернеті!

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

Ось 46-байтна версія, яка розділяє вкладені функції, щоб ми могли визначитись "| -"у меншій кількості байтів. Спробуйте в Інтернеті!

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

Ungolfing:

Перший алгоритм

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.

Другий алгоритм

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.

Полотно , 19 18 17 14 байт

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

Спробуйте тут!

Якби мені було дозволено виводити кожен другий вихід, повернутий на 90 °, останні 4 символи можна було б видалити.

Пояснення (деякі символи були змінені на вигляд ~ монопростір):

|               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 байт

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

Спробуйте в Інтернеті!

-1 дякую Дзаймі ...

Це ітеративне рішення.

По суті це робиться шляхом створення наступного шаблону:

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

Потім, попарно, перекладаючи кожен елемент разом і додаючи накладки.

Перекладаючи після кожної ітерації, ми закінчуємо створення єдиного кутового шаблону.

Тоді ми можемо використовувати команди відображення 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.

Математика, 158 164 байт

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

Математично обчислює правильний символ у координатах (i, j), де обидва біжать від -n до n. Відформатовано людиною:

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 байт

я пограв більше ніж 100 байт від мого першого підходу, і це все ще найдовша відповідь.

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

зламатися

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

неозорий

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 байт

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

Спробуйте в Інтернеті!

Haskell , 110 байт

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

Спробуйте в Інтернеті!

Пояснення / Недозволений

Допоміжна функція gприймає символ і список рядків, після чого попередньо і додає цей символ до кожної строки:

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

Далі оператор (!)приймає функцію (g ), число ( n) і символ ( c). Потім він обчислює висновок для n-1, застосовує до нього функцію gі додає рядок такої ж ширини, що складається з cs на початку і в кінці:

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

З цим ми готові генерувати результати рекурсивно, спочатку нам потрібно висвітлити базовий випадок:

f 0 = ["|"]

А потім рекурсія:

-- 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 байт

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

ТІО

Стакс , 22 байти

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

Запустіть і налагоджуйте його

Розпакований, неозорений та прокоментований, це виглядає приблизно так.

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

Виконати цей