前書き

紀元前2600年で、人々は現在ピラミッドを構築しています。彼らはすでにピラミッドの基礎を作ったが、どのように続けるか分からない。そこで、彼らはあなたに助けを求めました。

ピラミッドを作成するルールは非常に簡単です。前のレイヤーの上にあるレイヤーについては、次のステップバイステップのハンドガイドに従うだけです。

1. 前のレイヤーの端を切り取ります。

2. /キャラクターの上にキャラクターがなければならず、\その逆もあります。これは、エッジを除くすべての文字に適用されます。

3. 左端の文字は常にa /で、右端の文字は常に\です。

ピラミッドの基礎の例を見てみましょう。

//\/\/\\

以下を残して、エッジを切り取ります。

 /\/\/\

スラッシュをバックスラッシュで変更し、逆も同様です。

 \/\/\/

左端の文字は常にa /で、右端の文字は常にa \なので、次のように変更します。

 //\/\\

このレイヤーを前のレイヤーに配置します。

 //\/\\
//\/\/\\

最上部に到達するまで続行します（次のようになります/\）。したがって、最終的には次のようになります。

   /\
  //\\
 //\/\\
//\/\/\\

これは、出力する必要があるものです。

タスク

ピラミッドの基礎（長さが3を超える）を指定すると、ピラミッド全体が出力されます。左端の文字が/で、右端の文字がであると安全に仮定でき\ます。基底の長さは常に偶数であると仮定することもできます。末尾のスペースを使用できます。ピラミッドが所定の位置にある限り、先行スペースの使用も許可されます。1つの末尾と1 つの先頭の改行を使用できます。

テストケース

Input: /\\\
Output:
 /\
/\\\

Input: //\\///\/\
Output:
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Input: /////////////\
Output:
      /\
     /\\\
    /////\
   /\\\\\\\
  /////////\
 /\\\\\\\\\\\ 
/////////////\

これはcode-golfであるため、バイト数が最小の提出が勝ちです！

ゼリー、28 26 2524 バイト

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ

デニスのおかげで-4バイト

レシピ：

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ - one argument: input()
Q  Q       Q             - set of Left=input(): "/\"
 Ṛ                       - reverse Left: "\/"
  ,                      - Left-pair-Right: ["\/","/\"]
     ḊḊṖṖ                - dequeue Left twice, then pop twice: input()[2:-2]
    y                    - translate Right with mapping in Left: swaps internal slashes
         j@              - join Right with separator Left (@ swaps operands)
            µ  µ         - chain separators to form a 1,1,1 chain of chains
             ÐĿ          - loop while results are unique and collect them
                J        - yield [1,...,len(Left=input())]
                 ’       - decrement: [0,....len(input())-1]
                  ⁶      - " "
                   ẋ     - repeat Left Right times: ["", " ", ...]
                    ⁸ż   - zip Right and Left (⁸ is the link's Left argument):
                                ...pads the loop results
                      Y  - joins Left with line-feeds
                       Ṛ - reverse Left

（レモネードを添えて、それらのピラミッドはのどが渇いた労働者のために作ります）

TryItOnlineで独自のスラッシュピラミッドを作成するか、OPが提案するすべてのテイスターを試してください

網膜、59 56 54 52バイト

{`^( *)/.(.*)..
$1 /$2\¶$0
T`/\\`Ro`(?<=^ +/).+(?=.)

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

サンプル出力

    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Pyth - 27の 26バイト

OPで指定された操作によって、それが繰り返されるまで縮小します。これは空白行の場合です。

j_.e+*kdb.ujXtPtPNK"\/")_K

テストスイート。

Python 2、78バイト

f=lambda s,p='\n':(s[2:]and f('/%s\\'%s.translate('/\\'*128)[2:-2],p+' '))+p+s

文字列を出力する再帰関数。ピラミッドの各レイヤーは、その上のレイヤーで再帰呼び出しに追加されます。p改行文字として始まる接頭辞は、三角形を作るためのスペースをもう1つ増やします。次のレイヤーは、スラッシュを交換し、最初と最後の2つのシンボルを切り取り、左右のスラッシュの間に挟むことで作成されます。

Python 3は、長さ256の要件が削除された*99ためtranslate、で行うことでバイトを節約できます。

Haskell、98 94 90 85バイト

q=init.tail
s '/'='\\'
s _='/'
t#""=t++"\\\n"
t#l=(' ':t)#(s<$>q l)++t++l#""
("/"#).q

使用例（注：Haskellでは、リテラル文字列内のバックスラッシュはエスケープする必要があります\\）：

*Main> putStr $ (("/"#).q) "//\\\\///\\/\\"
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

単純な再帰アプローチ：#マッピングによって作業sを行います。これは、内部要素の/and を反転し\ます。追加のパラメーターtは、インデントレベルを追跡し、再帰呼び出しごとにスペースで拡張されます。

注：の第二の再帰呼び出し#（ - > l#""）がベースケースに直接ジャンプし、追加するだけの短い道でl、\改行、すなわち、それは置き換えられます++l++"\\\n"。

編集：@xnorは5バイトを保存しました。ありがとう！

Python 3、 108104101 94 91 89 88バイト

b,f='\/';p=lambda t,n='\n':(t[2:]and p(f+''.join(map({f:b,b:f}.get,t[2:-2]))+b,n+' '))+n+t

-7（私たちは印刷する必要はありません知らせる！）XNORのおかげで、バイト
-3 XNORのおかげバイト（関数宣言の宣言の外を取る[D'OH]）
-1バイトデニスのおかげで（置き換えf,b='/\\'てb,f='\/'）

ideoneでテストします。注：二重のバックスラッシュ用に調整された入力（生の文字列でも奇数のバックスラッシュで終わる場合は機能しません）。

JavaScript（ES6）、91 86バイト

f=
(s,t=`
`)=>s[2]?f(`/${s.slice(2,-2).replace(/./g,c=>c>`/`?`/`:`\\`)}\\`,t+` `)+t+s:t+s
;

<input placeholder=Basis oninput=o.textContent=f(this.value)><pre id=o>

出力には、先頭の改行文字が含まれます。

ルビー、80バイト

f=->s{s[-3]>?!&&f[" "+s.gsub(/^( *\/).|.(.$)?/){$1||$2||($&>?/??/:?\\)}]
puts s}

非ゴルフ

f = ->s{
  s[-3] > ?! &&
    f[" " + s.gsub(/^( *\/).|.(.$)?/) {
      $1 || $2 || ($& > ?/ ? ?/ : ?\\)
    }]
  puts s
}

ideoneでご覧ください：http ://ideone.com/HN0l0Y

バッチ、137バイト

@echo off
if %1==/\ goto g
set s=%1
set s=\%s:~2,-2%/
set s=%s:/=-%
set s=%s:\=/%
set s=%s:-=\%
call %0 %s% "%~2 "
:g
echo %~2%1

便利な私の使用%~2及び%1手段は私が上でバイトを費やすことを避けることsetlocal。説明：Batchは空の文字列で置換を実行しないため、「間違った」エッジを持つ次のレイヤーを設定する必要があります。これは、文字列置換の一部として修正されます。

BASH（sed + sort）71 66バイト

sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort   
sed -rne':l;p;y|\\/|1\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

入力は標準入力から行われます。
例：

echo '//\\' |sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

 /\
/\\\

説明：
-n-抑制の自動印刷
:l-と tl最初に分岐バックこの行は以外だった場合/\
p 、この行を印刷する-
y|\\/|1\\|;y|1|/|-置き換える\と1、/で\、その後1で/
th;:h-テストと同じ場所にジャンプし、唯一の次の置換がテストされますので、後に
s|\\.(.*)./| /\1\\|-とそれぞれの側に切りつけ外2を交換{space}/し、\
sort- spaceの前に来て/右の順にので、このプットのすべてを

05AB1E、42 38 36バイト

Dg;<FÐgÍ©£R®ÍN-£„/\‡'/ðN>׫«R'\«}r»

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

説明：

# Read the input to the stack, loop for 0 .. len(input) / 2 - 1
Dg;<F
# Save the layer by pushing a copy on the stack, then push
# len(layer) - 2 to both the top of the stack and register_c
     ÐgÍ©
# a = pop(); b = pop(); push(b[0:a].reverse())
# This removes the last 2 characters and reverses
         £R
# push(register_c - 2 - N)
           ®ÍN-
# a = pop(); b = pop(); push(b[0:a])
# This removes the leading spaces and the first two slashes
               £
# Push "/\" and "\/" to the stack.
                 „/\Â
# Transliterate the slashes
                     ‡
# Add N+1 spaces and a / to the end of the (reversed) current layer
                      '/ðN>׫«
# Reverse the layer and add a \ to the end.
                              R'\«
# End the loop
                                  }
# Reverse the stack and join it with newlines. It is implicitly printed.
                                   r»

（おかげEmignaことを指摘してDD -> ÐとDR -> Â）を。

Go、300 276バイト

package main
import(."regexp";."os")
func p(b string)string{
s:=MustCompile(`((\s*.)(\S*)(\S))`).FindStringSubmatch(b)
if s[3]!=""{r:=""
for _,c:=range s[3][1:len(s[3])-1]{r+=`\/`[c/64:c/46]}
return p(" "+s[2]+r+`\`)+s[1]+"\n"}
return s[1]+"\n"}
func main(){print(p(Args[1]))}

ロングバージョン：

package main

import (
    "regexp"
    "os"
)

func pyramid(base string) string {
    m := regexp.MustCompile(`^((\s*\S)(\S*)(\S))\s*`).FindStringSubmatch(base)
    if len(m[3]) > 0 {
        reversed := ""
        for _, c := range m[3][1:len(m[3]) - 1] {
            if c == '/' {
                reversed += `\`
            } else {
                reversed += `/`
            }
        }
        return pyramid(" " + m[2] + reversed + m[4]) + m[1] + "\n"
    }
    return m[1] + "\n"
}

func main() {
    print(pyramid(os.Args[1]))
}

Perl、53 52バイト

+1を含む -p

STDINの入力で実行します。例えば

./pyramid.pl <<< '//\\///\/\'

pyramid.pl：

#!/usr/bin/perl -p
s%^( *)/.(.*)..%"$1 \\$2/
"=~y|\\/|/\\|r.$&%e&&redo

05AB1E、31バイト

Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»

説明

Dg;G                        }    # for N in [1..len(input)/2-1]
    D                            # make a copy of previous layer
     ðK                          # remove all spaces
       ¦¦¨¨                      # remove first 2 and last 2 chars
           „/\‡                 # replace '/' with '\' and vice versa
                '\«              # add a backslash at the end
                   R             # reverse
                    '/«          # ad a slash at the end
                       ðN׫      # add N spaces
                           R     # reverse back
                             r»  # reverse stack and join on newline
                                 # implicitly print

オンラインで試す

> <> 、186の 179 175 171バイト

0&v &+1&<
  >i:0)?^~&2,:&v
v'/'~v?:-1<  }0<
o    >84*o^-$;?=@:&:&}:~<
\&::&{:@+$}1+[{l1-$-2*:&1+{
>}1-:?!v$:l2%?!vo
^o'/'v?~e  (*5a<
^o'\'< &   >~]a'\'oo{1+:^
  {$1- >:?!^

oooh manこれは間違いなく私の最大の> <>回答です。

まだゴルフをする必要があります（下部はかなり無駄です）

オンラインで試す

Powershell、142バイト

function s($s){if($s.Trim()-eq'/\'){return $s}
$n=$s-replace'\\','#'-replace'/','\'-replace'#','/'-replace'\\.(.*)./',' /$1\'
(s($n))+"`n$s"
}

C＃、250バイト

s=>{int j=s.Length/2,i=0;var l=new string[j];l[j-1]=s;while(++i<j){var n=l[j-i].Trim().Substring(1,l[j-i].Trim().Length-2);l[j-i-1]=new string(' ',i)+"/"+n.Replace("/","#").Replace(@"\","/").Replace("#",@"\").Substring(1,n.Length-2)+@"\";}return l;};

間違いなくさらにゴルフをすることができますが、私の脳は死んでしまったので、私はそれを今のところそのままにしておくことにしました。