Wprowadzenie

Jest 2600 pne i ludzie budują teraz piramidy. Stanowili już podstawę piramidy, ale nie wiedzą, jak kontynuować. Wołali cię o pomoc.

Zasady tworzenia piramidy są dość proste. W przypadku warstwy powyżej poprzedniej warstwy wystarczy postępować zgodnie z poniższym przewodnikiem:

1. Odetnij krawędzie poprzedniej warstwy.

2. Nad /postacią musi znajdować się \postać i na odwrót. Dotyczy to każdego znaku z wyjątkiem krawędzi.

3. Najbardziej wysunięta na lewo postać jest zawsze /a najbardziej na prawo jest zawsze \.

Weźmy przykład podstawy piramidy:

//\/\/\\

Odcinamy krawędzie, pozostawiając:

 /\/\/\

Zmieniamy ukośniki z ukośnikami i odwrotnie:

 \/\/\/

Znakiem najbardziej na lewo jest zawsze /a skrajnym prawym jest zawsze a \, dlatego zmieniamy to:

 //\/\\

Kładziemy tę warstwę na poprzedniej warstwie:

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

Kontynuujemy, aż do osiągnięcia szczytu (który wygląda /\). Ostatecznie otrzymujemy:

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

Właśnie tego potrzebujesz.

Zadanie

Biorąc pod uwagę podstawę piramidy (o długości większej niż 3), wypisz pełną piramidę. Możesz bezpiecznie założyć, że najbardziej wysunięta na lewo postać jest, /a najbardziej na prawo jest to \. Możesz również założyć, że długość podstawy jest zawsze równa . Użycie spacji końcowych jest dozwolone. Dozwolone jest również używanie wiodących miejsc , o ile piramida pozostaje na swoim miejscu. Dozwolone jest użycie 1 końcowej i 1 wiodącej nowej linii.

Przypadki testowe

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

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

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

To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Galaretka ,28 26 2524 bajty

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

-4 bajty dzięki Dennisowi

Przepis:

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

(podawaj z lemoniadą, te piramidy robią dla spragnionych robotników)

Przygotuj swoją własną piramidę cięcia w TryItOnline lub wypróbuj wszystkich sugerowanych degustatorów OP

Retina , 59 56 54 52 bajtów

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

Wypróbuj online!

Próbka wyjściowa

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

Pyth - 27 26 bajtów

Zmniejsza się o operację podaną w OP, dopóki się nie powtórzy, co ma miejsce w przypadku pustej linii.

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

Pakiet testowy .

Python 2, 78 bajtów

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

Funkcja rekurencyjna, która generuje ciąg. Każda warstwa piramidy jest dołączana do rekurencyjnego wezwania z warstwą nad nią. Prefiks p, który zaczyna się od znaku nowej linii, zyskuje jeszcze jedno miejsce na trójkąt. Następna warstwa jest tworzona przez zamianę ukośników, odcięcie pierwszego i ostatniego dwóch symboli i umieszczenie ich w lewym i prawym ukośniku.

Python 3 może zapisać bajt, wykonując *99w translate, ponieważ wymóg długości-256 został usunięty.

Haskell, 98 94 90 85 bajtów

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

Przykład użycia (uwaga: w Haskell odwrotne ukośniki w dosłownym ciągu muszą być poprzedzone znakami \\):

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

Proste podejście rekurencyjne: #działa poprzez mapowanie s, które odwraca /i\ na elementach wewnętrznych. Dodatkowy parametr tśledzi poziom wcięcia i jest powiększany o spację w każdym wywołaniu rekurencyjnym.

Uwaga: drugie wywołanie rekurencyjne #(-> l#"") przeskakuje bezpośrednio do przypadku podstawowego i jest tylko krótkim sposobem na dodanie l,\ i znak nowej linii, czyli zastępuje ++l++"\\\n".

Edycja: @xnor zapisał 5 bajtów. Dzięki!

Python 3, 108 104 101 94 91 89 88 bajtów

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 bajty dzięki XNOR (pozwalając mi znać, że nie mamy do wydrukowania!)
-3 bajty dzięki XNOR (biorąc deklaracji poza deklaracji funkcji [D'oh])
-1 bajt dzięki Dennis (Replace f,b='/\\'z b,f='\/')

Przetestuj na ideonie . Uwaga: dane wejściowe dostosowane do podwójnego ukośnika odwrotnego (nawet ciągi surowe nie będą działać, jeśli zakończą się nieparzystą liczbą odwrotnych ukośników).

JavaScript (ES6), 91 86 bajtów

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>

Wynik zawiera wiodący znak nowej linii.

Rubinowy, 80 bajtów

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

Nie golfił

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

Zobacz na ideone: http://ideone.com/HN0l0Y

Partia, 137 bajtów

@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

Dogodnie moje użycie %~2i %1oznacza, że ​​unikam konieczności wydawania bajtów setlocal. Objaśnienie: Ponieważ Batch nie wykona zamiany pustego łańcucha, musimy ustawić następną warstwę z „złymi” krawędziami, które następnie zostaną poprawione w ramach zamiany łańcucha.

BASH (sed + sort) 71 66 bajtów

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

dane wejściowe pochodzą ze standardowego wejścia.
Przykład:

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

 /\
/\\\

Wyjaśnienie:
-n- wstrzymywanie automatycznego druku
:l- i tloddział z powrotem do początku, jeśli linia ta była czymś innym niż /\
p - wydrukować tę linię
y|\\/|1\\|;y|1|/|- wymienić \z 1, /z \, a następnie 1z /
th;:h- test i skakać na to samo miejsce, tak że dopiero następny podstawienie zostanie przetestowany później
s|\\.(.*)./| /\1\\|- zamień dwa zewnętrzne nacięcia z każdej strony na {space}/i \
sort- spacepojawia się wcześniej, /więc wszystko układa się we właściwej kolejności

05AB1E, 42 38 36 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

(Podziękowania dla Emigny za zwrócenie na to uwagi DD -> Ði DR -> Â).

Idź, 300 276 bajtów

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

Długa wersja:

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 bajty

Obejmuje +1 dla -p

Uruchom z wejściem na STDIN, np

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

pyramid.pl:

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

05AB1E , 31 bajtów

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

Wyjaśnienie

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

Wypróbuj online

> <> , 186 179 175 171 bajtów

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 człowieku, to zdecydowanie moja największa jak dotąd odpowiedź.

Prawdopodobnie zostało jeszcze trochę golfa (dolna część jest dość marnotrawna)

Wypróbuj online

PowerShell, 142 bajty

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

C #, 250 bajtów

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

Zdecydowanie można dalej grać w golfa, ale mój mózg padł, więc postanowiłem go na chwilę zostawić.