Introdução

É 2600 aC e as pessoas estão construindo pirâmides agora. Eles já fizeram a base da pirâmide, mas não sabem como continuar. Então, eles te pediram ajuda.

As regras para fazer uma pirâmide são bastante simples. Para a camada acima da camada anterior, basta seguir este guia passo a passo:

1. Corte as bordas da camada anterior.

2. Acima do /personagem, deve haver um \personagem e vice-versa. Isso se aplica a todos os caracteres, exceto as arestas.

3. O caractere mais à esquerda é sempre um /e o caractere mais à direita é sempre \.

Vamos dar um exemplo de base para uma pirâmide:

//\/\/\\

Cortamos as bordas, deixando:

 /\/\/\

Alteramos as barras para frente com barras para trás e vice-versa:

 \/\/\/

O caractere mais à esquerda é sempre um /e o caractere mais à direita é sempre um \, então alteramos isso:

 //\/\\

Colocamos essa camada na camada anterior:

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

Continuamos até o topo (que parece /\). Então, eventualmente, obtemos:

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

É isso que você precisa produzir.

A tarefa

Dada a base de uma pirâmide (com um comprimento maior que 3), produza a pirâmide completa. Você pode assumir com segurança que o caractere mais à esquerda é /e o caractere mais à direita é a \. Você também pode assumir que o comprimento da base é sempre uniforme . É permitido o uso de espaços à direita . O uso de espaços à esquerda também é permitido, desde que a pirâmide permaneça no lugar. A utilização de 1 à direita e 1 principais é permitido novas linhas.

Casos de teste

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

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

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

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Gelatina ,28 26 2524 bytes

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

-4 bytes graças a Dennis

Receita:

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

(sirva com limonada, essas pirâmides produzem trabalhadores com sede)

Crie sua própria pirâmide de barra no TryItOnline ou experimente todos os provadores sugeridos pelo OP

Retina , 59 56 54 52 bytes

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

Experimente online!

Saída de amostra

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

Pitão - 27 26 bytes

Reduz pela operação fornecida no OP até repetir, como é o caso da linha em branco.

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

Conjunto de Teste .

Python 2, 78 bytes

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

Uma função recursiva que gera uma string. Cada camada da pirâmide é anexada à chamada recursiva com a camada acima dela. O prefixop , que começa como um caractere de nova linha, ganha mais um espaço para formar o triângulo. A próxima camada é produzida trocando barras, cortando o primeiro e o último dois símbolos e colocando-a dentro de uma barra esquerda e direita.

O Python 3 pode salvar um byte, fazendo *99o translate, como o requisito length-256 foi descartado.

Haskell, 98 94 90 85 bytes

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

Exemplo de uso (nota: em barras invertidas Haskell dentro de cadeias literais devem ser escapadas \\):

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

Abordagem simples de recursão: #faz o trabalho mapeando s, que inverte o /e \, nos elementos internos. O parâmetro adicional tcontrola o nível de indução e é expandido por um espaço em cada chamada recursiva.

Nota: a segunda chamada recursiva de #(-> l#"") vai diretamente para o caso base e é apenas uma maneira curta para adicionar l, \e uma nova linha, ou seja, ele substitui ++l++"\\\n".

Edit: @xnor salvou 5 bytes. Obrigado!

Python 3, 108 104 101 94 91 89 88 bytes

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 bytes graças ao xnor (informando que não precisamos imprimir!)
-3 bytes graças ao xnor (tirando a declaração fora da declaração da função [d'oh])
-1 byte graças ao Dennis (substitua f,b='/\\'por b,f='\/')

Teste em ideone . Nota: entrada ajustada para barra invertida dupla (mesmo as strings brutas não funcionarão se elas terminarem em um número ímpar de barras invertidas).

JavaScript (ES6), 91 86 bytes

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>

A saída inclui um caractere principal de nova linha.

Ruby, 80 bytes

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

Ungolfed

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

Veja no ideone: http://ideone.com/HN0l0Y

Lote, 137 bytes

@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

Convenientemente meu uso %~2e %1significa que evito ter que gastar bytes setlocal. Explicação: Como o Lote não executará substituições na sequência vazia, precisamos configurar a próxima camada com as arestas "erradas", que serão corrigidas como parte das substituições da sequência.

BASH (sed + sort) 71 66 bytes

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

entrada vem de stdin.
Exemplo:

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

 /\
/\\\

Explicação:
-n- suprima a impressão automática
:l- e tlramifique de volta ao início se essa linha não for /\
p - imprima esta linha
y|\\/|1\\|;y|1|/|- substitua \por 1, /por \e depois 1por /
th;:h- teste e pule no mesmo lugar, para que apenas a próxima substituição seja testada depois
s|\\.(.*)./| /\1\\|- substitua as duas por fora cortadas de cada lado por {space}/e \
sort- spacevem antes, /para colocar tudo na ordem certa

05AB1E, 42 38 36 bytes

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

Experimente online!

Explicação:

# 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»

(Obrigado a Emigna por apontar isso DD -> Ðe DR -> Â).

Go, 300 276 bytes

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

Versão longa:

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 bytes

Inclui +1 para -p

Corra com a entrada no STDIN, por exemplo

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

pyramid.pl:

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

05AB1E , 31 bytes

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

Explicação

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

Experimente online

> <> , 186 179 175 171 bytes

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 cara, essa é definitivamente a minha maior> <> resposta ainda.

Provavelmente ainda há algum golfe a ser feito (a área inferior é um grande desperdício)

Experimente online

Powershell, 142 bytes

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

C #, 250 bytes

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

Definitivamente posso jogar mais, mas meu cérebro ficou morto, então decidi deixá-lo como está no momento.