IHIHピラミッド

34

「H」と「I」の文字が非常に似ているのは魅力的です。「H」は、2つの垂直ストロークに囲まれた水平ストロークです。「I」は、2つの水平ストロークに囲まれた垂直ストロークです（フォントによって異なります）。これは入れ子にできると思います...それが何を思い出させるか知っていますか？フラクタル !!!

「IHIH」ピラミッドを次のように定義します。最初の反復は、文字「I」のこのASCII表現です。

---
 |
---

次の反復では、両側に垂直ストロークがあります。

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

中央の「I」を単一の水平ストロークとして表示する場合、この2番目の反復は基本的に「H」です。3番目の反復では、上下に水平ストロークを追加します

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

繰り返しになりますが、中央の「H」を単一の垂直ストロークと見なす場合、この反復は基本的に「I」です。このパターンは、繰り返しごとに「H」と「I」を交互に繰り返します。参考までに、最初の6つの反復を以下に示します。

1:
---
 |
---

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

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

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

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

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

チャレンジ：

IHIHピラミッドのN番目の反復とオプションの末尾の改行を出力するプログラムまたは関数を作成します。入力は、必要な合理的な形式の単一の正の整数になります。無効な入力（非整数、1未満の数値など）を処理する必要はありません。プログラムは少なくとも20までの入力に対して正しい出力を生成する必要があります。これはcode-golfであるため、標準の抜け穴は許可されません。バイト単位の最短回答が勝ちます！

code-golf  ascii-art  fractal 
— DJMcMayhem
ソース
1行ごとに文字列の矢印を返すことは許容されますか？
— ローハンジュンジュンワラ
チャレンジ基準を完全に満たしていませんでしたが、偶然クールなことをしました
— 魔法のタコ

回答:

7

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

テストスイート。

説明

これは再帰的なアルゴリズムです。

各反復で、次の3つのアクションを実行します。

  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

パイソン、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ピラミッドの反復番号です。

20バイトを節約してくれた@DJMcMayhemに感謝します。これらの提案の背後にあるアイデアを取り入れることで、さらに12バイト節約できました。@Maltysenに、さらにバイトを削減した提案をありがとう。

この関数は、区切り文字dをに設定し"|"、中間のスペースを" "（奇数回の繰り返しの場合）に設定し、縮退の場合に戻る処理を行い、偶数回の繰り返しの場合に区切り文字をリセットし" "、中間のスペースを"-"にリセットします。関数は、IHIHの各行の文字列のリストを返します。関数の再帰呼び出しの結果は、リスト内の適切な場所に埋め込まれています。

— サイモン
ソース
2
いい答えです。サイトへようこそ！行を結合する必要はありません。文字列のリストは問題ありません。いくつかのヒント：2行目と3行目をif e<1:return'|'（それらの間に改行はありません）に変更してから、「else」を削除し、余分なインデントを削除します。
— DJMcMayhem
1
後にスペースを取り出すことができますreturn。また、ifセミコロンでsのない行をマージし、インデントを保存することができます
— -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バイトはオリジナルよりも短くなりました。

— ダウンゴート
ソース
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
— リーキー修道女
ああ、もちろん：最初int(x/2.)は服用してrange(-n,n+1)いたので必要でしたが、今はそれらを使うことができます。ありがとうございました！
— リン
単に「Python」と言うのは通常、コードがPython 2またはPython 3で動作することを意味するため、ヘッダーでPython 2を指定しましたが、ここではそうではありません。
— メゴ
7

マトリックス、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
— 青い
ソース
1
うわー、反復的！私が感銘を受けた。
— コナーオブライエン
@ ConorO'Brien Matricksは動的なマトリックスのサイズ変更のために構築されたので、それほど印象的ではありませんが、とにかく感謝します！
— ブルー
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

Dyalog APL、52 43 バイト

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

v h s←'|- '3つの名前（に割り当てられる3文字のV ertical、時間 orizo​​ntal、Sペース）

⊃ 最初のもの、すなわち |

⍪ 1×1テーブルにする

{... }⍣⎕入力を取得し、ブレースされた関数を何度も適用する

 v=⊃⍵: 引数の左上の文字が垂直の場合、次のようになります。

  h⍪⍨ 下の水平線

  h⍪ 上記の水平線

  s, の左側のスペース

  ⍵,s 右側にスペースがある引数

 ⋄ その他：

  v,⍨ 右側の垂直

  v, の垂直方向の左側

  s⍪ 上記のスペース

  ⍵⍪s 下にスペースがある引数

TryAPLオンライン！

— アダム
ソース
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正確に1バイトを保存します。

— リン
ソース
3

Dyalog APL、34バイト

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

{... 文字の1x1マトリックスで始まる}⍣⍵⍪'|'中括弧で関数を適用します⍵|。各アプリケーションの結果は、次のアプリケーションの引数です。

s b←' -|'~⊃⍵sはスペースで、bは引数の左上隅にないバーです（' -|'~'-'水平バーを削除し、スペースと垂直バーを残します）

s,⍵,⊃s b左右にスペースを追加（⊃ベクトルsbからsを選択）

b,b,⍨⍉ 転置し、bを左右に追加します

奇数の場合、結果は転置されたままになるため、最終的な転置が必要です。

⍉⍣⍵転置⍵時間（1回で十分ですが、この方法でコーディングするには短い）

TryAPLオンライン

— ギル
ソース
PPCGへようこそ！
— スティーブン
ありがとう！今パーティーに参加しようと、これらを解決する多くの楽しみ：）
— ギル
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))abs関数の振る舞いを持つ関数を返します）。例(+)(1,2)-> 3。(^)(2,6)->64。また、アウトゴルフを50％近く行ったことで大きな驚き
— Downgoat
いいえ、私はそれを試しました：（おそらく要素とそのインデックスの両方を受け取るRuntime Error: `abs` has no behavior for types `Number` and `Number` ためmapです。）
— Lynn
ああ：/私はちょうどそのバグを今日修正しようとしていました> _>
— 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、対応する文字を選択します

— NGN
ソース
1

ルビー、81 78 77バイト

これはに基づいています LynnのPython answerにます。ゴルフの提案を歓迎します。

編集：リンのおかげで3バイト。ヨルダンのおかげで訂正とゴルフ1バイトができました。

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

アンゴルフ：

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
— シャーロック9
ソース
できます.map(&:abs)か？
— リン
@Lynnよく見つけました。他の提案はありますか？
— シャーロック
最初*は何もしていません。の*""代わりに使用できます.join。また、使用するとp、各行が引用符で囲まれ（inspect引数で呼び出されます）、失格になる可能性があります。
— ヨルダン
また、&:abs（map &:abs）の周りの括弧を削除することもできます。Array#productネストされたmapsの代わりに何かをすることができるかもしれませんが、改行がトリッキーになります。
— ヨルダン
@Jordan最初の4つのヒントは機能しますが、 r.product(r).map（機能しますが）より長く、改行を許可するようには見えません。
— Sherlock9
1

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
— ワウゼル
ソース
あなたは置き換えることができます' 'によって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

アンゴルフ：

最初のアルゴリズム

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.

2番目のアルゴリズム

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.
— シャーロック9
ソース
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£M現在のサイズよりも長い（2バイト）が、これを短くする方法にインスピレーションを見つけるかもしれない。
— メゴ
1

Canvas、19 18 17 14 バイト

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

ここで試してみてください！

90°回転した出力を1つおきに出力できる場合、最後の4文字を削除できます。

説明（一部の文字は〜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°
— ザイマ
ソース
彼らもその制限を緩めた場合、私は6バイトを失います：P。
— 魔法のタコ
P（？転置ループからあなたの答えの利益も同様でし）：私のためにバイトという-5 @MagicOctopusUrn wellp、メイク
— dzaima
私の実装は転置ループ：Dです。
— 魔法のタコ
1

05AB1E、29 28バイト

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

オンラインでお試しください！

-1ザイマのおかげで...

これは反復的な解決策です。

基本的に、これは次のパターンを作成することで作成されます。

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

次に、ペアごとに、各要素を一緒に転置し、パディングを追加します。

各反復後に転置することにより、パターンの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.
— 魔法のタコUr
ソース
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;
}

食べない

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;
}
— タイタス
ソース
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

オンラインでお試しください！

説明/ゴルフなし

ヘルパー関数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

スタックス、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

これを実行する

— 再帰的
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.