Sierpinsky Triangle 은 삼각형을 가져와 높이와 너비를 1/2로 줄이고 결과 삼각형의 사본 3 개를 만들어 각 삼각형이 모퉁이의 다른 두 개에 닿도록 배치 한 프랙탈입니다. 이 과정은 아래 그림과 같이 결과 삼각형으로 반복해서 반복되어 Sierpinski 삼각형을 생성합니다.

Sierpinski 삼각형을 생성하는 프로그램을 작성하십시오. 실제 삼각형을 그리거나 임의 알고리즘을 사용하여 패턴을 생성하려는 방법을 사용하여 그림을 생성 할 수 있습니다. 출력이 위에 표시된 마지막 그림과 비슷해 보이는 한 픽셀, 아스키 아트 또는 원하는 것으로 그릴 수 있습니다. 가장 적은 캐릭터가 승리합니다.

HTML + JavaScript, 150 자 (126 자 참고 사항 참조)

가독성을 위해 공백이 삽입되고 계산되지 않습니다.

<title></title><canvas></canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

그것의 핵심은 x & y == 0조건부 x&y||에서“Sierpinski right triangle”을 생성하는 픽셀을 색칠하는 규칙을 적용하는 것입니다 . 그리고 x-~y/2,k-y되는 대략 정삼각형 디스플레이를 생산하는 좌표 변환.

덜 올바른 (HTML 방식) 버전은 126 자입니다.

<canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

(정확하지 않은 방법은 title요소와 요소의 끝 태그를 생략하는 것 입니다. canvas요소를 생략해도 문서의 해석 이 변경되지 않더라도 올바른 문서에 필요 합니다.)

더 작은 결과의 비용으로 k상수를 선호하여 3 개의 문자를 절약 할 수 있습니다 64. 8세부 정보가 충분 하지 않으므로 옵션을 계산하지 않습니다 .

크기가 256 이상 <canvas>이면 캔버스 크기를 기본값에서 늘리 려면 속성이 필요합니다 .

GolfScript ( 43 42 문자)

' /\ /__\ '4/){.+\.{[2$.]*}%\{.+}%+\}3*;n*

산출:

               /\               
              /__\              
             /\  /\             
            /__\/__\            
           /\      /\           
          /__\    /__\          
         /\  /\  /\  /\         
        /__\/__\/__\/__\        
       /\              /\       
      /__\            /__\      
     /\  /\          /\  /\     
    /__\/__\        /__\/__\    
   /\      /\      /\      /\   
  /__\    /__\    /__\    /__\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/__\/__\/__\/__\/__\/__\/__\/__\

더 큰 삼각형의 경우 "3"을 더 큰 숫자로 변경하십시오.

파이썬 (234)

최대한의 골프, 작은 이미지 :

#!/usr/bin/env python3
from cairo import*
s=SVGSurface('_',97,84)
g=Context(s)
g.scale(97,84)
def f(w,x,y):
 v=w/2
 if w>.1:f(v,x,y);f(v,x+w/4,y-v);f(v,x+v,y)
 else:g.move_to(x,y);g.line_to(x+v,y-w);g.line_to(x+w,y);g.fill()
f(1,0,1)
s.write_to_png('s.png')

필요합니다 python3-cairo.

멋진 큰 이미지를 얻으려면 239자가 필요했습니다 .

Mathematica-32 자

Nest[Subsuperscript[#,#,#]&,0,5]

Mathematica-37 자

Grid@CellularAutomaton[90,{{1},0},31]

그러면 0과 1의 2D 테이블이 생성되며 여기서 1은 Sierpinski Triangle을 그립니다.

파이썬, 101 86

규칙 90 오토 마톤을 사용합니다.

x=' '*31
x+='.'+x
exec"print x;x=''.join(' .'[x[i-1]!=x[i-62]]for i in range(63));"*32

더 길지만 더 예쁘다.

x=' '*31
x+=u'Δ'+x
exec u"print x;x=''.join(u' Δ'[x[i-1]!=x[i-62]]for i in range(63));"*32

편집 : 문자열을 직접 연주하고 눈에 띄게 긴 슬라이싱을 제거하고 출력을 더 예쁘게했습니다.

산출:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ

제이

,/.(,~,.~)^:6,'o'

삼각형이 기울어 져 있고 많은 공백이 있기 때문에 이상적이지는 않지만 그럼에도 불구하고 흥미 롭습니다.

산출:

o                                                               
oo                                                              
o o                                                             
oooo                                                            
o   o                                                           
oo  oo                                                          
o o o o                                                         
oooooooo                                                        
o       o                                                       
oo      oo                                                      
o o     o o                                                     
oooo    oooo                                                    
o   o   o   o                                                   
oo  oo  oo  oo                                                  
o o o o o o o o                                                 
oooooooooooooooo                                                
o               o                                               
oo              oo                                              
o o             o o                                             
oooo            oooo                                            
o   o           o   o                                           
oo  oo          oo  oo                                          
o o o o         o o o o                                         
oooooooo        oooooooo                                        
o       o       o       o                                       
oo      oo      oo      oo                                      
o o     o o     o o     o o                                     
oooo    oooo    oooo    oooo                                    
o   o   o   o   o   o   o   o                                   
oo  oo  oo  oo  oo  oo  oo  oo                                  
o o o o o o o o o o o o o o o o                                 
oooooooooooooooooooooooooooooooo                                
o                               o                               
oo                              oo                              
o o                             o o                             
oooo                            oooo                            
o   o                           o   o                           
oo  oo                          oo  oo                          
o o o o                         o o o o                         
oooooooo                        oooooooo                        
o       o                       o       o                       
oo      oo                      oo      oo                      
o o     o o                     o o     o o                     
oooo    oooo                    oooo    oooo                    
o   o   o   o                   o   o   o   o                   
oo  oo  oo  oo                  oo  oo  oo  oo                  
o o o o o o o o                 o o o o o o o o                 
oooooooooooooooo                oooooooooooooooo                
o               o               o               o               
oo              oo              oo              oo              
o o             o o             o o             o o             
oooo            oooo            oooo            oooo            
o   o           o   o           o   o           o   o           
oo  oo          oo  oo          oo  oo          oo  oo          
o o o o         o o o o         o o o o         o o o o         
oooooooo        oooooooo        oooooooo        oooooooo        
o       o       o       o       o       o       o       o       
oo      oo      oo      oo      oo      oo      oo      oo      
o o     o o     o o     o o     o o     o o     o o     o o     
oooo    oooo    oooo    oooo    oooo    oooo    oooo    oooo    
o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   
oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o 
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

빠른 설명 :

동사 (,~,.~)는 여기서 일하는 것입니다. 먼저 인수를 자체 ( -> )에 연결 한 다음 원래 인수를 출력에 추가 하는 후크 입니다 .,.ooo

oo

된다

oo
o

이 동사는 ^:6각 반복의 출력이 다음 반복의 입력이되도록 6 번 반복됩니다. 그래서

oo
o

된다

oooo
o o
oo
o

차례로

oooooooo
o o o o 
oo  oo
o   o
oooo
o o
oo
o

그런 다음 추가시 경사 부사를 사용 ,/.하여 삼각형을 똑 바르게하기 위해 대각선으로 행을 읽었습니다. randomra가 지적했듯이 나는 이것을 할 필요가 없었 습니다. 나는 |.같은 결과를 얻기 위해 많은 것을 뒤집을 수 있었다 . 더 좋은 방법은, (,,.~)^:6,'o'역 단계를 완전히 저장하는 데 사용했을 수도 있습니다 .

아 잘, 당신은 살고 배우고 있습니다. :-)

APL (51)

      A←67⍴0⋄A[34]←1⋄' ○'[1+32 67⍴{~⊃⍵:⍵,∇(1⌽⍵)≠¯1⌽⍵⋄⍬}A]

설명:

• A←67⍴0: A는 67 개의 0으로 구성된 벡터입니다.
• A[34]←1: 34 번째 요소는 1
• {...}A: A로 시작하여 다음을 수행하십시오.
• ~⊃⍵:: 현재 행의 첫 번째 요소가 0 인 경우
• ⍵,∇: 현재 행을 답변에 추가하고 다음과 같이 반복하십시오.
• (1⌽⍵)≠¯1⌽⍵: 각 요소가 이전 세대의 이웃 XOR 인 벡터
• ⋄⍬그렇지 않으면 우리는 끝났어
• 32 67⍴: 67x32 행렬로 형식화
• 1+: 문자 배열에서 올바른 값을 선택하려면 하나를 추가하십시오.
• ' ○'[... ]: 공백 (삼각형의 일부가 아님) 또는 원 (삼각형의 일부인 경우)을 출력합니다.

산출:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○  

하스켈 (291)

나는 골프 하스켈 코드를 잘하지 못한다.

solve n = tri (putStrLn "") [2^n] n
tri m xs 1 =
  do putStrLn (l1 1 xs "/\\" 0)
     putStrLn (l1 1 xs "/__\\" 1)
     m
tri m xs n=tri m' xs (n-1)
  where m'=tri m (concat[[x-o,x+o]|x<-xs]) (n-1)
        o=2^(n-1)
l1 o [] s t=""
l1 o (x:xs) s t=replicate (x-o-t) ' '++s++l1 (x+2+t) xs s t

출력 solve 4은 다음과 같습니다.

               /\
              /__\
             /\  /\
            /__\/__\
           /\      /\
          /__\    /__\
         /\  /\  /\  /\
        /__\/__\/__\/__\
       /\              /\
      /__\            /__\
     /\  /\          /\  /\
    /__\/__\        /__\/__\
   /\      /\      /\      /\
  /__\    /__\    /__\    /__\
 /\  /\  /\  /\  /\  /\  /\  /\
/__\/__\/__\/__\/__\/__\/__\/__\

QBasic 151 자

예를 들어, 다음은 QBasic에서 수행 할 수있는 방법입니다.

SCREEN 9
H=.5
P=300
FOR I=1 TO 9^6
    N=RND
    IF N > 2/3 THEN
        X=H+X*H:Y=Y*H
    ELSEIF N > 1/3 THEN
        X=H^2+X*H:Y=H+Y*H    
    ELSE
        X=X*H:Y=Y*H
    END IF
    PSET(P-X*P,P-Y*P)
NEXT

파이썬 (42)

나는 원래 boothbys 솔루션 (실제로 규칙 18을 사용 하는)에 대한 몇 가지 제안을 게시하고 싶었지만 의견을 말할 만큼 평판이 좋지 않았으므로 다른 답변으로 만들었습니다. 그가 그의 접근 방식을 변경 한 이후, 나는 약간의 설명을 추가했다. 내 제안은 다음과 같습니다.

1. ''대신에 '% d'* 64 % tuple (x)를 사용하십시오.
2. 목록을 감싸지 않고 0으로 이동

다음 코드 (93 자)로 이어질 것입니다.

x=[0]*63
x[31]=1
exec"print'%d'*63%tuple(x);x=[a^b for a,b in zip(x[1:]+[0],[0]+x[:-1])];"*32

그러나 먼저 정수 배열 대신 longint를 사용하고 이진 표현 (75 자)을 인쇄하여 더 최적화했습니다.

x=2**31
exec"print'%d'*63%tuple(1&x>>i for i in range(63));x=x<<1^x>>1;"*32

마지막으로 printf 보간 (42 자)에서 이미 지원되는 8 진 표현을 인쇄하면 다음과 같습니다.

x=8**31
exec"print'%063o'%x;x=x*8^x/8;"*32

그들 모두가 인쇄됩니다 :

000000000000000000000000000000010000000000000000000000000000000
000000000000000000000000000000101000000000000000000000000000000
000000000000000000000000000001000100000000000000000000000000000
000000000000000000000000000010101010000000000000000000000000000
000000000000000000000000000100000001000000000000000000000000000
000000000000000000000000001010000010100000000000000000000000000
000000000000000000000000010001000100010000000000000000000000000
000000000000000000000000101010101010101000000000000000000000000
000000000000000000000001000000000000000100000000000000000000000
000000000000000000000010100000000000001010000000000000000000000
000000000000000000000100010000000000010001000000000000000000000
000000000000000000001010101000000000101010100000000000000000000
000000000000000000010000000100000001000000010000000000000000000
000000000000000000101000001010000010100000101000000000000000000
000000000000000001000100010001000100010001000100000000000000000
000000000000000010101010101010101010101010101010000000000000000
000000000000000100000000000000000000000000000001000000000000000
000000000000001010000000000000000000000000000010100000000000000
000000000000010001000000000000000000000000000100010000000000000
000000000000101010100000000000000000000000001010101000000000000
000000000001000000010000000000000000000000010000000100000000000
000000000010100000101000000000000000000000101000001010000000000
000000000100010001000100000000000000000001000100010001000000000
000000001010101010101010000000000000000010101010101010100000000
000000010000000000000001000000000000000100000000000000010000000
000000101000000000000010100000000000001010000000000000101000000
000001000100000000000100010000000000010001000000000001000100000
000010101010000000001010101000000000101010100000000010101010000
000100000001000000010000000100000001000000010000000100000001000
001010000010100000101000001010000010100000101000001010000010100
010001000100010001000100010001000100010001000100010001000100010
101010101010101010101010101010101010101010101010101010101010101

물론 그래픽 솔루션 (131 자)도 있습니다.

from PIL.Image import*
from struct import*
a=''
x=2**31
exec"a+=pack('>Q',x);x=x*2^x/2;"*32
fromstring('1',(64,32),a).save('s.png')

:디

8086 기계어 코드-30 바이트

참고 : 이것은 내 코드가 아니며 답변으로 받아 들여서는 안됩니다 . 나는 8086 CPU를 에뮬레이트하기 위해 다른 CG 문제 를 해결하면서 이것을 발견했다 . 포함 된 텍스트 파일은 David Stafford에게 크레딧을 주지만 그것이 내가 얻을 수있는 최선입니다.

나는 영리하고 짧기 때문에 이것을 게시하고 있으며, 당신이 그것을보고 싶다고 생각했습니다.

더 작은 공간에 더 많은 명령을 패킹하기 위해 겹치는 opcode를 사용합니다. 놀랍도록 영리합니다. 기계 코드는 다음과 같습니다.

B0 13 CD 10 B3 03 BE A0 A0 8E DE B9 8B 0C 32 28 88 AC C2 FE 4E 75 F5 CD 16 87 C3 CD 10 C3

스트레이트 업 디코드는 다음과 같습니다.

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11

실행시 0x0115에서 점프가 발생하면 이전 명령의 중간으로 바로 0x010C로 점프합니다.

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]

훌륭한! 너희들이 나에게 이것을 공유하지 않기를 바랍니다. 나는 그것이 그 자체로 답이 아니라는 것을 알고 있지만 도전에 관심이 있습니다.

여기 실제로 작동합니다.

C 127 119 116 108 65

이것은 HTML ^ i & j출력의 예쁜 트릭을 사용하여 예쁜 출력을 인쇄하는 데 1 문자가 더 필요합니다 (을 희생하여 실제로 추악한 출력을 얻을 수 있음 a^).

a=32,j;main(i){for(;++i<a;)putchar(a^i&j);++j<a&&main(puts(""));}

그것을 꽤 돌리 (32^i&j)려면 (32|!(i&j))에서 ++i<a로 돌리십시오 ++i<=a. 그러나 외모를 낭비하는 것은 나에게 비 골격으로 보입니다.

추악한 출력 :

 ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
""  ""  ""  ""  ""  ""  ""  ""
"# !"# !"# !"# !"# !"# !"# !"#
  $$$$    $$$$    $$$$    $$$$
 !$%$% ! !$%$% ! !$%$% ! !$%$%
""$$&&  ""$$&&  ""$$&&  ""$$&&
"#$%&' !"#$%&' !"#$%&' !"#$%&'
      ((((((((        ((((((((
 ! ! !()()()() ! ! ! !()()()()
""  ""((**((**  ""  ""((**((**
"# !"#()*+()*+ !"# !"#()*+()*+
  $$$$((((,,,,    $$$$((((,,,,
 !$%$%()(),-,- ! !$%$%()(),-,-
""$$&&((**,,..  ""$$&&((**,,..
"#$%&'()*+,-./ !"#$%&'()*+,-./
              0000000000000000
 ! ! ! ! ! ! !0101010101010101
""  ""  ""  ""0022002200220022
"# !"# !"# !"#0123012301230123
  $$$$    $$$$0000444400004444
 !$%$% ! !$%$%0101454501014545
""$$&&  ""$$&&0022446600224466
"#$%&' !"#$%&'0123456701234567
      ((((((((0000000088888888
 ! ! !()()()()0101010189898989
""  ""((**((**0022002288::88::
"# !"#()*+()*+0123012389:;89:;
  $$$$((((,,,,000044448888<<<<
 !$%$%()(),-,-010145458989<=<=
""$$&&((**,,..0022446688::<<>>
"#$%&'()*+,-./0123456789:;<=>?

나는 실제로 그것이 어떻게 생겼는지 좋아합니다. 그러나 당신이 그것을 예쁘다고 주장하면 네 글자를 도킹 할 수 있습니다. 예쁜 출력 :

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
  !!  !!  !!  !!  !!  !!  !!  !
  !   !   !   !   !   !   !   !
!!    !!!!    !!!!    !!!!    !
!     ! !     ! !     ! !     !
      !!      !!      !!      !
      !       !       !       !
!!!!!!        !!!!!!!!        !
! ! !         ! ! ! !         !
  !!          !!  !!          !
  !           !   !           !
!!            !!!!            !
!             ! !             !
              !!              !
              !               !
!!!!!!!!!!!!!!                !
! ! ! ! ! ! !                 !
  !!  !!  !!                  !
  !   !   !                   !
!!    !!!!                    !
!     ! !                     !
      !!                      !
      !                       !
!!!!!!                        !
! ! !                         !
  !!                          !
  !                           !
!!                            !
!                             !
                              !
                              !

오래된 108 문자, 셀룰러 오토마타 버전을 그대로 둡니다.

j,d[99][99];main(i){d[0][31]=3;for(;i<64;)d[j+1][i]=putchar(32|d[j][i+2]^d[j][i++]);++j<32&&main(puts(""));}

그래서 나는 이것보다 훨씬 짧아 질 것이라고 생각하지 않으므로 코드를 설명 할 것입니다. 몇 가지 유용한 정보가 있으므로이 설명을 그대로 두겠습니다.

j,d[99][99]; // these init as 0
main(i){ //starts at 1 (argc)
  d[0][48]=3; //seed the automata (3 gives us # instead of !)
  for(;i<98;) // print a row
    d[j+1][i]=putchar(32|d[j][i+2]]^d[j][i++]);
    //relies on undefined behavoir. Works on ubuntu with gcc ix864
    //does the automata rule. 32 + (bitwise or can serve as + if you know
    //that (a|b)==(a^b)), putchar returns the char it prints
  ++j<32&&main(puts(""));
  // repeat 32 times
  // puts("") prints a newline and returns 1, which is nice
}

일부 출력

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

80x86 코드 / MSDos-10 바이트

MsDos에 대한 아주 작은 소개를 전문으로하는 sizecoder로서 저는 10 바이트 만 차지하는 프로그램을 만들었습니다.

16 진수로 :

04 13 CD 10 20 E9 B4 0C E2 F6

asm으로 :

X: add al,0x13
int 0x10
and cl,ch
mov ah,0x0C
loop X

내가 코딩 한 첫 번째 버전은 16 바이트 크기의 "Colpinski"였으며 키보드와 마우스로 색상을 변경할 수있는 방식으로 대화식으로 사용되었습니다. 또 다른 크기 조정기 인 "Frag"와 함께 우리는 1 바이트를 13 바이트로 줄였으며 핵심 루틴 만 포함하는 10 바이트 프로그램을 허용했습니다.

사물이 애니메이션 될 때 조금 더 흥미로워 지므로 Zoompinski 64-512 바이트에서 "Zoompinski C64"의 정확한 동작을 모방하려고합니다-이름에서 알 수 있듯이 64 바이트 크기의 MsDos도 마찬가지입니다.

우아함, 색상 및 대칭 (위의 링크 뒤에서 소스 및 실행 파일 사용 가능)을 잃으면 서 31 바이트까지 더 최적화 할 수 있습니다.

원본을 다운로드하고 "Pouet"에 대한 의견

포스트 스크립트, 120 자

-7 -4 moveto
14 0 rlineto
7{true upath dup
2{120 rotate uappend}repeat[2 0 0 2 7 4]concat}repeat
matrix setmatrix
stroke

고스트 스크립트 출력 :

이것은 이미 그려진 것을 재귀 적으로 삼켜 서 그림을 그립니다.

첫 번째 단계는 선을 그리는 것입니다. 선은 사용자 경로로 저장되고 사용자 경로는 매번 120도 회전 한 후 두 번 더 추가됩니다. [2 0 0 2 7 4]concat"회전 지점"을 우리가 이미 가지고있는 삼각형의 복제에 의해 둘러싸 일 다음 큰 흰색 "중심 삼각형"의 중심으로 이동시킵니다. 여기, 1 단계로 돌아갑니다 (회전에 의해 3 배의 업사이드 생성).

반복 횟수는 3 행의 첫 번째 숫자로 제어됩니다.

J (9 자)

쉽게 가장 추악한, 당신은 실제로 출력을보기 위해 곁눈질해야합니다.)

2|!/~i.32

출력을 생성

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

물론 그래픽으로 표시 할 수 있습니다.

load 'viewmat'
viewmat 2|!/~i.32

APL, 37 32 ( 28 23)

직각 삼각형 ( 37 32 자)

({((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 2⍴'/\'

설명

• 1 2⍴'/\': 1 × 2 문자 행렬 만들기 /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: 양쪽에 오른쪽 인수를 공백으로 채워서 두 배 너비의 행렬을 만든 다음 오른쪽에 두 번 오른쪽 인수를 적층합니다.
  예가 /\될 것입니다

 / \ 
/ \ / \

• ⍣⎕: 기능 (사용자 입력) 횟수를 반복합니다.

출력 예

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

기울어 진 삼각형 ( 28 23 자리)

({(⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 1⍴'○'

설명

• 1 1⍴'○': 1 × 1 문자 행렬 만들기 ○
• {(⍵,∊⍵)⍪⍵,⍵}: 오른쪽의 오른쪽 인수를 공백으로 채워 두 배 너비의 행렬을 만든 다음 오른쪽의 인수 자체를 바닥에 두 배로 적층하는 함수입니다.
  예가 ○될 것입니다

○ 
○○

• ⍣⎕: 기능 (사용자 입력) 횟수를 반복합니다.

출력 예

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○

파이썬 (75)

나는 파티에 2 년 늦었지만 아직 아무도이 방법을 사용하지 않았다는 것에 놀랐다.

from pylab import*
x=[[1,1],[1,0]]
for i in'123':x=kron(x,x)
imsave('a',x)

Kronecker 제품 을 사용하여 매트릭스를 여러 개의 사본으로 교체합니다.

x=kron(x,x);x=kron(x,x)3 줄 을 사용하여 3 개의 보이는 레벨이있는 ​​16x16 픽셀 이미지를 얻거나 반복기에 다른 문자를 추가하고 2 ^ 16 x 2 ^ 16 = 4.3 기가 픽셀 이미지와 15 개의 삼각형 레벨로 끝내면 2 개의 문자를 저장할 수 있습니다.

로고, 75 자

첫 번째 함수의 경우 59 자, 두 번째 함수는 첫 번째 함수의 크기 및 깊이 / 반복 횟수로 첫 번째 함수를 호출합니다. 따라서 다음 명령을 사용하여 인터프리터에서 첫 번째 함수를 호출 할 수 있습니다 : e 99 5 또는 출력하려는 ​​크기

to e :s :l
if :l>0[repeat 3[e :s/2 :l-1 fd :s rt 120]]
end
to f
e 99 5
end

MATLAB 56

v=[1;-1;j];plot(filter(1,[1,-.5],v(randi(3,1,1e4))),'.')

J (18 자)

' *'{~(,,.~)^:9 ,1

결과

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************

파이썬 (90 자)

from turtle import*
def l():left(60)
def r():right(60)
def f():forward(1)
def L(n):
 if n:n-=1;R(n);l();L(n);l();R(n)
 else:f()
def R(n):
 if n:n-=1;L(n);r();R(n);r();L(n)
 else:f()
l();L(8)

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

프랙탈 라인 충전 Sierpinsky Triangle 그리기

매스 매 티카 67

ListPlot@NestList[(#+RandomChoice@{{0,0},{2,0},{1,2}})/2&,{0,0},8!]

매스 매 티카 92

Graphics@Polygon@Nest[Join@@(Mean/@#&/@#~Tuples~2~Partition~3&/@#)&,{{{0,0},{2,0},{1,1}}},3]

Mathematica , 29 바이트

Image@Array[BitAnd,{2,2}^9,0]

Sierpinski 사면체는 비슷한 방식으로 그릴 수 있습니다.

Image3D[1-Array[BitXor,{2,2,2}^7,0]]

J , ³⁷ 35 바이트

FrownyFrog 덕분에 -2 바이트

(,.~,~' '&,.^:#)@[&0' /\',:'/__\'"_

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

이것은 피터 테일러의 아스키 아트 버전으로 J로 변환됩니다. 덜 예쁜 버전으로 바이트를 절약 할 수 있지만 왜 그럴까요?

       /\       
      /__\      
     /\  /\     
    /__\/__\    
   /\      /\   
  /__\    /__\  
 /\  /\  /\  /\ 
/__\/__\/__\/__\

Golly의 루아 스크립트 , 54 바이트

g=golly()
g.setrule("W60")
g.setcell(0,0,1)
g.run(512)

Golly는 Lua 및 Python 스크립팅을 지원하는 셀룰러 오토마타 시뮬레이터입니다.

이 스크립트는 규칙을 Wolfram Rule 60으로 설정하고 셀을 (0,0)에서 1로 설정하고 512 단계를 실행합니다.

추신, 205 203

[48(0-1+0+1-0)49(11)43(+)45(-)/s{dup
0 eq{exch{[48{1 0 rlineto}49 1 index
43{240 rotate}45{120 rotate}>>exch
get exec}forall}{exch{load
exch 1 sub s}forall}ifelse 1 add}>>begin
9 9 moveto(0-1-1)9 s fill

문자열을 사용하여 다시 쓰고 재귀는 정확히 같은 수로 끝납니다. 그러나 거시 접근법의 깊이 한계는 극복되었습니다.

편집 : fill 보다 짧습니다 stroke.

들여 쓰기하고 주석을 달았습니다.

%!
[   % begin dictionary
    48(0-1+0+1-0) % 0
    49(11)        % 1
    43(+)         % +
    45(-)         % -
    /s{ % string recursion-level
        dup 0 eq{ % level=0
            exch{  % iterate through string
                [
                    48{1 0 rlineto} % 0
                    49 1 index      % 1 
                    43{240 rotate}  % +
                    45{120 rotate}  % -
                >>exch get exec % interpret turtle command
            }forall
        }{ % level>0
            exch{  % iterate through string
                load exch  % lookup charcode
                1 sub s    % recurse with level-1
            }forall
        }ifelse
        1 add  % return recursion-level+1
    }
>>begin
9 9 moveto(0-1-1)9 s fill % execute and fill

추가 0 setlinewidth하면 이것이 얼마나 깊은 지 더 잘 알 수 있습니다.

APL (Dyalog Classic) , 12 바이트

×.≥∘⍉⍨↑,⍳⎕⍴2

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

점근선, 152 바이트

나는이 사이트에서 점근 적으로 답변을 보지 못했기 때문에 이것을 추가 할 것입니다. 좋은 형식과 일반성을 위해 몇 바이트를 낭비했지만 그와 함께 살 수 있습니다. A, B 및 C를 변경하면 포함 삼각형의 모서리 위치가 변경되지만 생각한 방식으로 변경되지는 않습니다. 불평등의 수를 늘리면 깊이가 증가합니다.

pair A=(0,0),B=(1,0),C=(.5,1);void f(pair p,int d){if(++d<7){p*=2;f(p+A*2,d);f(p+B*2,d);f(p+C*2,d);}else{fill(shift(p/2)*(A--B--C--cycle));}}f((0,0),0);

또는 ungolfed 및 읽을 수

pair A=(0,0), B=(1,0), C=(.5,1);

void f(pair p, int d) {
    if (++d<7) {
        p *= 2;
        f(p+A*2,d);
        f(p+B*2,d);
        f(p+C*2,d);
    } else {
        fill(shift(p/2)*(A--B--C--cycle));
    }
}

f((0,0),0);

asymptote는 다소 C와 유사한 구문을 가진 깔끔한 벡터 그래픽 언어입니다. 다소 기술적 인 다이어그램에 매우 유용합니다. 출력은 물론 기본적으로 벡터 형식 (eps, pdf, svg)으로되어 있지만 기본적으로 imagemagick에서 지원하는 모든 것으로 변환 할 수 있습니다. 산출:

하스켈 , 166154 바이트

(Laikoni 덕분에 12 바이트, (zipWith 및 lambda 대신에 zip 및 목록 이해, 첫 번째 줄을 생성하는 더 좋은 방법))

i#n|let k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]];x=1<$[2..2^n]=mapM(putStrLn.map("M "!!))$take(2^n)$1!(x++0:x)

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

설명:

이 함수 i#n는 반복 단계 2^n후 높이의 ASCII 삼각형을 그립니다 i.

내부적으로 사용되는 인코딩은 빈 위치를로 1, 전체 위치를로 인코딩 0합니다. 따라서, 삼각형의 첫 번째 행과 같이 부호화 [1,1,1..0..1,1,1]와 2^n-1제로 양쪽 것. 이 목록을 만들려면 list로 시작합니다 x=1<$[2..2^n]. 즉 [2..2^n]모든 것이 매핑 된 목록 입니다 1. 그런 다음 전체 목록을 다음과 같이 작성합니다.x++0:x

k!p행 색인 k과 해당 항목이 주어지면 연산자 (아래에 자세한 설명) p가 뒤에 오는 무한 행 목록을 생성합니다 p. 와 그것을 호출 우리 1와 위에서 설명한 시작하는 라인은 전체 삼각형을 얻을 후 첫 번째 촬영합니다 2^n라인. 그런 다음 각 줄을 인쇄 1하여 공백으로 바꾸고 ( 위치 또는에 있는 목록에 액세스하여) 0로 바꿉니다 .M"M "01

연산자 k!p는 다음과 같이 정의됩니다.

k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]]

첫째, 우리는 세 가지 버전의 생성 p: 1:p인 pA가와 1, 앞에 추가를 p자체 및 tail p++[1]모든하지만의 첫 번째 요소 이는 pA를, 1추가는. 그런 다음이 세 가지 목록을 압축 p하여 왼쪽 및 오른쪽 이웃과 의 모든 요소를 ​​효과적으로 제공합니다 (l,m,r). 리스트 이해를 사용하여 새 줄에서 해당 값을 계산합니다.

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))    

이 표현을 이해하려면 고려해야 할 두 가지 기본 사례가 있음을 알아야합니다. 단순히 이전 선을 확장하거나 삼각형의 빈 지점이 시작되는 지점에 있습니다. 첫 번째 경우, 이웃의 반점이 채워지면 반점이 채워집니다. 이것은 다음과 같이 계산할 수 있습니다 m*l*r. 이 세 가지 중 하나가 0이면 새 값은 0입니다. 다른 경우는 조금 까다 롭습니다. 여기서 기본적으로 가장자리 감지가 필요합니다. 다음 표는 가능한 한 8 개의 이웃에 줄 바꿈 결과 값을 제공합니다.

000 001 010 011 100 101 110 111
 1   1   1   0   1   1   0   1

이 테이블을 생성하기위한 간단한 공식은 것 1-m*r*(1-l)-m*l*(1-r)에있는 단순화 m*(2*l*r-l-r)+1. 이제 우리는 line number를 사용하는 두 가지 경우 중에서 선택해야합니다 k. 인 경우 mod k (2^(n-i)) == 0두 번째 경우를 사용해야하고, 그렇지 않은 경우 첫 번째 경우를 사용해야합니다. 0^(mod k(2^n-i))따라서이 용어 0는 첫 번째 경우 1를 사용해야하고 두 번째 경우를 사용해야하는 경우입니다. 결과적으로 사용할 수 있습니다

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i)) 

전체적으로-첫 번째 경우를 사용하면 간단히 얻을 수 m*l*r있지만 두 번째 경우에는 추가 항이 더해져 총합이 m*(2*l*r-l-r)+1됩니다.

C, 106 자

i,j;main(){for(;i<32;j>i/2?puts(""),j=!++i:0)
printf("%*s",j++?4:33-i+i%2*2,i/2&j^j?"":i%2?"/__\\":"/\\");}

( puts("")C에서 줄 바꿈을 출력하는 가장 짧은 방법은 여전히 나를 즐겁게합니다 .)

당신은 대체하여 더 큰 (또는 작은) 가스켓을 만들 수 있습니다 32에서 for당신은 또한 교체 한 바와 같이, 두 개의 큰 (작은) 전원 루프의 시험 33의 중간에 printf()전원의 -이 - 플러스 -와 하나.