시 에르 핀 스키 층

19

시작하여 아래에 선을 추가하여 Sierpinski 삼각형 과 같은 패턴을 /\만들 수 있습니다 ...

  1. 느슨한 가지 /또는 \두 가지로 다시 분할 : /\.
  2. 가지의 충돌은 \/그 아래에 아무것도 없지만 공백으로 죽습니다.

이 규칙들을 반복하면

     /\
    /\/\
   /\  /\
  /\/\/\/\
 /\      /\
/\/\    /\/\
etc...

( ViHart의 영감 )

양의 정수 N을 취하고이 패턴의 첫 번째 N 라인을 stdout에 인쇄하는 프로그램이나 함수를 작성하십시오. 필요한 것보다 앞이나 뒤에 공백이 없습니다.

예를 들어, 입력이 1출력 인 경우

/\

입력이 2출력 인 경우

 /\
/\/\

입력이 8출력 인 경우

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

등등.

가장 적은 바이트를 가진 코드가 이깁니다.

code-golf  fractal  code-golf  math  polynomials  abstract-algebra  code-golf  geometry  3d  popularity-contest  string  code-golf  math  3d  code-golf  javascript  browser  code-golf  random  array-manipulation  code-golf  restricted-source  javascript  set-theory  code-golf  graph-theory  path-finding  decision-problem  code-golf  code-golf  primes  c  code-golf  graphical-output  fractal  fastest-code  simulation  code-golf  sequence  code-golf  graphical-output  code-golf  code-golf  math  binary  rational-numbers  code-golf  number  fibonacci  popularity-contest  code-golf  number  code-golf  game 
— 칼빈의 취미
소스
1
코드 압축을 피하기 위해 "최소 바이트"로 만들 수 있습니까?
— xnor
@xnor 변경됨.
— Calvin 's Hobbies
말 그대로 이것을 게시하려고했습니다. Meanie. : /
— Kaz Wolfe
APL은 어디에 있습니까?
— Joe

답변:

9

GolfScript (42 바이트)

~,-1%1\{' '*\.2base{'  /\\'2/=}%n@.2*^}/;;

온라인 데모

이것은 파스칼의 삼각형과 Sierpinski 삼각형 사이의 잘 알려진 관계를 이용합니다.

— 피터 테일러
소스
6

CJam, 48 46 바이트

li(_S*"/\\":T+\{_N@S+TW%/S2**" /"/"\ "f/:+T*}*

문제의 관측치 1과 2를 기반으로 한 간단한 재귀 접근법.

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

작동 원리

li(         " L := int(input()) - 1            ";
_S*         " A := L * ' '                     ";
"/\\":T+    " A += (T := '/\')                 ";
\{          " do L times:                      ";
  _N        "   push A, '\n'                   ";
  @S+       "   A += ' '                       ";
  TW%/      "   B := A.split(reverse(T))       ";
  S2**      "   A := '  '.join(B)              ";
  " /"/     "   B := A.split(' /')             ";
  "\ "f/    "   C := { X.split('\ ') : X ∊ B } ";
  :+T*      "   A := T.join(sum(C, []))        ";
}*          "                                  ";

CJam, 51 바이트

li__2mL,1a\{2_@##)1$f*+}/<f{2b_"  /\\"2/f=@@,-S*\N}

나는이 접근법을 더 좋아하지만 재귀 적과 경쟁 할 수는 없습니다. 2mL(최소 O (2 n ) 실행 시간이 발생 함) 을 제거한 후에도 여전히 48 바이트입니다 ...

이 방법은 /\'를 1로 인코딩 하고 그 사이에 공백을 0으로 인코딩 합니다. 결과 배열 이진수를 고려하면, n 번째 행 의 구성 이 다른 Fermat 수 ( 2 2 k +1 형식의 정수)의 곱으로 표현 될 수있는 1보다 큰 n 번째 정수에 해당함을 알 수 있습니다 .

작동 원리

li__2mL,1a         " push L := int(input()), L, R := range(log(L)/log(2)), A := [1] ";
\{2_@##)1$f*+}/    " for I in R: A += { a × 2**(2**I) : a ∊ A }                     ";
<                  " A := A[:L]                                                     ";
f{                 " for I in R: push L, I                                          ";
  2b_"  /\\"2/     "   push (B := base(I, 2)), B, S := [ '  ' '/\' ]                ";
  f=               "   for J in I: J := S[J]                                        ";
  @@,-S*\N         "   push (L - len(B)) * ' ', J, '\n'                             ";
}                  "                                                                ";
— 데니스
소스
5

파이썬 2 - 140 139 127 122 121 118 116

N=input()
b,V,m,n=' V/\\'
s=b*~-N+m+n
R=str.replace
while N:print s;N-=1;s=R(R(R(R(s+b,b+m,V),n+b,V),n+m,b+b),V,m+n)

임시 문자열 대체 ( /programming//a/8687380/3419103 )를 기반으로합니다 .

  1. / > V
  2. \ > V
  3. \/> __(2 칸)
  4. V > /\
— 팔코
소스
b*(N-1)+m+n수b*~-N+m+n
— FryAmTheEggman
@FryAmTheEggman : 굉장합니다! 이제 JavaScript를 받았습니다. ;)
— Falko
4

자바 스크립트-117 바이트

축소 :

T=n=>{S=' '.repeat(n-1);a='/\\';for(t=s=S+a+S;--n;t+='\n'+s)s=s.replace(/\\\//g,'  ').replace(/ \/|\\ /g,a);return t}

넓히는:

T = n => {
    S = ' '.repeat( n-1 );
    a = '/\\';
    for( t = s = S + a + S; --n; t += '\n' + s )
        s = s.replace( /\\\//g, '  ' ).replace( / \/|\\ /g, a );

    return t;
}

샘플 출력 (의 경우 n = 20) :

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

repeat그리고 replace함수 이름 만 그렇게 길지 않았다면. :피

— 코토
소스
3

Pyth, 45 바이트

K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"

예제 실행

$ pyth -c 'K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"' <<< 16
               /\
              /\/\
             /\  /\
            /\/\/\/\
           /\      /\
          /\/\    /\/\
         /\  /\  /\  /\
        /\/\/\/\/\/\/\/\
       /\              /\
      /\/\            /\/\
     /\  /\          /\  /\
    /\/\/\/\        /\/\/\/\
   /\      /\      /\      /\
  /\/\    /\/\    /\/\    /\/\
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

작동 원리

                            # Q = eval(input())
K"/\\"                      # K = "/\\"
      Jt+*QdK               # J = (Q * " " + K)[1:]
             VQ             # for N in range(Q):
               pbJ          #     print(J, end="\n")
                            #
=JjK                        #     J = K.join(
    sm                      #         sum(list(map(lambda d:
      cd"\ "                #             d.split("\ "),
            c               #                                                .split(    )
             j*2d           #              " ".join(                        )
                 c   _K     #                                .split(K[::-1])
                  +Jd       #                       (J + " ")
                       " /" #                                                       " /"
                            #     ))))
— 데니스
소스
3

루비, 90

f=->n{a=["/\\".center(2*n)]
2.upto(n){a<<a[-1].gsub("\\/","  ").gsub(/ \/|\\ /,"/\\")}
puts a}

설명

  • 입력은 람다에 대한 인수로 간주됩니다. 이 될 것으로 예상됩니다 Integer.
  • 사용 String#center을 만들 String "/\"으로 n - 2양쪽에 공간 및에 넣어 Array( a).
  • 로 대체 된 모든 a요소 및로 또는 대체 된 모든 요소를 마지막 요소에 추가하십시오 .a"\/"" "" /"" \""/\"
  • puts각 요소를 a자체 줄에 인쇄하는 데 사용 합니다 .
— 영국 차
소스
3

하스켈 128 112

g n=unlines$take n$i t([1..n]>>" ")%(i(\l->l++l%i(t.t)(t l>>"  ")%l)["/\\"]!!n)
t=tail
(%)=zipWith(++)
i=iterate
— 자랑스런 하스 켈러
소스
내가 문자를 import Data.Listunlines
— 세면
@Flonk unlines는 전주곡에 있습니다.
— 자랑스러운 haskeller
죄송합니다. 댓글을 달기 전에 찾아 보셨을 것입니다. 내 잘못이야!
— Flonk
2

자바 스크립트 (E6) 107 106

편집 : 고정 바이트 수, 재귀 적.

다른 JS 답변과 크게 다르지 않습니다 ... 적어도 하나는 요청에 따라 패턴을 '인쇄'합니다. 핵심은 각각의 새 줄에서 '/' '\'를 '/ \'로 바꾸고 나머지는 모두 ''로 바꿉니다.

F=(n,o=t='/\\',b=' ')=>
  n--&&
    console.log(b.repeat(n)+o)|
    F(n,(b+o+b).replace(/../g,s=>s==b+b|s=='\\/'?b+b:t))

FireFox / FireBug 콘솔에서 테스트

F(15)

산출

                  /\
                 /\/\
                /\  /\
               /\/\/\/\
              /\      /\
             /\/\    /\/\
            /\  /\  /\  /\
           /\/\/\/\/\/\/\/\
          /\              /\
         /\/\            /\/\
        /\  /\          /\  /\
       /\/\/\/\        /\/\/\/\
      /\      /\      /\      /\
     /\/\    /\/\    /\/\    /\/\
    /\  /\  /\  /\  /\  /\  /\  /\
— edc65
소스
2

Perl 5-56 바이트

\ 0은 실제 널 바이트 문자로 대체 될 수 있습니다.

#!/usr/bin/perl -l
$p="/\\";$_=$"x~$_.$p,y/\0/ /,print,$p^="\0\0$p"for-<>..-1

선행 공백을 무시하고 '/ \'를 1로, ''를 0으로 나타내는 경우 주어진 행의 패턴 f (n) = f (n-1) ^ (f (n-1) < <1). 그러나 위 코드의 계산은 perl의 비트 단위 문자열 조작으로 인해 예상 출력에 가까운 문자열 (앞 공백이없고 다른 공백이 널 바이트로 대체 됨)에 대해 실행됩니다.

$p="/\\";          # initialize
  $_=$"x~$_.$p,    # loop start, add spaces
  y/\0/ /,         # replace nulls with spaces
  print,           # output
  $p^="\0\0$p"     # calculate next string
for-<>..-1         # loop from -n to -1
— nutki
소스
1

파이썬 2, 84 바이트

n=i=input()
while i:print' '*i+''.join("/ \ "[j&i+1>0::2]for j in range(n-i+1));i-=1
— xnor
소스
0

람다과 자바 스크립트, 141 128

141

f=n=>{for(a="25",q=0;++q<n;a=a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25));return a[r](/./g,x=>"  /  \\"[x])}

128

f=n=>(t=a=>--n?t(a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25)):a)("25")[r](/./g,x=>"  /  \\"[x])

Firefox에서 테스트 가능 (n = 16) :

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
— 쿼티
소스
0

파이썬 2, 97 바이트

i=input()
x=1
while i:i-=1;print " "*i+bin(x)[2:].replace("0","  ").replace("1", "/\\");x^=2*x
— 보 크니 악
소스
프로그래밍 퍼즐 및 코드 골프에 오신 것을 환영합니다! 좋은 답변 : D
— cat
0

수학, 86 바이트

Column[Row/@Mod[Table[Binomial[n,k],{n,0,#-1},{k,0,n}],2]/.{1->"/\\",0->"  "},Center]&
— J42161217
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.