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

Давайте определим пирамиду «IHIH» следующим образом: Первая итерация - это ASCII-представление буквы «I»:

---
 |
---

Следующая итерация имеет вертикальный штрих с обеих сторон.

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

Если вы рассматриваете «Я» в середине как один горизонтальный штрих, то эта вторая итерация в основном представляет собой «Н». Третья итерация добавляет горизонтальный штрих сверху и снизу

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

Опять же, если вы рассматриваете букву «H» в середине как один вертикальный штрих, то эта итерация в основном представляет собой «I». Этот шаблон продолжается, чередуя "H" и "I" на каждой итерации. Для справки, вот первые 6 итераций:

1:
---
 |
---

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

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

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

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

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

Соревнование:

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

Pyth , 50 40 31 25 байт

J @ су, J + * \ - K + 2lheN + Jr * 2, еп * \ - KJR "||" + * дК + 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)

Matricks , 80 62 байта

Итеративное решение (рекурсия в Matricks сложна ...)

Бежать с python matricks.py ihih.txt [[]] <input> --asciiprint

K124; FIQ% 2: v; б [M124: Q * 2 + 3: 1;]; а {г: Q * 2 + 1;} ;: б; v [M45: 1: Q * 2 + 3;] ; и {ZQ * 2 + 1:;} ;;: 1: п ;;
K124; FIQ% 2: v; б [M124: Q * 2 + 3: 2;]; В1;: б; v [M45: 2: Q * 2 + 3;]; V1, ;;: 1: п ;;

Объяснение:

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.

Дьялог АПЛ , 52 43 байта

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

v h s←'|- 'правопреемники три символа до трех имен ( об ertical, ч orizontal, S темп)

⊃ первый, т.е. |

⍪ сделать в 1 × 1 таблице

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

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

  h⍪⍨ горизонтали ниже

  h⍪ горизонтали выше

  s, пробелы слева от

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

 ⋄ еще:

  v,⍨ вертикали справа от

  v, по вертикали слева от

  s⍪ пробелы выше

  ⍵⍪s аргумент с пробелами ниже

Попробуй APL онлайн!

Брахилог , 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сохраняет ровно один байт.

Дьялог АПЛ, 34 байта

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

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

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

s,⍵,⊃s bдобавить пространство слева и справа ( ⊃выбирает s из вектора sb)

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

Это основано на ответе Линн на Python . Предложения по игре в гольф приветствуются.

Редактировать: 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

МАТЛАБ, 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) .

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

На самом деле , 48 45 44 байт

Это попытка перенести мой ответ Ruby на Actually. Это слишком долго, и предложения по игре в гольф очень ценятся. Попробуйте онлайн!

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.

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

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

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

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

Объяснение / Ungolfed

Вспомогательная функция 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:

TIO

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

Запустите этот