Disegna un triangolo Sierpinski


43

Il triangolo Sierpinsky è un frattale creato prendendo un triangolo, diminuendo l'altezza e la larghezza di 1/2, creando 3 copie del triangolo risultante e posizionandole in modo tale che ciascun triangolo tocchi le altre due su un angolo. Questo processo viene ripetuto più volte con i triangoli risultanti per produrre il triangolo Sierpinski, come illustrato di seguito.

inserisci qui la descrizione dell'immagine

Scrivi un programma per generare un triangolo Sierpinski. È possibile utilizzare qualsiasi metodo che si desidera generare il modello, sia disegnando i triangoli effettivi, sia utilizzando un algoritmo casuale per generare l'immagine. Puoi disegnare in pixel, arte ascii o qualsiasi cosa tu voglia, purché l'output sia simile all'ultima immagine mostrata sopra. Vince il minor numero di personaggi.


1
Vedi anche la vecchia versione Stack Overflow: stackoverflow.com/questions/1726698/...
dmckee

3
Ho avuto l'idea per questo dopo aver visto la domanda sul triangolo di Pascal e aver ricordato il programma di esempio per questo nel mio manuale della TI-86. Ho deciso di convertirlo in QBasic e quindi di codificarlo.
Kibbee,

Non vi è alcun problema con l'esecuzione di una sfida qui già eseguita su Stack Overflow, ma molte persone non vorranno presentare di nuovo lo stesso materiale. Quindi li collego per l'edificazione dei visitatori successivi.
dmckee,

Per evitare la duplicazione, forse dovresti cambiare le regole per consentire solo implementazioni grafiche.
primo

Risposte:


41

HTML + JavaScript, 150 caratteri (vedi note per 126 caratteri)

Spazio bianco inserito per leggibilità e non conteggiato.

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

Il suo nucleo sta applicando la regola dei pixel di colorazione per i quali x & y == 0dal condizionale x&y||, che produce un "triangolo rettangolo di Sierpinski"; e x-~y/2,k-ysono una trasformazione coordinata per produrre la visualizzazione approssimativamente equilatera.

inserisci qui la descrizione dell'immagine

Una versione meno corretta (HTML) è di 126 caratteri:

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

(Il modo in cui ciò è meno corretto è che omette l' titleelemento e il tag di fine canvasdell'elemento, entrambi necessari per un documento corretto anche se ometterli non cambia l' interpretazione del documento.)

Tre personaggi possono essere salvati eliminando ka favore della costante 64, a costo di un risultato minore; Non conterei l' 8opzione in quanto ha dettagli insufficienti.

Si noti che una dimensione di 256 o superiore richiede attributi <canvas>per aumentare la dimensione della tela dal valore predefinito.


22
A nessuno importa se il tuo HTML viene convalidato su codegolf :-) Alcuni miglioramenti: <canvas id=c>e poi c.getContext. Accorciare i loop:for(x=k=128;x--;)for(y=k;y--;)
copiare il

4
la trasformazione degli ID in variabili globali è un'orribile disfunzione che mi rifiuto di riconoscere e WebKit non lo implementa in modalità standard. Grazie per il trucco del ciclo.
Kevin Reid,

1
Miglioramento minore: x&y?0:può essere sostituito con una x&y||soluzione altrimenti piacevole.
primo

5
Bravo, questo è semplicemente meraviglioso.
stand

2
Dato che contiene uno script, ti consiglio di intitolarlo come HTML + Javascript . Ciò renderà più chiaro a qualcuno la scrematura che tipo di risposta è.

30

GolfScript ( 43 42 caratteri)

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

Produzione:

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

Cambia "3" in un numero più grande per un triangolo più grande.


27

Python (234)

Massima golf, minuscola immagine:

#!/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')

Richiede python3-cairo.

Per ottenere una bella immagine di grandi dimensioni avevo bisogno di 239 caratteri.

Triangolo di Sierpinski


1
import cairo as cper salvarti alcuni personaggi
quasimodo,

1
questa risposta ha bisogno di più voti
ixtmixilix,

26

Mathematica - 32 caratteri

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

inserisci qui la descrizione dell'immagine

Mathematica - 37 personaggi

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

Questo produrrà una tabella 2D di 0 e 1, in cui 1 disegna il triangolo di Sierpinski.

inserisci qui la descrizione dell'immagine


2
Al costo di 5 caratteri aggiuntivi, la tua seconda soluzione verrà visualizzata meglio con ArrayPlot@CellularAutomaton[90, {{1}, 0}, 31]o MatrixPlot@CellularAutomaton[90, {{1}, 0}, 31].
DavidC,

1
... o con ReliefPlot@...
DavidC

Capisco questo . Come hai ottenuto l'output senza tutte le parentesi?
Mr.Wizard,

@ Mr.Wizard hmm ... da dove vengono le parentesi? Funziona anche qui: mathics.net Prova e fammi sapere.
Vitaliy Kaurov,

1
@Vitaliy Kaurov La soluzione principale (32 caratteri) è sorprendente. Riesci a fare la sfida "albero frattale" (altrove su PCG) usando la stessa tecnica?
Michael Stern,

22

Python, 101 86

Utilizza l'automa della regola 90.

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

Questo è più lungo, ma più bello.

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

Modifica: suonando direttamente con le stringhe, sbarazzandoci di tagli odiosamente lunghi, rendendo l'output più bello.

Produzione:

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

Sembra davvero fantastico: D
beary605

Usare quel Delta U + 0394 è davvero un bel tocco.
David Conrad,

16

J

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

Non è l'ideale, dal momento che il triangolo è sbilenco e seguito da molto spazio bianco - ma comunque interessante ho pensato.

Produzione:

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

Una breve spiegazione:

Il verbo (,~,.~)è ciò che sta facendo il lavoro qui. È un hook che ricama prima ,.l'argomento su se stesso ( o-> oo) e quindi aggiunge l'argomento originale all'output:

oo

diventa

oo
o

Questo verbo viene ripetuto 6 volte ^:6con l'output di ogni iterazione che diventa l'input dell'iterazione successiva. Così

oo
o

diventa

oooo
o o
oo
o

che a sua volta diventa

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

ecc. Ho quindi usato l'avverbio obliquo su append ,/.per leggere le file in diagonale per raddrizzare (ish) il triangolo. Non avevo bisogno di farlo, come sottolinea randomra . Avrei potuto semplicemente invertire |.il lotto per ottenere lo stesso risultato. Ancora meglio, avrei potuto semplicemente usare (,,.~)^:6,'o'per salvare completamente il passaggio inverso.

Ah bene, vivi e impari. :-)


1
Potresti spiegare brevemente come funziona? Non conosco J
aditsu il

1
|.(,~,.~)^:6,'o'è più corto e senza spazi extra. E (,~,.~)^:6,1dà anche un input decente in soli 12 caratteri!
randomra,

@aditsu Ho aggiunto una spiegazione.
Gareth,

Quindi, se lo capisco, quell'operatore concatena due array 2D?
MaiaVictor

13

APL (51)

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

Spiegazione:

  • A←67⍴0: A è un vettore di 67 zeri
  • A[34]←1: il 34 ° elemento è 1
  • {...}A: a partire da A, esegui:
  • ~⊃⍵:: se il primo elemento della riga corrente è zero
  • ⍵,∇: aggiungi la riga corrente alla risposta e ripeti con:
  • (1⌽⍵)≠¯1⌽⍵: il vettore in cui ogni elemento è lo XOR dei suoi vicini nella generazione precedente
  • ⋄⍬: altrimenti, abbiamo finito
  • 32 67⍴: formatta questo in una matrice 67x32
  • 1+: aggiungine uno per selezionare il valore corretto dall'array di caratteri
  • ' ○'[... ]: genera uno spazio (non parte del triangolo) o un cerchio (quando fa parte del triangolo)

Produzione:

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

1
Yikes. Mi aspettavo che fossero 4 caratteri, usando i binomi mod 2 ... (ok ... forse un po ' più di così)
stand

13

Haskell (291)

Non sono molto bravo a giocare a golf con i codici haskell.

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

L'output di solve 4è:

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

13

QBasic 151 personaggi

Ad esempio, ecco come si può fare in 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

inserisci qui la descrizione dell'immagine


Potresti descrivere la misura in base alla quale questo programma ha 129 caratteri? Ottengo 151 se rimuovo tutto lo spazio bianco probabilmente non necessario. (Non ho familiarità con QBasic.)
Kevin Reid

Ho eliminato tutto lo spazio bianco per il mio conteggio. Immagino di poter contare solo spazi bianchi non essenziali. Non sono sicuro di quale sia la regola "ufficiale" per il codice golf.
Kibbee,

4
Dovresti contare il numero effettivo di caratteri, incluso lo spazio, in un programma che esegue e produce l'output corretto . Naturalmente non vorrai avere spazi bianchi non necessari.
Kevin Reid,

1
Corretto il conteggio del mio personaggio.
Kibbee,

13

Python (42)

Inizialmente volevo pubblicare alcuni suggerimenti sulla soluzione boothbys (che utilizza effettivamente la regola 18 :), ma non avevo abbastanza reputazione per commentare, quindi l'ho trasformata in un'altra risposta. Da quando ha cambiato approccio, ho aggiunto alcune spiegazioni. I miei suggerimenti sarebbero stati:

  1. usa '% d' * 64% tupla (x) invece di '' .join (mappa (str, x)
  2. sposta gli zeri invece di racchiudere l'elenco

che avrebbe portato al seguente codice (93 caratteri):

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

Ma ho ottimizzato ulteriormente, prima usando un longint invece di un array intero e stampando semplicemente la rappresentazione binaria (75 caratteri):

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

E infine stampando la rappresentazione ottale, che è già supportata dall'interpolazione printf (42 caratteri):

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

Tutti stamperanno:

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

Naturalmente c'è anche una soluzione grafica (131 caratteri):

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')

triangolo sierpinsky molto piccolo : D


1
36:x=8**31;exec"print'%o'%x;x^=x/8;"*32
aditsu,

13

8086 Codice macchina - 30 byte.

NOTA: questo non è il mio codice e non deve essere accettato come risposta . Ho trovato questo mentre lavoravo su un diverso problema CG per emulare una CPU 8086 . Il file di testo incluso dà credito a David Stafford , ma è il migliore che ho potuto inventare.

Sto pubblicando questo perché è intelligente, breve e ho pensato che avresti voluto vederlo.

Fa uso di codici operativi sovrapposti per impacchettare più istruzioni in uno spazio più piccolo. Incredibilmente intelligente. Ecco il codice macchina:

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

Una decodifica semplice si presenta così:

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

Quando corri, quando si verifica il salto a 0x0115, nota che salta indietro a 0x010C, proprio nel mezzo di un'istruzione precedente:

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]

Brillante! Spero che non vi dispiaccia se condivido questo. So che non è una risposta in sé, ma è interessante per la sfida.

Eccolo in azione:

In esecuzione


11

C 127 119 116 108 65

Questo usa il trucco della risposta HTML per ^ i & jottenerlo per stampare un output piuttosto che richiederebbe 1 carattere in più (puoi ottenere un output davvero brutto sacrificando il a^).

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

Per rendere abbastanza girare (32^i&j)per (32|!(i&j))e girare da ++i<aa ++i<=a. Tuttavia, sprecare chars su sguardi mi sembra poco divertente.

Brutta produzione:

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

In realtà mi piace come sembra. Ma se insisti sul fatto che è carino puoi agganciare quattro caratteri. Abbastanza uscita:

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

Lasciando la vecchia 108 caratteri, la versione degli automi cellulari.

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(""));}

Quindi non penso che lo farò molto più breve di così, quindi spiegherò il codice. Lascerò questa spiegazione, poiché alcuni dei trucchi potrebbero essere utili.

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
}

Alcuni output

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

1
Questo non sembra essere un triangolo di Sierpinski; si divide in tre triangoli (procedendo verso il basso) anziché in due, e si può vedere che questo non produce un grande triangolo vuoto centrale.
Kevin Reid,

1
Questo perché ho usato la regola sbagliata: O. Risolto e rasato un paio di caratteri.
Walpen

9

Codice 80x86 / MsDos - 10 byte

Essendo un programmatore specializzato in piccole introduzioni su MsDos, sono riuscito a elaborare un programma che occupa solo 10 byte.

in esadecimale:

04 13 CD 10 20 E9 B4 0C E2 F6

inserisci qui la descrizione dell'immagine

in asm:

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

La prima versione che ho codificato era "Colpinski", che ha una dimensione di 16 byte, e addirittura interattiva in modo da poter cambiare il colore con la tastiera e il mouse. Insieme a "Frag" - un altro sizecoder - l'abbiamo portato a 13 byte, consentendo un programma da 10 byte che contiene solo la routine principale.

Diventa un po 'più interessante quando le cose sono animate, quindi citerò un'altra versione, Zoompinski 64 - che cerca di imitare il comportamento esatto di "Zoompinski C64" in 512 byte - anche per MsDos, 64 byte in dimensioni come suggerisce il nome.

È possibile ottimizzare ulteriormente questo fino a 31 byte, perdendo eleganza, colori e simmetria (sorgente ed eseguibile disponibili dietro il link sopra)

Scarica l'originale e commenta "Pouet"


2
Dovresti pubblicare un dump esadecimale del tuo codice, in modo che possiamo vedere i byte effettivi.
mbomb007,

8

PostScript, 120 caratteri

-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

Uscita Ghostscript:

Output di Ghostscript reso

Questo sta disegnando la figura triplicando ricorsivamente ciò che è già disegnato.

Il primo passo è disegnare una linea. La linea viene salvata come percorso utente, quindi il percorso utente viene aggiunto altre due volte dopo aver ruotato di 120 gradi ogni volta. [2 0 0 2 7 4]concatsposta il "punto di rotazione" al centro del prossimo grande "triangolo centrale" bianco che deve essere racchiuso dalle repliche del triangolo che già abbiamo. Qui, torniamo al passaggio 1 (creando un upath triplicato dalla rotazione).

Il numero di iterazioni è controllato dal primo numero nella riga 3.


+1 Molto bello. Non avevo idea che Upath potesse essere usato in quel modo.
Luser droog

Ehi, hai il rappresentante per aggiungere quell'immagine ora!
Luser droog

@luserdroog: Esatto (anche in parte grazie a te)!
Thomas W.

7

J (9 caratteri)

Facilmente il più brutto, devi davvero strizzare gli occhi per vedere l'output;)

2|!/~i.32

produce l'output

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

ovviamente puoi visualizzarlo graficamente:

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

Immagine


come ... cosa?
accolito

4
Il codice sfrutta la proprietà del triangolo di Pascal che se si colorano tutti i numeri dispari (pari) nero (bianco), si finisce con il triangolo Sierpinski. (vedi questa immagine). i.32 genera la lista 0 1 2 ... 31. Quindi! / ~ calcola i coefficienti binomiali di ciascun elemento nella lista rispetto a se stesso, cioè produce una matrice 32 x 32 che ha il triangolo di Pascal incorporato in essa. Quindi 2 | è semplicemente ogni elemento in questa matrice mod 2, producendo il triangolo di Sierpinski.
Mark Allen

4

APL, 37 32 ( 28 23)

Triangolo verticale ( 37 32 caratteri)

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

Spiegazione

  • 1 2⍴'/\': Crea una matrice di caratteri 1 × 2 /\
  • {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Una funzione che riempie l'argomento giusto su entrambi i lati di spazi vuoti per creare una matrice doppia come larga, quindi lamina l'argomento giusto stesso raddoppiato sul fondo.
    Ad esempio /\sarebbe diventato
 / \ 
/ \ / \
  • ⍣⎕: Ricorre la funzione (input dell'utente) volte.

Esempio di output

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

Triangolo obliquo ( 28 23 caratteri)

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

spiegazione

  • 1 1⍴'○': Crea una matrice di caratteri 1 × 1
  • {(⍵,∊⍵)⍪⍵,⍵}: Una funzione che riempie l'argomento giusto a destra con spazi vuoti per creare una matrice doppia come larga, quindi lamina l'argomento giusto stesso raddoppiato sul fondo.
    Ad esempio sarebbe diventato
○ 
○○
  • ⍣⎕: Ricorre la funzione (input dell'utente) volte.

Esempio di output

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

4

Python (75)

Sono in ritardo di due anni alla festa, ma sono sorpreso che nessuno abbia ancora adottato questo approccio

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

level7

Utilizza il prodotto Kronecker per sostituire una matrice con più copie di se stesso.

Potrei salvare due caratteri usando x=kron(x,x);x=kron(x,x)nella riga tre per ottenere un'immagine di 16x16 pixel con tre livelli visibili o aggiungere un altro carattere all'iteratore e finire con un'immagine 2 ^ 16 x 2 ^ 16 = 4.3 Gigapixel e 15 livelli di triangolo.


3

Logo, 75 caratteri

59 caratteri solo per la prima funzione, la seconda chiama la prima con le dimensioni e la profondità / numero di iterazioni. Quindi potresti semplicemente chiamare la prima funzione dall'interprete con il comando: e 99 5, o qualunque dimensione tu voglia emettere

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

+1 Ho letto del Logo. Quale interprete stai usando? ... Logo potrebbe essere una scelta naturale per la mia sfida l-sistema .
Luser droog

Se hai appena rimosso il to fe endintorno e 99 5, si dispone di un programma eseguibile completo in un minor numero di caratteri. Inoltre, in UCBLogo (anche se non in altre versioni) puoi perdere i due punti sulle variabili per salvare più caratteri.
Mark Reed,

3

matlab 56

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

inserisci qui la descrizione dell'immagine


3

J (18 caratteri)

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

Risultato

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

3

Python (90 caratteri)

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)

Provalo online

Disegna la linea frattale riempiendo il triangolo di Sierpinsky


Prima di eseguire, consiglio di inserire ht();speed(0);up();goto(20-window_width()/2, 20-window_height()/2);down()dopo l'importazione. Questo lo farà funzionare molto più velocemente e assicurerà che l'output si adatti alla tela.
mbomb007,

3

Mathematica 67

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

inserisci qui la descrizione dell'immagine

Mathematica 92

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

inserisci qui la descrizione dell'immagine


3

Mathematica , 29 byte

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

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

Il tetraedro Sierpinski può essere disegnato in modo simile:

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

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


3

J , 37 35 byte

-2 byte grazie a FrownyFrog

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

Provalo online!

Questa è la versione in arte ascii di Peter Taylor convertita in J. Potrebbe salvare byte con una versione meno carina, ma perché?

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

@]^:[-> @[&0e ' /\ '->' /\'
FrownyFrog il

Sai per caso dove &0è documentato il trucco?
Giona il

1
Menzionato qui in fondo alla pagina. Mentre salva un byte, perdi la possibilità di avere un numero negativo di ripetizioni.
FrownyFrog il

Oh, dovresti essere in grado di scambiare gli operandi in ,~giro.
FrownyFrog,

3

Script Lua in Golly , 54 byte

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

Golly è un simulatore di automi cellulari con supporto di scripting Lua e Python.

Questo script imposta la regola su Wolfram Rule 60, imposta la cella su (0,0) su 1 ed esegue 512 passaggi.

inserisci qui la descrizione dell'immagine


2

Postscript, 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

Riscrivere usando le stringhe e la ricorsione finisce esattamente allo stesso conteggio. Ma i limiti di profondità del macro-approccio vengono superati.

Modifica: fill è più breve di stroke.

Rientrato e commentato.

%!
[   % 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

L'aggiunta 0 setlinewidthdà una migliore impressione di quanto sia profonda questa.

rivedi l'immagine usando <code> fill </code> (praticamente lo stesso)


Questo è il mio preferito.
cjfaure,

C'è un modo per renderlo più breve con questa lib esterna che ho scritto dopo il fatto e che non posso usare. : P
luser droog


2

Asintoto, 152 byte

Aggiungerò questo, soprattutto da quando ho visto più o meno nessuna risposta negli asintoti su questo sito. Alcuni byte sprecati per una buona formattazione e generalità, ma posso conviverci. La modifica di A, B e C cambierà la posizione degli angoli del triangolo contenente, ma probabilmente non nel modo in cui pensi. Aumenta il numero nella disuguaglianza per aumentare la profondità.

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

o non golfato e leggibile

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

Quindi l'asintoto è un linguaggio di grafica vettoriale pulito con una sintassi un po 'C-like. Molto utile per diagrammi alquanto tecnici. L'output è ovviamente in formato vettoriale per impostazione predefinita (eps, pdf, svg) ma può essere convertito in praticamente tutto ciò che imagemagick supporta. Produzione:

Triangolo di Sierpinski


2

Haskell , 166 154 byte

(-12 byte grazie a Laikoni, (comprensione di zip e list invece di zipWith e lambda, modo migliore di generare la prima riga))

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)

Provalo online!

Spiegazione:

La funzione i#ndisegna un triangolo ASCII di altezza 2^ndopo i ipassaggi dell'iterazione.

La codifica utilizzata codifica internamente le posizioni vuote come 1e le posizioni complete come 0. Pertanto, la prima riga del triangolo è codificata come [1,1,1..0..1,1,1]con 2^n-1quelle su entrambi i lati dello zero. Per creare questo elenco, iniziamo con l'elenco x=1<$[2..2^n], ovvero l'elenco [2..2^n]con tutto ciò a cui è mappato 1. Quindi, creiamo l'elenco completo comex++0:x

L'operatore k!p(spiegazione dettagliata di seguito), dato un indice di riga ke un corrispondente pgenera un elenco infinito di righe che seguono p. Lo invochiamo con 1e la linea di partenza sopra descritta per ottenere l'intero triangolo, quindi prendiamo solo le prime 2^nlinee. Quindi, stampiamo semplicemente ogni riga, sostituendola 1con spazio e 0con M(accedendo all'elenco "M "nella posizione 0o 1).

L'operatore k!pè definito come segue:

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

Innanzitutto, generiamo tre versioni di p: 1:pche è pcon un 1anteposto, pse stesso e tail p++[1]che è tutto tranne il primo elemento di p, con un 1allegato. Quindi comprimiamo queste tre liste, dandoci effettivamente tutti gli elementi pcon i loro vicini sinistro e destro, come (l,m,r). Usiamo una comprensione dell'elenco per poi calcolare il valore corrispondente nella nuova riga:

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

Per comprendere questa espressione, dobbiamo renderci conto che ci sono due casi di base da considerare: o semplicemente espandiamo la linea precedente o siamo in un punto in cui inizia un punto vuoto nel triangolo. Nel primo caso, abbiamo uno spazio pieno se uno degli spazi del quartiere è pieno. Questo può essere calcolato come m*l*r; se uno di questi tre è zero, il nuovo valore è zero. L'altro caso è un po 'più complicato. Qui, abbiamo sostanzialmente bisogno del rilevamento dei bordi. La tabella seguente mostra gli otto possibili quartieri con il valore risultante nella nuova riga:

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

Una formula semplice per produrre questa tabella sarebbe quella 1-m*r*(1-l)-m*l*(1-r)che semplifica m*(2*l*r-l-r)+1. Ora dobbiamo scegliere tra questi due casi, che è dove utilizziamo il numero di riga k. Se mod k (2^(n-i)) == 0, dobbiamo usare il secondo caso, altrimenti usiamo il primo caso. Il termine 0^(mod k(2^n-i))quindi è 0se dobbiamo usare il primo caso e 1se dobbiamo usare il secondo caso. Di conseguenza, possiamo usare

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

in totale - se utilizziamo il primo caso, otteniamo semplicemente m*l*r, mentre nel secondo caso viene aggiunto un termine aggiuntivo, che dà il totale complessivo di m*(2*l*r-l-r)+1.


1
154 byte: provalo online! Bella spiegazione a proposito!
Laikoni,

@Laikoni Ooh, alcuni miglioramenti molto belli!
Sacchan,

1

C, 106 caratteri

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?"/__\\":"/\\");}

(Mi diverte ancora che puts("")sia il modo più breve per produrre una nuova riga in C.)

Si noti che è possibile creare guarnizioni più grandi (o più piccole) sostituendo il test 32nel forciclo con una potenza maggiore (più piccola) di due, purché si sostituisca anche 33la metà nel mezzo printf()con la potenza del due più uno.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.