Вступ

Це 2600 р. До н.е., і зараз люди будують піраміди. Вони вже склали основу піраміди, але не знають, як далі. Отже, вони покликали вас на допомогу.

Правила виготовлення піраміди досить прості. Для шару над попереднім шаром все, що вам потрібно зробити, це дотримуватися цього покрокового керівництва від руки:

1. Відріжте краї попереднього шару.

2. Над /персонажем повинен бути \персонаж і навпаки. Це стосується кожного символу, крім ребер.

3. Край лівий символ - це завжди, /а правий крайній - завжди \.

Візьмемо приклад основи для піраміди:

//\/\/\\

Відрізаємо краї, залишаючи:

 /\/\/\

Ми змінюємо косою нахилом вперед і навпаки:

 \/\/\/

Край лівий символ завжди є a, /а правий крайній символ - завжди a \, тому ми змінюємо це:

 //\/\\

Розміщуємо цей шар на попередньому шарі:

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

Ми продовжуємо, поки не буде досягнуто вершини (як виглядає /\). Отже, з часом ми отримуємо:

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

Це те, що потрібно для виведення.

Завдання

Враховуючи основу піраміди (довжиною більше 3), виведіть повну піраміду. Можна сміливо припускати, що крайній лівий символ є, /а правий крайній символ - це \. Можна також припустити, що довжина основи завжди рівна . Дозволено використання проміжних пробілів . Допускається також використання провідних просторів , поки піраміда залишається на місці. Допускається використання 1 кінцевих та 1 провідних нових рядків.

Тестові справи

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

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

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

Це код-гольф , тому подання з найменшою кількістю байтів виграє!

Желе ,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 або спробуйте всіх запропонованих ОП дегустаторів

Сітківка , 59 56 54 52 байт

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

Спробуйте в Інтернеті!

Вибірка зразка

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

Pyth - 27 26 байт

Зменшується за допомогою операції, заданої в ОП, поки вона не повториться, що стосується порожнього рядка.

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, який починається як символ нового рядка, отримує ще один пробіл, щоб зробити трикутник. Наступний шар виробляється шляхом заміни косої риски, відрізання першого та останнього двох символів та зачистки її всередині лівої та правої риски.

Python 3 може зберегти байт, зробивши це *99в translate, оскільки вимога довжина-256 була відхилена.

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, яке перевертає /та \, на внутрішніх елементах. Додатковий параметр tвідстежує рівень відступу і розширюється пробілом у кожному рекурсивному виклику.

Примітка: другий рекурсивний виклик #(-> l#"") переходить безпосередньо до базового нагоди і тільки короткий шлях , щоб додати l, \і символ нового рядка, тобто він замінює ++l++"\\\n".

Редагувати: @xnor зберегло 5 байт. Спасибі!

Пітон 3, 108 104 101 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 байт завдяки Dennis (замінити 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 не виконує заміни на порожній рядку, ми повинні встановити наступний шар із "неправильними" ребрами, який потім буде виправлено як частина заміни рядків.

БАШ (sed + сорт) 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

вхід надходить від stdin.
Приклад:

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\\|- замініть зовнішні два нарізані з кожної сторони на {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»

(Дякую Еміньї, що вказала на це DD -> Ðі DR -> Â).

Ідіть, 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 людина, це, безумовно, моя найбільша відповідь.

Напевно ще залишається зробити щось для гольфу (нижня площа досить марнотратна)

Спробуйте в Інтернеті

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

Однозначно можна пограти в гольф далі, але мій мозок загинув, тому я вирішив залишити його таким, яким він є на даний момент.