IHIH Пирамида

34

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

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

---
 |
---

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

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

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

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

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

1:
---
 |
---

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

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

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

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

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

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

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

DJMcMayhem
источник
Допустимо ли возвращать стрелку строк по одному на каждую строку?
Рохан Джунджхунвала
Не совсем соответствует критериям, но случайно сделал что-то крутое ... Попробуйте онлайн!
Волшебная Урна Осьминога

Ответы:

7

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
Дрянная Монахиня
источник
Я люблю идею транспонирования.
Тит
12

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, вставив результат рекурсивного вызова функции в нужное место в списке.

Саймон
источник
2
Приятный ответ и добро пожаловать на сайт! Вам не нужно объединять строки, список строк в порядке. Пара советов: измените строки 2 и 3 на if e<1:return'|'(без новой строки между ними), затем удалите «else» и удалите лишние отступы.
DJMcMayhem
1
Вы можете вынуть место после return. Кроме того, вы можете объединить строки без ifs с точкой с запятой и сэкономить на отступе
Maltysen
1
Я отредактировал твой ответ. Пожалуйста, не стесняйтесь отменить мои правки, если они вам не нравятся.
Утренняя монахиня
10

Чеддер , 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 байтов короче, чем оригинал.

Downgoat
источник
8

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)
Линн
источник
Закрытая форма: o: o
Leaky Nun
Ах, конечно: сначала мне нужно было, int(x/2.)потому что я принимал, range(-n,n+1)но теперь я могу просто использовать их. Спасибо!
Линн
Я указал Python 2 в заголовке, потому что просто сказать «Python» обычно означает, что код работает либо под Python 2, либо с Python 3, что здесь не так.
Mego
7

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
синий
источник
1
Вау, итеративный! Я впечатлен.
Конор О'Брайен
@ ConorO'Brien Matricks был создан для динамического изменения размера матрицы, так что это не впечатляет, но все равно спасибо!
Blue
5

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.

Нил
источник
4

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

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

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

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

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

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

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

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

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

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

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

еще:

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

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

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

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

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

Адам
источник
3

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

Линн
источник
3

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

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

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

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

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

b,b,⍨⍉ транспонировать и добавить б влево и вправо

Для нечетных чисел это оставляет результат транспонированным, поэтому требуется финальная транспонирование.

⍉⍣⍵Время транспонирования (достаточно было бы одного раза, но для того, чтобы закодировать таким образом)

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

Гил
источник
Добро пожаловать в PPCG!
Стивен
Благодарность! Попытка вступить в партию сейчас, очень весело, решая их :)
Gil
2

Чеддер, 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->…)), интерпретатор падает. ; -;

Линн
источник
Вы можете сделать v->abs vв (abs)(например r.map((abs))) , который будет возвращать функцию , которая имеет поведение функции абс. например (+)(1,2)-> 3. (^)(2,6)-> 64. Кроме того, я не могу превзойти меня почти на 50%
Downgoat
Нет, я попробовал это: Runtime Error: `abs` has no behavior for types `Number` and `Number` (потому что mapполучает и элемент, и его индекс, предположительно.)
Линн
ах: / я как раз собирался исправить эту ошибку сегодня> _>
Downgoat
2

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и выбирает соответствующие символы

СПП
источник
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
Sherlock9
источник
Ты можешь .map(&:abs)?
Линн
@ Линн Хорошо замечен. Любые другие предложения?
Sherlock9
Первый *ничего не делает. Вы можете использовать *""вместо .join. Кроме того, использование pокружает каждую строку кавычками (это вызывает inspectее аргументы), что может вас дисквалифицировать.
Джордан
Также вы можете убрать круглые скобки &:abs( map &:abs). Возможно, вы сможете что-то делать Array#productвместо вложенных maps, но это усложнит разрывы строк.
Джордан
@Jordan Ваши первые четыре подсказки работают, но r.product(r).map(хотя это работает) длиннее и, по-видимому, не позволяют легко переносить строки.
Sherlock9
1

МАТЛАБ, 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
Wauzl
источник
Вы можете заменить ' 'на 0(Matlab рассматривает char 0 как пробел) и '-' на 45. Имя файла не должно быть включено в число байтов
Луис Мендо
1

На самом деле , 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.
Sherlock9
источник
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£Mбольше, чем у вас в настоящее время (на 2 байта), но вы можете найти вдохновение для способов сделать его короче, чего я не вижу.
Mego
1

Холст , 19 18 17 14 байтов

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

Попробуй это здесь!

Если бы мне было разрешено выводить все остальные выходные данные, повернутые на 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°
dzaima
источник
Я бы потерял 6 байт, если бы они тоже ослабили это ограничение: P.
Волшебная урна осьминога
@MagicOctopusUrn wellp, сделай для меня это -5 байт: p (твой ответ также может принести пользу от транспонированного цикла?)
dzaima
моя реализация представляет собой цикл транспонирования: D.
Волшебная Урна Осьминога
1

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.
Урна волшебного осьминога
источник
0

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}]
Грег Мартин
источник
@ Adám Спасибо за указатель на эту тему!
Грег Мартин
0

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;
}
Titus
источник
0

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 ) ' '
ბიმო
источник
0

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

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

рекурсивный
источник