Capas Sierpinski

19

Comenzando con /\usted, puede crear un patrón similar a un triángulo de Sierpinski agregando una línea debajo de tal manera que ...

  1. Cualquier rama suelta /o \se divide de nuevo en dos ramas: /\.
  2. Cualquier colisión de ramas \/muere con nada (excepto espacios) debajo.

Repetir estas reglas produce

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

( Inspiración de ViHart )

Escriba un programa o función que tome un entero positivo N e imprima las primeras N líneas de este patrón en stdout, sin más espacios iniciales o finales de los necesarios.

Por ejemplo, si la entrada es 1la salida debe ser

/\

Si la entrada es 2la salida debe ser

 /\
/\/\

Si la entrada es 8la salida debe ser

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

Y así.

El código con la menor cantidad de bytes gana.

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 Pasatiempos de Calvin
fuente
1
¿Puede por favor hacer "la menor cantidad de bytes" para evitar travesuras de compresión de código?
xnor
@xnor cambiado.
Hobbies de Calvin
Estaba literalmente a punto de publicar esto. Malvado : /
Kaz Wolfe
¿Dónde está la respuesta APL?
Joe

Respuestas:

6

CJam, 48 46 bytes

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

Enfoque recursivo simple basado en las observaciones 1 y 2 de la pregunta.

Pruébalo en línea.

Cómo funciona

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 bytes

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

Me gusta más este enfoque, pero no puede competir con el recursivo. Incluso después de eliminar 2mL(lo que resulta en al menos O (2 n ) tiempo de ejecución), todavía estoy en 48 bytes ...

Este enfoque codifica /\los s como 1 y los espacios dobles entre ellos como 0. Considerando los números binarios de las matrices resultantes, vemos que la configuración de la enésima fila corresponde al enésimo número entero mayor que 1 que puede expresarse como producto de diferentes números de Fermat (enteros de la forma 2 2 k +1 ).

Cómo funciona

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'                             ";
}                  "                                                                ";
Dennis
fuente
5

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

Basado en reemplazos de cadenas temporales ( /programming//a/8687380/3419103 ):

  1. / > V
  2. \ > V
  3. \/> __(2 espacios)
  4. V > /\
Falko
fuente
b*(N-1)+m+npodría serb*~-N+m+n
FryAmTheEggman
@FryAmTheEggman: ¡Impresionante! Ahora te tengo, JavaScript! ;)
Falko
4

Javascript - 117 bytes

Minified:

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}

Expandido:

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

Salida de muestra (para n = 20):

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

Ahora bien, si sólo el repeaty replacenombres de funciones no eran tan largas. :PAG

COTO
fuente
3

Pyth, 45 bytes

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

Ejecución de ejemplo

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

Cómo funciona

                            # 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 + " ")
                       " /" #                                                       " /"
                            #     ))))
Dennis
fuente
3

Rubí, 90

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

Explicación

  • La entrada se toma como argumento para una lambda. Se espera que sea un Integer.
  • Use String#centerpara crear un String "/\"con n - 2espacios en cada lado y ponerlo en un Array( a).
  • Agregue al aúltimo elemento de acon cada aparición de "\/"reemplazado con " "y cada aparición de " /"o" \" reemplazado con "/\".
  • Use putspara imprimir cada elemento en asu propia línea.
britishtea
fuente
3

Haskell, 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
orgulloso Haskeller
fuente
Si cuento los caracteres que obtengo 128, también lo olvidaste import Data.List(desde unlinesque lo
usaste
@Flonk unlinesestá en el preludio.
orgulloso Haskeller
Vaya, tal vez debería haberlo buscado antes de comentar. ¡Culpa mía!
Flonk
2

JavaScript (E6) 107 106

Editar: recuento de bytes fijo, hecho recursivo.

No muy diferente de la otra respuesta JS ... al menos esta 'imprime' el patrón según lo solicitado. El núcleo está reemplazando '/' '\' con '/ \' y todo el resto con '' en cada nueva línea.

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

Prueba en la consola FireFox / FireBug

F(15)

Salida

                  /\
                 /\/\
                /\  /\
               /\/\/\/\
              /\      /\
             /\/\    /\/\
            /\  /\  /\  /\
           /\/\/\/\/\/\/\/\
          /\              /\
         /\/\            /\/\
        /\  /\          /\  /\
       /\/\/\/\        /\/\/\/\
      /\      /\      /\      /\
     /\/\    /\/\    /\/\    /\/\
    /\  /\  /\  /\  /\  /\  /\  /\
edc65
fuente
2

Perl 5 - 56 bytes

Los \ 0 se pueden reemplazar por caracteres de bytes nulos reales

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

Está utilizando el hecho de que si ignora los espacios iniciales y representa '/ \' como 1 y '' como 0, el patrón en una fila dada f (n) = f (n-1) ^ (f (n-1) < <1). Sin embargo, los cálculos en el código anterior se ejecutan en cadenas que están cerca de la salida esperada (sin espacios iniciales, otros espacios reemplazados por bytes nulos) gracias a la manipulación de cadenas bit a bit de 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
fuente
1

Python 2, 84 bytes

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

Javascript con lambdas, 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])

Se puede probar en Firefox (n = 16):

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
Qwertiy
fuente
0

Python 2, 97 bytes

i=input()
x=1
while i:i-=1;print " "*i+bin(x)[2:].replace("0","  ").replace("1", "/\\");x^=2*x
pbochniak
fuente
¡Bienvenido a Programming Puzzles & Code Golf! Buena respuesta: D
gato
0

Mathematica, 86 bytes

Column[Row/@Mod[Table[Binomial[n,k],{n,0,#-1},{k,0,n}],2]/.{1->"/\\",0->"  "},Center]&
J42161217
fuente