introduction

C'est 2600 avant JC et les gens construisent des pyramides maintenant. Ils ont déjà fait la base de la pyramide mais ne savent pas comment continuer. Alors, ils t'ont appelé pour de l'aide.

Les règles de fabrication d'une pyramide sont assez simples. Pour le calque au-dessus du calque précédent, il vous suffit de suivre ce guide manuel étape par étape:

1. Coupez les bords du calque précédent.

2. Au-dessus du /personnage, il doit y avoir un \personnage et vice versa. Cela s'applique à tous les caractères à l' exception des bords.

3. Le caractère le plus à gauche est toujours un /et le caractère le plus à droite est toujours \.

Prenons un exemple de base pour une pyramide:

//\/\/\\

Nous coupons les bords, laissant:

 /\/\/\

Nous changeons les barres obliques avec des barres obliques inverses et vice versa:

 \/\/\/

Le caractère le plus à gauche est toujours un /et le caractère le plus à droite est toujours un \, nous changeons donc cela:

 //\/\\

Nous plaçons cette couche sur la couche précédente:

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

Nous continuons jusqu'à ce que le sommet soit atteint (ce qui ressemble /\). Donc, finalement, nous obtenons:

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

C'est ce dont vous avez besoin pour sortir.

La tâche

Étant donné la base d'une pyramide (d'une longueur supérieure à 3), sortez la pyramide complète. Vous pouvez sans risque supposer que le caractère le plus à gauche est /et le caractère le plus à droite est a \. Vous pouvez également supposer que la longueur de la base est toujours égale . L'utilisation d' espaces de fin est autorisée. L'utilisation d' espaces de tête est également autorisée, tant que la pyramide reste en place. L'utilisation de 1 arrière et 1 grands sauts de ligne est autorisée.

Cas de test

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

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

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée ,28 26 2524 octets

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

-4 octets grâce à Dennis

Recette:

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

(servir avec de la limonade, ces pyramides font pour les travailleurs assoiffés)

Cuisinez votre propre pyramide slash sur TryItOnline , ou essayez tous les dégustateurs suggérés par l' OP

Rétine , 59 56 54 52 octets

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

Essayez-le en ligne!

Exemple de sortie

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

Pyth - 27 26 octets

Réduit de l'opération donnée dans l'OP jusqu'à ce qu'il se répète, ce qui est le cas pour la ligne vierge.

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

Suite de tests .

Python 2, 78 octets

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

Une fonction récursive qui génère une chaîne. Chaque couche de la pyramide est ajoutée à l'appel récursif avec la couche au-dessus. Le préfixep , qui commence comme un caractère de nouvelle ligne gagne un espace de plus pour faire le triangle. Le calque suivant est produit en échangeant des barres obliques, en coupant les deux premier et dernier symboles et en le plaçant dans une barre oblique gauche et droite.

Python 3 peut enregistrer un octet en faisant *99dans translate, comme l'exigence de longueur 256 a été supprimée.

Haskell, 98 94 90 85 octets

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

Exemple d'utilisation (remarque: dans les barres obliques inversées Haskell, les chaînes littérales doivent être échappées \\):

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

Approche récurrente simple: #fait le travail en cartographiant s, ce qui inverse le /et \, sur les éléments internes. Le paramètre supplémentaire tgarde une trace du niveau d'indentation et est développé par un espace sur chaque appel récursif.

Remarque: le deuxième appel récursif de #(-> l#"") saute directement au cas de base et n'est qu'un court moyen d'ajouter l,\ et une nouvelle ligne, c'est-à-dire qu'elle remplace ++l++"\\\n".

Modifier: @xnor a enregistré 5 octets. Merci!

Python 3, 108 104 101 94 91 89 88 octets

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 octets grâce à xnor (me faisant savoir que nous n'avons pas besoin d'imprimer!)
-3 octets grâce à xnor (prise de déclaration en dehors de la déclaration de fonction [d'oh])
-1 octet grâce à Dennis (remplacer f,b='/\\'par b,f='\/')

Testez-le sur ideone . Remarque: entrée ajustée pour la double barre oblique inverse (même les chaînes brutes ne fonctionneront pas si elles se terminent par un nombre impair de barres obliques inverses).

JavaScript (ES6), 91 86 octets

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>

La sortie comprend un caractère de nouvelle ligne de tête.

Ruby, 80 octets

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

Non golfé

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

Voir sur ideone: http://ideone.com/HN0l0Y

Lot, 137 octets

@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

Idéalement, mon utilisation de %~2et %1signifie que j'évite d'avoir à dépenser des octets setlocal. Explication: Étant donné que Batch n'effectuera pas de remplacements sur la chaîne vide, nous devons configurer le calque suivant avec les «mauvais» bords, qui seront ensuite corrigés dans le cadre des remplacements de chaînes.

BASH (sed + sort) 71 66 octets

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

l'entrée vient de stdin.
Exemple:

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

 /\
/\\\

Explication:
-n- supprimer l'impression automatique
:l- et tlramener au début si cette ligne était autre chose que /\
p - imprimer cette ligne
y|\\/|1\\|;y|1|/|- remplacer \par 1, /avec \, puis 1avec /
th;:h- tester et sauter au même endroit, de sorte que seule la substitution suivante soit testée plus tard
s|\\.(.*)./| /\1\\|- remplacer les deux côtés coupés de chaque côté par {space}/et \
sort-space vient avant /, cela met donc tout dans le bon ordre

05AB1E, 42 38 36 octets

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

Essayez-le en ligne!

Explication:

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

(Merci à Emigna de l' avoir signalé DD -> Ðet DR -> Â).

Go, 300 276 octets

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

Version longue:

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 octets

Comprend +1 pour -p

Exécuter avec l'entrée sur STDIN, par exemple

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

pyramid.pl:

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

05AB1E , 31 octets

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

Explication

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

Essayez-le en ligne

> <> , 186 179 175 171 octets

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 mec c'est certainement ma plus grande réponse> <> pour le moment.

Il y a probablement encore du golf à faire (la zone inférieure est assez inutile)

Essayez-le en ligne

Powershell, 142 octets

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

C #, 250 octets

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

Peut certainement être joué plus loin mais mon cerveau est mort alors j'ai décidé de le laisser tel quel pour le moment.