language agnostic - Código de Golf: Triángulo de Sierpinski

language-agnostic code-golf

Question

El reto

El código más corto, por número de caracteres, muestra una representación ASCII de las iteraciones Triángulo de N de Sierpinski realizadas a partir del siguiente triángulo ASCII:

 //
/__/

La entrada es un solo número positivo.

Casos de prueba

Input:
    2
Output:
       //
      /__/
     //  //
    /__//__/

Input:
    3
Output:
           //
          /__/
         //  //
        /__//__/
       //      //
      /__/    /__/
     //  //  //  //
    /__//__//__//__/

Input:
    5
Output:
                                   //
                                  /__/
                                 //  //
                                /__//__/
                               //      //
                              /__/    /__/
                             //  //  //  //
                            /__//__//__//__/
                           //              //
                          /__/            /__/
                         //  //          //  //
                        /__//__/        /__//__/
                       //      //      //      //
                      /__/    /__/    /__/    /__/
                     //  //  //  //  //  //  //  //
                    /__//__//__//__//__//__//__//__/
                   //                              //
                  /__/                            /__/
                 //  //                          //  //
                /__//__/                        /__//__/
               //      //                      //      //
              /__/    /__/                    /__/    /__/
             //  //  //  //                  //  //  //  //
            /__//__//__//__/                /__//__//__//__/
           //              //              //              //
          /__/            /__/            /__/            /__/
         //  //          //  //          //  //          //  //
        /__//__/        /__//__/        /__//__/        /__//__/
       //      //      //      //      //      //      //      //
      /__/    /__/    /__/    /__/    /__/    /__/    /__/    /__/
     //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //
    /__//__//__//__//__//__//__//__//__//__//__//__//__//__//__//__/

El recuento de códigos incluye entrada / salida (es decir, programa completo).

Answer 1

Clojure: 174 caracteres

Algoritmo robado de otros arriba.

(doseq[q((fn f[n](if(= n 1)[" /// ""/__//"](let[z(f(dec n))](concat(map #(let[y(repeat(Math/pow 2(dec n))/ )](apply str(concat y % y)))z)(map str z z)))))(read))](println q))

38 de esos personajes son paréntesis. : (

(doseq [q ((fn f [n]
           (if (= n 1)
             [" /// " "/__//"]
             (let [z (f (dec n))]
               (concat
                (map #(let [y (repeat (Math/pow 2 (dec n))/ )]
                        (apply str (concat y % y))) z)
                (map str z z))))) (read))] 
  (println q))

Answer 2

F #, 225 caracteres

let rec p n=if n=1 then" "else p(n-1)+p(n-1)
and S n=if n=1 then[" /// ";"/__//"]else let s=S(n-1)in List.append(List.map(fun s->p(n)+s+p(n))s)(List.map(fun x->x+x)s)
for s in S(int(System.Console.ReadLine()))do printfn"%s"s

Answer 3

Golfscript - 46

'' // /__/ ''4/{).+: ;.{ / ++}%/{.+}%+~ ]}@~(*n*

Golfscript - 47

'' // /__/ ''4/): ;{  +: ;.{ / ++}%/{.+}%+}@~(*n*

Golfscript - 48

'' '': ''// /__//'+4/{2 *: ;.{ / ++}%/{.+}%+}@~(*n*

Golfscript - 51

~'' '': ''// /__//'+4//(,{;2 *: ;.{ / ++}%/{.+}%+}%;n*

El mismo algoritmo que mi respuesta más corta de pitón (y rubí)

Golfscript - 78

2/~(?,{-1*}$1: ;{"  ":$*. 2base.{[$$+'' // '']=}%n+@@{[$$+"/__//"]=}%n .2*^: ;}%

El mismo algoritmo que mi solución python más larga

Este tiene nuevas líneas significativas

2/~(?,{-1*}$1: ;{"  ":
*. 2base.{[
2*'' // '']=}%n+@@{[
2*"/__//"]=}%n .2*^: ;}%

Answer 4

Haskell, 153 149 137 125 118 112 caracteres:

Uso de recursividad de cola:

(%)=zipWith(++)
p="  ":p
g t _ 1=t
g t s(n+1)=g(s%t%s++t%t)(s%s)n
main=interact$unlines.g[" /// ","/__//"]p.read

versión anterior, @ 118 caracteres:

(%)=zipWith(++)
f 1=[" /// ","/__//"]
f(n+1)=s%t%s++t%t where t=f n;s=replicate(2^n)'' '':s
main=interact$unlines.f.read

Usando el patrón (justly deprecated!) N + k guardó 4 caracteres.

Me gusta cómo sale a mitad de camino, incluso en forma comprimida.

editar: antiguo principal

main=do{n<-getLine;putStr$unlines$f$read n}

Answer 5

Perl, 82 golpes

Esta versión ya no imprime una nueva línea final. Solo la primera nueva línea es necesaria:

$_='' // 
/__//';
for$x(2..<>){
my$y;
$".=$";
s#.+#$y.=$/.$&x2,$".$&.$"#ge;
$_.=$y
}
print

Si se permiten los cambios en la línea de comandos, entonces, con la puntuación de golf tradicional de Perl, esto es 77 + 3 golpes (la primera nueva línea es literal):

#!perl -p
$/='' // 
/__//';
$y="",
$".=$",
$/=~s#.+#$y.=$/.$&x2,$".$&.$"#ge,
$/.=$y
for 2..$_

Por favor, siéntase libre de editar mi respuesta si encuentra una mejora.

Answer 6

Prolog, 811 Chars

:- module(sierpinsky, [draw/1]).

% draw(+Level)
draw(N) :- K is 2^(N+1)-1,
  for(Line, 0, K),
  draw2(N, Line, true, nl),
  fail.
draw(_).

% draw2(+Level, +Line, +Before, +After)
draw2(0, 0, Before, After) :- !,
  Before, write('' /// ''), After.
draw2(0, 1, Before, After) :- !,
  Before, write(''/__//'), After.
draw2(N, Line, Before, After) :- N>0, K is 2^N, Line < K, !, M is N-1,
  draw2(M, Line, (Before, tab(K)), (tab(K), After)).
draw2(N, Line, Before, After) :- N>0, K is 2^N, Line >= K, !, M is N-1,
  Line2 is Line - K,
  draw2(M, Line2, Before, draw2(M, Line2, true, After)).

% for(+Variable, +Integer, +Integer)
for(V, N, M) :- N =< M, V = N.
for(V, N, M) :- N < M, K is N+1, for(V, K, M).

% tab(+Integer)
tab(N) :- for(_, 1, N), write('' ''), fail.
tab(_).

Answer 7

Python - 102

a=" // ","/__//"
j='' ''
for n in~-input()*j:j+=j;a=[j+x+j for x in a]+[x*2for x in a]
print"/n".join(a)

Python - 105

a=" // ","/__//"
j='' ''
for n in(input()-1)*j:j+=j;a=[j+x+j for x in a]+[x+x for x in a]
print"/n".join(a)

Python - 109

a=" // ","/__//"
for n in range(1,input()):j='' ''*2**n;a=[j+x+j for x in a]+[x+x for x in a]
print"/n".join(a)

Python2.6 - 120

N=1<<input()
a=1
while N:
 N-=2
 for s in" // ","/__//":print'' ''*N+bin(a)[2:].replace(''0'','' ''*4).replace(''1'',s)
 a=a^a*2

Answer 8

Python, 135 caracteres

S=lambda n:[" /// ","/__//"]if n==1 else[" "*(1<<n-1)+x+" "*(1<<n-1)for x in S(n-1)]+[x+x for x in S(n-1)]
for s in S(input()):print s

Answer 9

Ir , 273 caracteres

package main
import(f"fmt";"os";s"strconv";)func main(){var
t=[2]string{" /// ","/__//"};
n,_:=s.Atoi(os.Args[1]);a:=1;N:=a<<uint(n);for
N>0{N-=2;for
k:=0;k<2;k++{for
j:=0;j<N;j++{f.Print(" ")}b:=a;for
b>0{o:=t[k];if
b&1==0{o="    "}f.Print(o);b>>=1}f.Print("/n")}a^=a*2}}

El espacio en blanco es todo significativo.

Sin unificar con gofmt sierpinski-3.go | perl -p -e''s//t/ /g'' gofmt sierpinski-3.go | perl -p -e''s//t/ /g'' :

package main

import (
    "fmt";
    "os";
    "strconv";
)

func main() {
    var t = [2]string{" /// ", "/__//"};
    n, _ := strconv.Atoi(os.Args[1]);
    a := 1;
    N := a << uint(n);
    for N > 0 {
        N -= 2;
        for k := 0; k < 2; k++ {
            for j := 0; j < N; j++ {
                fmt.Print(" ")
            }
            b := a;
            for b > 0 {
                o := t[k];
                if b&1 == 0 {
                    o = "    "
                }
                fmt.Print(o);
                b >>= 1;
            }
            fmt.Print("/n");
        }
        a ^= a * 2;
    }
}

Tengo una buena pista para Go golf here .

Answer 10

GolfScript ( 45 44 caracteres)

~('' // /__/ ''4/)@{.+/.{[2$.]*}%/{.+}%+/}*;n*

Similar a la solución de gnibbler. Mi intento inicial ya era bastante similar, y luego lo miré y tomé prestadas algunas ideas.

Answer 11

Logotipo (que no sigue exactamente los requisitos): 47 caracteres

to F:n if:n[repeat 3[F(:n-1)fd 2^:n rt 120]]end

Probé esto solo con http://www.calormen.com/Logo/ así que no sé si es portátil. No cumple con los requisitos, pero seguramente el logotipo debe ser el idioma apropiado aquí. :) Me encanta que en el momento de escribir el logo, un personaje no sea igual a golfscript y J.

Answer 12

Lua, 139 personajes

t={" /// ","/__//"}for i=2,(...)do for j=1,#t do
t[#t+1]=t[j]:rep(2)k=(" "):rep(#t[j]/2)t[j]=k..t[j]..k end end
print(table.concat(t,"/n"))

Answer 13

MATLAB - 64 caracteres (versión de script)

Esto supone que tiene la variable N ya definida en su espacio de trabajo:

A=['' // '';''/__/'];for i=1:N-1,B=32*ones(2^i);A=[B A B;A A];end;A

MATLAB - 78 caracteres (versión de la función m-file)

Pase N como argumento a la función s :

function A=s(N),A=['' // '';''/__/'];for i=1:N-1,B=32*ones(2^i);A=[B A B;A A];end

Answer 14

Nroff, 542

$ nroff -rn=5 file.n

.pl 1
.nf
.de b
. nr i 0
. while d//$1//ni /{/
.   //$3 //$1//ni //$2//ni
.   nr i +1
. /}
..
.de push
. nr i 0
. while d//$2//ni /{/
.   nr i +1
. /}
. nr j 0
. while d//$1//nj /{/
.   ds //$2//ni /&//*[//$1//nj]
.   nr i +1
.   nr j +1
. /}
..
.ds l0 /& //[rs] /&
.ds l1 "/__/[rs]
.ds s /&/ 
.de o
. ds //$2 /&//*s//*[//$1]//*s
..
.de p
. ds //$2 /&//*[//$1]//*[//$1]
..
.de assign
. ds //$2 /&//*[//$1]
..
.nr a 2
.while /na<=/nn /{/
. ds s /&/*s/*s
. b l m o
. b l n p
. b m l assign
. push n l
. nr a +1
./}
.de t
//*[//$1]
..
.b l zz t

Answer 15

Ruby - 85

a='' // '',''/__//' j='' '' 2.upto(gets.to_i){j+=j;a=a.map{|x|j+x+j}+a.map{|x|x+x}} puts a 101 caracteres - // -solución modificada del Código Rosetta

(a=2**gets.to_i).times{|y|puts" "*(a-y-1)+(0..y).map{|x|~y&x>0?''  '':y%2>0?x%2>0?''_//':''/_'':''///'}*''''}

Answer 16

C

El mismo algoritmo que la respuesta de Perl , pero pesando en más pesado, en 131 caracteres necesarios.

a,b;main(c,v)char**v;{c=1<<atoi(v[1]);for(a=0;a<c;a++,puts(""))
for(b=c;b--;write(1,b&~a?"    ":a&1?"/__//":" /// ",4-2*(b>a)))--b;}

Pensé que write(1,…) era una API de UNIX, pero parece que también compila y funciona bien en Windows.

Si reemplaza char por int , guarda un carácter y aún funciona, pero es de legalidad cuestionable.

Answer 17

J

46 caracteres, leyendo de stdin.

(,.~,~[,.~'' ''$~#,#)^:(<:".1!:1]3)'' //',:''/__/'

/n siempre delimita las oraciones, lo que hace imposible encajar dentro de S ₃ (solo 54 caracteres para jugar). S ₄ es un poco grande en 162, así que lo rellené para que cupiera. Por casualidad, // es un adverbio legal. ☺

// i=:3 // // %r=:1!:1 // // t=:] [r+i // // // // b=:'' //',:''/__/' // // i=:1 -".t // // // // h=:('' ''$ ~#,#),.] // // // // s=:( h^:1 ,d=: ,.~) // // // // // // // // (,,&(10{a.)"1[s^:(-i)b)(1!:2)(4)

Answer 18

Perl

94 caracteres cuando se eliminan las nuevas líneas.

$c=2**<>;$/=$/;for$a(0..--$c){print$"x($c-$a&~1),
map$_*2&~$a?$"x4:$a&1?''/__//':'' // '',0..$a/2}

Answer 19

Lo siento, llegué tarde. Esto se basa en la solución Perl de A. Rex:

                           &I                               
                          ;for                              
                         $x  (2                             
                        ..<>){$E                            
                       .=      $E                           
                      ;my$    y;3*                          
                     33  +3  **  3;                         
                    s".+"$y.=$n.$&x2                        
                   ,$              E.                       
                  $&.$            E"ge                      
                 ;;  $_          .=  $y                     
                }print;;        sub I{($                    
               E,      $n      ,$      F,                   
              $B,$    U)=(    $",$    /,qw                  
             (/   /   _  ))  ;$  _=  $E  .$                 
            F.$B.$E.$n.$F.$U.$U.$B};33333333                

Answer 20

Python, 120 caracteres (solución recursiva)

S=lambda n:n<2and[" // ","/__//"]or[" "*n+x+" "*n for x in S(n/2)]+[x+x for x in S(n/2)]
print"/n".join(S(1<<input()-1))

Empecé a poner el verde donde @fserb se fue ...

Answer 21

Python, 186 caracteres (terminación de línea UNIX)

for j in range(1,n):
 for s in p:
  print s
 x=2**j;y=2*x;p.extend(['''']*x)
 for i in range(y-1,-1,-1):
  if i<x:
   s='' ''*x;p[i]=s+p[i]+s
  else:
   q=p[i-x];p[i]=q+q