Giới thiệu

Bây giờ là 2600 trước Công nguyên và mọi người đang xây dựng kim tự tháp. Họ đã tạo ra nền tảng của kim tự tháp nhưng không biết làm thế nào để tiếp tục. Vì vậy, họ gọi bạn để được giúp đỡ.

Các quy tắc làm một kim tự tháp khá đơn giản. Đối với lớp phía trên lớp trước, tất cả những gì bạn cần làm là làm theo hướng dẫn thủ công từng bước này:

1. Cắt các cạnh ra khỏi lớp trước.

2. Phía trên /nhân vật, phải có một \nhân vật và ngược lại. Điều này áp dụng cho mọi nhân vật ngoại trừ các cạnh.

3. Nhân vật ngoài cùng bên trái luôn là một /và nhân vật ngoài cùng bên phải luôn luôn \.

Hãy lấy một ví dụ về một cơ sở cho một kim tự tháp:

//\/\/\\

Chúng tôi cắt các cạnh, để lại:

 /\/\/\

Chúng tôi thay đổi dấu gạch chéo về phía trước với dấu gạch chéo ngược và ngược lại:

 \/\/\/

Ký tự ngoài cùng bên trái luôn là a /và ký tự ngoài cùng bên phải luôn là a \, vì vậy chúng tôi thay đổi:

 //\/\\

Chúng tôi đặt lớp này trên lớp trước:

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

Chúng tôi tiếp tục cho đến khi đạt đến đỉnh (trông giống như /\). Vì vậy, cuối cùng chúng ta nhận được:

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

Đây là những gì bạn cần để đầu ra.

Nhiệm vụ

Dựa trên cơ sở của một kim tự tháp (có chiều dài lớn hơn 3), xuất ra kim tự tháp đầy đủ. Bạn có thể giả định một cách an toàn rằng ký tự ngoài cùng bên trái /và ký tự ngoài cùng bên phải là a \. Bạn cũng có thể giả định rằng độ dài của cơ sở luôn luôn là chẵn . Việc sử dụng dấu cách được cho phép. Việc sử dụng các không gian hàng đầu cũng được cho phép, miễn là kim tự tháp giữ nguyên vị trí. Việc sử dụng 1 trailing và 1 dòng mới hàng đầu được cho phép.

Các trường hợp thử nghiệm

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

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

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

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Thạch ,28 26 2524 byte

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

-4 byte nhờ Dennis

Công thức:

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

(phục vụ với nước chanh, những kim tự tháp làm cho những người lao động khát nước)

Nấu lên kim tự tháp chém của riêng bạn tại TryItOnline hoặc thử tất cả các món ăn được đề xuất của OP

Võng mạc , 59 56 54 52 byte

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

Hãy thử trực tuyến!

Sản lượng mẫu

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

Pyth - 27 26 byte

Giảm bởi hoạt động được đưa ra trong OP cho đến khi nó lặp lại, đó là trường hợp cho dòng trống.

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

Phòng thử nghiệm .

Python 2, 78 byte

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

Hàm đệ quy đưa ra một chuỗi. Mỗi lớp của kim tự tháp được gắn vào cuộc gọi đệ quy với lớp bên trên nó. Tiền tố p, bắt đầu như một ký tự dòng mới có thêm một khoảng trắng để tạo thành hình tam giác. Lớp tiếp theo được tạo ra bằng cách hoán đổi các dấu gạch chéo, cắt hai biểu tượng đầu tiên và cuối cùng, và kẹp nó vào trong một dấu gạch chéo trái và phải.

Python 3 có thể tiết kiệm một byte bằng cách thực hiện *99trong translate, như yêu cầu chiều dài-256 đã bị bỏ.

Haskell, 98 94 90 85 byte

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

Ví dụ sử dụng (lưu ý: trong dấu gạch chéo ngược Haskell trong chuỗi ký tự phải được thoát \\):

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

Phương pháp tiếp cận đơn giản: #thực hiện công việc bằng cách ánh xạ s, lật /và \, trên các phần tử bên trong. Tham số bổ sung ttheo dõi mức độ chỉ định và được mở rộng bằng khoảng trắng trên mỗi cuộc gọi đệ quy.

Lưu ý: các cuộc gọi đệ quy thứ hai của #(-> l#"") nhảy trực tiếp đến trường hợp cơ sở và chỉ là một cách ngắn để thêm l, \và một dòng mới, tức là nó thay thế ++l++"\\\n".

Chỉnh sửa: @xnor lưu 5 byte. Cảm ơn!

Con trăn 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 nhờ xnor (cho tôi biết chúng tôi không phải in!)
-3 byte nhờ xnor (lấy khai báo bên ngoài khai báo hàm [d'oh])
-1 byte nhờ Dennis (thay thế f,b='/\\'bằng b,f='\/')

Kiểm tra nó trên ideone . Lưu ý: đầu vào được điều chỉnh cho dấu gạch chéo kép (ngay cả các chuỗi thô sẽ không hoạt động nếu chúng kết thúc bằng một số dấu gạch chéo ngược lẻ).

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>

Đầu ra bao gồm một nhân vật dòng mới hàng đầu.

Ruby, 80 byte

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

Bị đánh cắp

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

Xem nó trên ideone: http://ideone.com/HN0l0Y

Mẻ, 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

Sử dụng thuận tiện cho tôi %~2và %1có nghĩa là tôi tránh phải tiêu tốn byte setlocal. Giải thích: Vì Batch sẽ không thực hiện thay thế trên chuỗi trống, chúng tôi phải thiết lập lớp tiếp theo với các cạnh "sai", sau đó sẽ được sửa thành một phần của chuỗi thay thế.

BASH (sed + sort) 71 66 byte

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

đầu vào đến từ stdin.
Thí dụ:

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

 /\
/\\\

Giải thích:
-n- in tự động đàn áp
:l- và tlchi nhánh trở lại bắt đầu nếu dòng này là một cái gì đó khác hơn /\
p - in dòng này
y|\\/|1\\|;y|1|/|- thay thế \với 1, /với \, và sau đó 1với /
th;:h- thử nghiệm và nhảy cùng một vị trí, để chỉ những thay tiếp theo được kiểm tra sau này
s|\\.(.*)./| /\1\\|- thay thế hai bên ngoài bị cắt ở mỗi bên bằng {space}/và \
sort- spaceđến trước /để điều này sắp xếp mọi thứ theo đúng thứ tự

05AB1E, 42 38 36 byte

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

Hãy thử trực tuyến!

Giải trình:

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

(Cảm ơn Emigna đã chỉ ra điều đó DD -> Ðvà DR -> Â).

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

Phiên bản dài:

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

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN, vd

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

Giải trình

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

Dùng thử trực tuyến

> <> , 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 người đàn ông này chắc chắn là câu trả lời lớn nhất của tôi> <> chưa.

Có lẽ vẫn còn một số việc phải chơi golf (khu vực phía dưới khá lãng phí)

Dùng thử trực tuyến

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

Chắc chắn có thể bị đánh gôn hơn nữa nhưng não tôi đã chết nên tôi quyết định rời khỏi nó như hiện tại.