pengantar

Ini 2600 SM dan orang-orang membangun piramida sekarang. Mereka sudah membuat dasar piramida tetapi tidak tahu bagaimana melanjutkannya. Jadi, mereka memanggil Anda untuk meminta bantuan.

Aturan membuat piramida cukup sederhana. Untuk layer di atas layer sebelumnya, yang perlu Anda lakukan adalah mengikuti panduan langkah demi langkah ini:

1. Potong ujung-ujungnya dari lapisan sebelumnya.

2. Di atas /karakter, harus ada \karakter dan sebaliknya. Ini berlaku untuk setiap karakter kecuali tepi.

3. Karakter paling kiri selalu a /dan karakter paling kanan selalu \.

Mari kita ambil contoh dasar untuk piramida:

//\/\/\\

Kami memotong tepi, meninggalkan:

 /\/\/\

Kami mengubah garis miring ke depan dengan garis miring ke belakang dan sebaliknya:

 \/\/\/

Karakter paling kiri selalu a /dan karakter paling kanan selalu a \, jadi kami mengubahnya:

 //\/\\

Kami menempatkan layer ini pada layer sebelumnya:

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

Kami terus sampai bagian atas tercapai (yang terlihat seperti /\). Jadi, akhirnya kita dapatkan:

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

Ini yang Anda butuhkan untuk output.

Tugas

Diberi dasar piramida (dengan panjang lebih besar dari 3), menghasilkan piramida lengkap. Anda dapat dengan aman berasumsi bahwa karakter paling kiri adalah /dan karakter paling kanan adalah a \. Anda juga dapat mengasumsikan bahwa panjang dasar selalu sama . Penggunaan spasi tambahan diperbolehkan. Penggunaan ruang terdepan juga diperbolehkan, selama piramida tetap di tempatnya. Penggunaan 1 membuntuti dan 1 terkemuka baris diperbolehkan.

Uji kasus

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

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

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

Ini adalah kode-golf , jadi pengiriman dengan jumlah byte paling sedikit menang!

Jelly ,28 26 2524 byte

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

-4 byte terima kasih kepada Dennis

Resep:

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

(sajikan bersama limun, piramida-piramida itu dibuat untuk para pekerja yang haus)

Masak piramida tebas Anda sendiri di TryItOnline , atau coba semua campur sari yang disarankan OP

Retina , 59 56 54 52 byte

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

Cobalah online!

Output sampel

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

Pyth - 27 26 byte

Mengurangi oleh operasi yang diberikan dalam OP sampai berulang, yang merupakan kasus untuk baris kosong.

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

Test Suite .

Python 2, 78 byte

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

Fungsi rekursif yang menghasilkan string. Setiap lapisan piramida ditambahkan ke panggilan rekursif dengan lapisan di atasnya. Awalan p, yang dimulai saat karakter baris baru mendapatkan satu ruang lagi untuk membuat segitiga. Lapisan berikutnya diproduksi dengan menukar garis miring, memotong dua simbol pertama dan terakhir, dan memasukkannya ke dalam garis miring kiri dan kanan.

Python 3 dapat menyimpan byte dengan melakukan *99di translate, karena persyaratan panjang-256 dijatuhkan.

Haskell, 98 94 90 85 byte

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

Contoh penggunaan (catatan: dalam backslash Haskell dalam string literal harus dilepaskan \\):

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

Pendekatan perulangan sederhana: #melakukan pekerjaan dengan memetakan s, yang membalik /dan \, pada elemen dalam. Parameter tambahan tmelacak tingkat indentasi dan diperluas oleh spasi pada setiap panggilan rekursif.

Catatan: panggilan rekursif kedua dari #(-> l#"") melompat langsung ke case dasar dan hanya cara singkat untuk menambahkan l, \dan baris baru, yaitu menggantikan ++l++"\\\n".

Sunting: @xnatau disimpan 5 byte. Terima kasih!

Python 3, 108 104 101 94 91 89 88 byte

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 byte terima kasih kepada xnor (beri tahu saya bahwa kami tidak perlu mencetak!)
-3 byte terima kasih kepada xnor (mengambil deklarasi di luar deklarasi fungsi [d'oh])
-1 byte berkat Dennis (ganti f,b='/\\'dengan b,f='\/')

Uji di ideone . Catatan: input disesuaikan dengan garis miring terbalik ganda (bahkan string mentah tidak akan berfungsi jika berakhir dengan jumlah garis miring terbalik yang aneh).

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>

Keluaran mencakup karakter baris baru terkemuka.

Ruby, 80 byte

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

Tidak disatukan

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

Lihat di ideone: http://ideone.com/HN0l0Y

Batch, 137 byte

@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

Mudah digunakan %~2dan %1berarti saya menghindari harus menghabiskan byte setlocal. Penjelasan: Karena Batch tidak akan melakukan penggantian pada string kosong, kita harus mengatur lapisan berikutnya dengan tepi "salah", yang kemudian akan dikoreksi sebagai bagian dari penggantian string.

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

input berasal dari stdin.
Contoh:

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

 /\
/\\\

Penjelasan:
-n- tekan cetak otomatis
:l- dan tlcabang kembali ke awal jika baris ini adalah sesuatu selain /\
p - cetak baris ini
y|\\/|1\\|;y|1|/|- ganti \dengan 1, /dengan \, dan kemudian 1dengan /
th;:h- tes dan lompati tempat yang sama, sehingga hanya penggantian berikutnya yang diuji. nanti
s|\\.(.*)./| /\1\\|- ganti dua bagian luar yang dipotong pada masing-masing sisi dengan {space}/dan \
sort- spaceada sebelum /jadi ini menempatkan semuanya dalam urutan yang benar

05AB1E, 42 38 36 byte

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

Cobalah online!

Penjelasan:

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

(Terima kasih kepada Emigna karena menunjukkan itu DD -> Ðdan DR -> Â).

Pergi, 300 276 byte

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

Versi panjang:

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 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, mis

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

pyramid.pl:

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

05AB1E , 31 byte

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

Penjelasan

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

Cobalah online

> <> , 186 179 175 171 byte

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 man ini pasti jawaban terbesar saya> <>.

Mungkin masih ada beberapa golf yang harus dilakukan (area bawah cukup boros)

Cobalah online

Powershell, 142 byte

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

C #, 250 byte

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

Pasti bisa bermain golf lebih jauh tetapi otak saya mati sehingga saya memutuskan untuk membiarkannya seperti saat ini.