Einführung

Es ist 2600 v. Chr. Und die Menschen bauen jetzt Pyramiden. Sie haben bereits die Basis der Pyramide geschaffen, wissen aber nicht, wie sie fortfahren sollen. Also haben sie dich um Hilfe gerufen.

Die Regeln für die Herstellung einer Pyramide sind recht einfach. Für die Ebene über der vorherigen Ebene müssen Sie nur diese Schritt-für-Schritt-Anleitung befolgen:

1. Schneiden Sie die Kanten der vorherigen Ebene ab.

2. Über dem /Zeichen muss sich ein \Zeichen befinden und umgekehrt. Dies gilt für alle Zeichen mit Ausnahme der Kanten.

3. Das Zeichen ganz links ist immer ein /und das Zeichen ganz rechts ist immer ein \.

Nehmen wir ein Beispiel für eine Pyramidenbasis:

//\/\/\\

Wir schneiden die Ränder ab und lassen:

 /\/\/\

Wir ersetzen die Schrägstriche durch umgekehrte Schrägstriche und umgekehrt:

 \/\/\/

Das Zeichen ganz links ist immer ein /und das Zeichen ganz rechts ist immer ein \, also ändern wir das:

 //\/\\

Wir platzieren diese Ebene auf der vorherigen Ebene:

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

Wir fahren weiter, bis der Gipfel erreicht ist (wie es aussieht) /\ ). Also, irgendwann bekommen wir:

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

Dies ist, was Sie ausgeben müssen.

Die Aufgabe

Geben Sie auf der Grundlage einer Pyramide (mit einer Länge von mehr als 3) die vollständige Pyramide aus. Sie können davon ausgehen, dass das Zeichen ganz links /und das Zeichen ganz rechts a ist \. Sie können auch davon ausgehen, dass die Länge der Basis immer gerade ist . Die Verwendung von nachgestellten Leerzeichen ist zulässig. Die Verwendung von führenden Leerzeichen ist ebenfalls zulässig, solange die Pyramide an Ort und Stelle bleibt. Die Verwendung von 1 Trailing und 1 Leading Zeilen ist zulässig.

Testfälle

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

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

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Gelee ,28 26 2524 Bytes

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

-4 Bytes dank Dennis

Rezept:

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

(mit Limonade servieren, diese Pyramiden machen durstige Arbeiter)

Stellen Sie sich bei TryItOnline Ihre eigene Pyramide zusammen oder probieren Sie alle vom OP empfohlenen Verkostungen aus

Retina , 59 56 54 52 Bytes

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

Probieren Sie es online!

Beispielausgabe

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

Pyth - 27 26 Bytes

Reduziert sich um die im OP angegebene Operation, bis sie sich wiederholt, was für die leere Zeile der Fall ist.

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

Test Suite .

Python 2, 78 Bytes

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

Eine rekursive Funktion, die eine Zeichenfolge ausgibt. Jede Ebene der Pyramide wird mit der darüber liegenden Ebene an den rekursiven Aufruf angehängt. Das Präfix p, das als Newline-Zeichen beginnt, erhält ein Leerzeichen mehr, um das Dreieck zu bilden. Die nächste Ebene wird durch Vertauschen der Schrägstriche, Abschneiden der ersten und letzten beiden Symbole und Einfügen in einen linken und rechten Schrägstrich erstellt.

Python 3 können , indem Sie ein Byte speichern *99in der translate, wie die Länge-256 Forderung fallen gelassen wurde.

Haskell, 98 94 90 85 Bytes

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

Anwendungsbeispiel (Hinweis: In Haskell müssen Backslashes innerhalb von Literal-Strings maskiert werden \\):

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

Einfacher Rekursionsansatz: Erledigt #die Arbeit durch Mapping s, bei dem das /und \auf die inneren Elemente gekippt wird . Der zusätzliche Parameter tverfolgt die Einrückungsstufe und wird bei jedem rekursiven Aufruf um ein Leerzeichen erweitert.

Hinweis: Der zweite rekursive Aufruf von #(-> l#"") springt direkt zum Basisfall und ist nur ein kurzer Weg l, \eine neue Zeile hinzuzufügen, dh zu ersetzen ++l++"\\\n".

Edit: @xnor 5 Bytes gespeichert. Vielen Dank!

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 dank xnor (lassen Sie mich wissen, dass wir nicht drucken müssen!)
-3 Bytes dank xnor (Deklaration außerhalb der Funktionsdeklaration [d'oh])
-1 Bytes dank Dennis (Ersetzen)f,b='/\\' durch b,f='\/')

Teste es auf ideone . Hinweis: Die Eingabe wurde für doppelten Backslash angepasst (gerade rohe Zeichenfolgen funktionieren nicht, wenn sie mit einer ungeraden Anzahl von Backslashs enden).

JavaScript (ES6), 91.86 Byte

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>

Die Ausgabe enthält ein führendes Zeilenumbruchzeichen.

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
}

Sehen Sie es auf ideone: http://ideone.com/HN0l0Y

Batch, 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

Praktischerweise bedeutet meine Verwendung von %~2und %1, dass ich keine Bytes ausgeben muss setlocal. Erläuterung: Da Batch keine Ersetzungen für die leere Zeichenfolge vornimmt, müssen wir die nächste Ebene mit den "falschen" Kanten einrichten, die dann im Rahmen der Zeichenfolgenersetzung korrigiert werden.

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

eingabe kommt von stdin.
Beispiel:

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

 /\
/\\\

Erklärung:
-n- Auto-Druck unterdrücken
:l- und tlzurück zum Anfang verzweigen, wenn diese Zeile etwas anderes war als /\
p - diese Zeile drucken
y|\\/|1\\|;y|1|/|- \mit 1, /mit \und dann 1mit /
th;:h- testen und an die gleiche Stelle springen, damit nur die nächste Ersetzung getestet wird später
s|\\.(.*)./| /\1\\|- ersetzen Sie die äußeren zwei Schrägstriche auf jeder Seite durch {space}/und \
sort- spacekommen Sie vor, /damit alles in die richtige Reihenfolge gebracht wird

05AB1E, 42 38 36 Bytes

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

Probieren Sie es online!

Erläuterung:

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

(Danke an Emigna für den Hinweis DD -> Ðund DR -> Â).

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

Lange Version:

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

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN, z

./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»

Erläuterung

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

Probieren Sie es online aus

> <> , 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- >:?!^

Oh Mann, das ist definitiv meine bisher größte> <> Antwort.

Es bleibt wahrscheinlich noch ein bisschen Golf zu spielen (der untere Bereich ist ziemlich verschwenderisch)

Probieren Sie es online aus

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

Kann definitiv weiter golfen werden, aber mein Gehirn ist kaputt gegangen, also habe ich beschlossen, es so zu lassen, wie es momentan ist.