Введение

Это 2600 до н.э., и люди строят пирамиды сейчас. Они уже составили основу пирамиды, но не знают, как продолжить. Итак, они звали вас на помощь.

Правила изготовления пирамиды довольно просты. Для слоя выше предыдущего слоя все, что вам нужно сделать, это следовать этому пошаговому руководству:

1. Отрежьте края от предыдущего слоя.

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

3. Крайний левый символ - всегда, /а самый правый - всегда \.

Давайте возьмем пример основы для пирамиды:

//\/\/\\

Отрезаем края, оставляя:

 /\/\/\

Мы меняем прямую и обратную косую черту и наоборот:

 \/\/\/

Крайний левый символ - всегда, /а самый правый - всегда \, поэтому мы изменим это:

 //\/\\

Мы размещаем этот слой на предыдущем слое:

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

Продолжаем до тех пор, пока не будет достигнута вершина (похоже /\). Итак, в итоге мы получаем:

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

Это то, что вам нужно для вывода.

Задание

Учитывая основание пирамиды (длиной более 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 или попробуйте все рекомендуемые дегустаторы ОП.

Retina , 59 56 54 52 байта

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

Попробуйте онлайн!

Образец вывода

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

Pyth - 27 26 байт

Сокращается на операцию, заданную в OP, до тех пор, пока она не повторится, что имеет место для пустой строки.

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 байтов. Благодарность!

Python 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 байт благодаря Деннису (замените 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}

Ungolfed

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 не будет выполнять замены пустой строки, мы должны установить следующий слой с «неправильными» ребрами, которые затем будут исправлены как часть замены строки.

BASH (sed + sort) 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

вход поступает от стандартного ввода.
Пример:

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- test и перейти в то же место, чтобы проверялась только следующая замена позже
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 -> Â).

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

оооооооо, это определенно мой самый большой ответ.

Там, вероятно, еще предстоит поиграть в гольф (нижняя часть довольно расточительна)

Попробуйте онлайн

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

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