소개

기원전 2600 년이며 사람들은 현재 피라미드를 만들고 있습니다. 그들은 이미 피라미드의 기초를 만들었지 만 계속하는 방법을 모른다. 그래서 그들은 당신에게 도움을 청했습니다.

피라미드를 만드는 규칙은 매우 간단합니다. 이전 레이어 위에있는 레이어의 경우이 단계별 핸드 가이드를 따르기 만하면됩니다.

1. 이전 레이어에서 가장자리를 잘라냅니다.

2. /캐릭터 위에는 캐릭터가 있어야 \하며 그 반대도 마찬가지입니다. 이것은 가장자리를 제외한 모든 문자에 적용됩니다 .

3. 가장 왼쪽 문자는 항상 a /이고 가장 오른쪽 문자는 항상 \입니다.

피라미드의 기초를 예로 들어 보겠습니다.

//\/\/\\

가장자리를 잘라 내고 다음을 남깁니다.

 /\/\/\

슬래시로 슬래시를 변경하고 그 반대도 가능합니다.

 \/\/\/

가장 왼쪽 문자는 항상 a /이고 가장 오른쪽 문자는 항상 a \이므로 다음과 같이 변경합니다.

 //\/\\

이 레이어를 이전 레이어에 배치합니다.

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

상단에 도달 할 때까지 계속됩니다 ( /\). 결국 우리는 다음을 얻습니다.

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

출력해야합니다.

작업

피라미드 (길이가 3보다 큰)의 기초가 주어지면 전체 피라미드를 출력하십시오. 가장 왼쪽 문자는 /이고 가장 오른쪽 문자는 이라고 가정 할 수 있습니다 \. 기준의 길이가 항상 짝수 라고 가정 할 수도 있습니다 . 사용 후미 공간이 허용된다. 피라미드가 제 위치 에있는 한 선행 공간을 사용할 수도 있습니다. (1)의 사용 후행 1 선도하는 줄 바꿈이 허용됩니다.

테스트 사례

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

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

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

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

젤리 ,28 26 2524 바이트

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

Dennis 덕분에 -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 에서 자신의 슬래시 피라미드를 요리 하거나 OP가 제안한 모든 맛보기를 사용해보십시오

망막 , 59 56 54 52 바이트

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

온라인으로 사용해보십시오!

샘플 출력

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

Pyth- 27 26 바이트

반복 될 때까지 OP에 제공된 작업이 줄어 듭니다 (빈 줄의 경우).

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

테스트 스위트 .

파이썬 2, 78 바이트

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

문자열을 출력하는 재귀 함수입니다. 피라미드의 각 레이어는 그 위에있는 레이어와 함께 재귀 호출에 추가됩니다. p개행 문자로 시작 하는 접두어 는 삼각형을 만들 공간을 하나 더 확보합니다. 다음 레이어는 슬래시를 바꾸고 첫 번째와 마지막 두 기호를 잘라 내고 왼쪽과 오른쪽 슬래시 안에 끼워서 만듭니다.

파이썬 3을 수행하여 바이트를 저장할 수 있습니다 *99에 translate길이-256 요구 사항이 삭제되면서.

하스켈, 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) "//\\\\///\\/\\"
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

간단한 같이 Recurse 방법 : #매핑하여 작업 수행 s을 화나게, /그리고 \내부 요소를. 추가 매개 변수 t는 indention 레벨을 추적하고 각 재귀 호출의 공백으로 확장됩니다.

참고 :의 두 번째 재귀 호출 #(-> l#"") 기본 케이스에 직접 뛰어 단지 추가하는 간단한 방법입니다 l, \그리고 줄 바꿈, 그것이 바꾸는 즉 ++l++"\\\n".

편집 : @xnor는 5 바이트를 저장했습니다. 감사!

파이썬 3, 108104101 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 덕분 바이트 (함수 선언의 선언 외부 [오 드] 복용)
-1 데니스에 바이트 덕분에 (교체 f,b='/\\'와 함께 b,f='\/')

ideone에서 테스트하십시오 . 참고 : 이중 백 슬래시로 조정 된 입력 (홀수 문자열이 홀수의 백 슬래시로 끝나도 작동하지 않음)

자바 스크립트 (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. 설명 : 배치가 빈 문자열에서 교체를 수행하지 않기 때문에 "잘못된"모서리를 가진 다음 레이어를 설정해야합니다. 그런 다음 문자열 교체의 일부로 수정됩니다.

배쉬 (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- 테스트와 같은 장소를 이동은 다음 대체가 테스트됩니다 그래서, 나중에
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»

( 그리고 그것을 지적 해 준 Emigna 에게 감사합니다 ).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]))
}

펄, 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 man 이것은 확실히 내 가장 큰> <> 답변입니다.

아직 골프가 남아있을 것입니다 (하단 영역은 꽤 낭비입니다)

온라인으로 사용해보십시오

파워 쉘, 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;};

확실히 더 골프를 칠 수 있지만 뇌가 죽었으므로 나는 그것을 그대로두기로 결정했습니다.