Кодекс Гольфа - Пирамида Ihih

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

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

 
 
 
 1:
---

|
---

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

3:
-------

|   |

|---|

| | |

|---|

|   |
-------

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

5:
-----------

|       |

|-------|

| |   | |

| |---| |

| | | | |

| |---| |

| |   | |

|-------|

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

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

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

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

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

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

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

--- | ---

Задача:

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

#код-гольф #код-гольф #ascii-art #фрактал

Питон, 165 145 133 123 байта

Рекурсивное решение:

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

Позвонили с

 
[email protected],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\|
 

, where the parameter is the iteration number of the IHIH pyramid.

Спасибо @DJMcMayhem за экономию 20 байт. Использование идеи, лежащей в основе этих предложений, позволило сэкономить еще 12 байт. Спасибо @Maltysen за предложения, которые сократили еще несколько байтов.

Функция устанавливает разделитель

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

to -- 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 ) ' ' и промежуточные пространства для f 0 = ["|"] (for odd-numbered iterations), deals with returning in the degenerate case, then resets the delimiter to (g ! n) c | prev <- g $ f (n-1), ln <- [c | _ <- head p] = [ln] ++ prev ++ [ln] и промежуточные пространства для c for even-numbered iterations. The function returns a list of strings for each line of the IHIH, having embedded the result of a recursive call to the function in the right place within the list.

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

g

Использует рекурсию. Дополню объяснение после игры в гольф.

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

Объяснение

Это немного сложно, слишком важно отслеживать все переменные, которые я использую, но я постараюсь сделать это проще:

n-1

Это было проблемой для гольфа, но он на 55 байт короче оригинала.

Питон 2, 93 байта

Дырявая монахиня сэкономила 7 байт.

c ||answer||

Пиф, 50 40 31 25 байт

n

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

Объяснение

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

На каждой итерации мы выполняем три действия:

1. добавить и добавить пробел к каждой строке
2. транспонировать массив
3. добавить и добавить к каждой строке либо g or (!) в зависимости от количества итераций.

После итераций выходные данные с нечетными номерами будут транспонированы. Поэтому мы их транспонируем.

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

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

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

Беги с g

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

Объяснение:

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

JavaScript (ES6), 92 90 байт

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; } 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 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;} character to the sides, then adding the 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}] характер по углам и 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}] character along the top and bottom. The set of characters simply alternates each iteration. Edit: Saved 2 bytes by returning '| 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 когда âeò↕\┐▄┤╚╬8φ8Δ☺Pä≤δ₧߃ .

Диалог АПЛ, 52 43 байты

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

['|','--','|||',...] assigns the three characters to three names (вэртический, часгоризонтальный, сшаг)

„|-S¹>∍ƶćsvy‚˜.Bζ}¹Fζ}»R.∞.∊ the first one, i.e. | 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°

|╶［ ｅ↷ｌ|＊ｅ｝╶［↷ make into 1×1 table

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. ... 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╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£MΣ."%£M if the top-left character of the argument is a vertical, then:

   "| -" horizontals below

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

   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 spaces to the left of

   g(15) the argument with spaces to the right

  g.m else:

   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 verticals to the right of

   n verticals to the left of

   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 spaces above

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

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

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

r(y->r(x->…))

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

Порт мой ответ на Пите.

С, 110 байт

r=(-n|>n).map(v->abs v).map

Вызов как (n,r=(-n|>n).map(v->abs v))->r.map(y->r.map(x->"| -"[(x&-2)<y?y%2+1:x%2]).fuse).vfuse . For 111 bytes, I could do:

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

то есть, ⎕IO=1 saves exactly one byte.

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

'- |'[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 ... {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵} Применить функцию в фигурных скобках (≤-(1+=)×2|⌈) times starting with 1x1 matrix of character ⍺ ⍵ . Результат каждого приложения является аргументом для следующего приложения.

∘.( )⍨ s is space and b is the bar not in the top left corner of the argument ( -N ... -1 0 1 ... N убирает горизонтальную полосу и оставляет место и вертикальную полосу)

(⌽,0,⊢) add space to left and right ( 1 2 ... N выбирает s из вектора s b)

⍳⎕ transpose and add b to left and right

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

⎕io←1 Transpose '- |'[2+∘.(≤-(1+=)×2|⌈)⍨(⌽,0,⊢)⍳⎕] раз (одного раза было бы достаточно, но для такого кода код будет короче)

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

АПЛ (Диалог Классик), 34 байта

⍵

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

(использует ⍉⍣⍵ )

b,b,⍨⍉ is ⊃

s,⍵,⊃s b is a train that turns it into ' -|'~'-'

s b←' -|'~⊃⍵ executes the parentheses for every pair of coordinates |

поезд ⍵ or its dfn equivalent }⍣⍵⍪'|' создает матрицу типа:

{

{⍉⍣⍵{b,b,⍨⍉s,⍵,⊃s b←' -|'~⊃⍵}⍣⍵⍪'|'} makes these valid indices in #define и выбирает соответствующие символы

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

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

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

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

f(n)

Мой первый ответ о Чеддере. Попробуйте онлайн!

Если я попытаюсь написать #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]);} , and then ,[[["|"]]:?:1]i:1:zi:ca~@nw hh~m["-|":B]:ramggL," "ggS,?:Sz:ca:Srz:caz:Lz:ca:Lrz:ca. , интерпретатор выходит из строя. ;-;

Рубин, 81 78 77 байт

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

Редактировать: 3 байта благодаря Линн. Исправления и гольф 1 байт спасибо Джордану.

⍵⍪s

Унгольфинг:

s⍪ ||answer||

MATLAB, 168 163 байта

Вероятно, это не самый умный способ сделать это: расширить строку со всех сторон в v, steps:

v,⍨

Использование: Сохранить как ⋄ (do I have to add that to the byte count?) and call e.g. ⍵,s .

Не в гольфе:

s, ||answer||

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

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

h⍪

Вот 46-байтовая версия, в которой вложенные функции разделены, чтобы мы могли определить h⍪⍨ in fewer bytes. Попробуйте онлайн!

v=⊃⍵:

Унгольфинг:

Первый алгоритм

}⍣⎕

Второй алгоритм

{ ||answer||

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

⍪

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

Если бы мне разрешили выводить каждый второй вывод с поворотом на 90°, последние 4 символа можно было бы удалить.

Пояснение (некоторые символы изменены и теперь выглядят ~monospace):

| ||answer||

05AB1E, 29 28 байт

⊃

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

-1 спасибо Дзайме...

Это итеративное решение.

---

По сути, это делается путем создания следующего шаблона:

v h s←'|- '

Затем попарно транспонируем каждый элемент вместе и добавляем отступы.

Транспонируя после каждой итерации, мы в конечном итоге создаем один угол узора.

Затем мы можем использовать команды отражения 05AB1E.

---

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

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

n=0

Запустите и отладьте его

Распакованный, разархивированный и прокомментированный, он выглядит так.

v

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

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

h

Математически вычисляет правильный символ по координатам (i,j), где оба значения идут от -n до n. Человеческий формат:

c ||answer||

PHP, 166 байт

отбил более 100 байт от моего первого подхода

v

и это по-прежнему самый длинный ответ здесь.

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

авария

f= (n,[h,c,v]=n&1?`-- `:` ||`)=>n?(c+=h.repeat(n+n-1)+c)+` ${f(n-1).replace(/^|$/gm,v)} `+c:v ; ||answer||

не забитый в гольфПерл 5

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

, 150 байт

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

Хаскелл python matricks.py ihih.txt [[]] <input> --asciiprint

, 110 байт

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

Объяснение/Унгольфед 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 takes a character and a list of strings, it then pre- and appends that character to each string:

"|"

Вспомогательная функция "-" takes a function ( 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) Далее оператор ( 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 `|` ) and a character ( (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("|") ), число ( "-" , applies the function " " ). Затем он вычисляет результат для " " s to the beginning and end:

"|"

к нему и добавляет строку той же ширины, состоящую из

d

Теперь мы готовы рекурсивно генерировать выходные данные. Сначала нам нужно рассмотреть базовый случай:

print ("\n".join(i(int(sys.argv[1])))) ||answer||

И дальше рекурсия:Дж

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]

, 37 байт