Sierpinski triangle: Difference between revisions

{{trans|Python}}

 

V d = [String(‘*’)]

L(i) 0 .< n

R d

 

 

{{out}}

 

=={{header|8080 Assembly}}==

puts: equ 9 ; CP/M syscall to print a string

putch: equ 2 ; CP/M syscall to print a character

pop b

ret

 

{{out}}

 

=={{header|8086 Assembly}}==

puts: equ 9 ; MS-DOS syscall to print string

argmt: equ 5Dh ; MS-DOS still has FCB in same place as CP/M

jnz line

ret

 

{{out}}

 

=={{header|ACL2}}==

(if (endp (rest prev))

(list 1)

(let ((height (1- (expt 2 levels))))

(print-odds (pascal-triangle height)

 

=={{header|Ada}}==

This Ada example creates a string of the binary value for each line, converting the '0' values to spaces.

with Ada.Strings.Fixed;

with Interfaces; use Interfaces;

Sierpinski(N);

end loop;

 

alternative using modular arithmetic:

with Ada.Text_IO;

 

end if;

Sierpinski (N);

{{out}}

<pre>XXXXXXXXXXXXXXXX

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - test missing transput}} -->

FLEX[0]STRING d := "*";

FOR i TO n DO

);

 

 

=={{header|ALGOL W}}==

{{Trans|C}}

integer SIZE;

SIZE := 16;

write();

end for_y

 

=={{header|AppleScript}}==

{{Trans|Haskell}}

Centering any previous triangle block over two adjacent duplicates:

 

-- sierpinski :: Int -> [String]

on unwords(xs)

intercalate(space, xs)

{{Out}}

<pre> *

Or generating each line as an XOR / Rule 90 / Pascal triangle rewrite of the previous line.

{{Trans|JavaScript}}

 

-- sierpinskiTriangle :: Int -> String

return lst

end tell

{{Out}}

<pre> *

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

</pre>

 

=={{header|ATS}}==

(* ****** ****** *)

//

//

} (* end of [main0] *)

 

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=150 discussion]

MsgBox % Triangle(A_Index)

 

Triangle(n-1,x+u,y+u) ; smaller triangle down right

Return t

 

=={{header|AWK}}==

# syntax: GAWK -f WST.AWK [-v X=anychar] iterations

# example: GAWK -f WST.AWK -v X=* 2

}

exit(0)

 

=={{header|BASH (feat. sed & tr)}}==

other language just as well, but is particularly well suited for

tools like sed and tr.

#!/bin/bash

 

 

rec $1 | tr 'dsx' ' *'

 

=={{header|BASIC}}==

<!-- {{works with|RapidQ}} doesn't work for me -- Erik Siers, 12 March 2012 -->

 

 

CLS

triangle x + length * 2, y + length, length / 2, n - 1

END IF

 

Note: The total height of the triangle is 2 * parameter ''length''. It should be power of two so that the pattern matches evenly with the character cells. Value 16 will thus create pattern of 32 lines.

 

==={{header|BBC BASIC}}===

OFF

PROCsierpinski(x%+l%+l%, y%+l%, l% DIV 2)

ENDIF

 

==={{header|FreeBASIC}}===

if l=0 then

locate y, x: print "*"

 

cls

 

==={{header|IS-BASIC}}===

110 TEXT 40

120 CALL TRIANGLE(1,1,8)

190 CALL TRIANGLE(X+2*L,Y+L,INT(L/2))

200 END IF

 

=={{header|Befunge}}==

This is a version of the cellular automaton (''rule 90'') construction. The order, ''N'', is specified by the first number on the stack. It uses a single line of the playfield for the cell buffer, so the upper limit for ''N'' should be 5 on a standard Befunge-93 implementation. Interpreters with poor memory handling may not work with anything over 3, though, and a Befunge-98 interpreter should theoretically be unlimited.

 

v:$_:#`0#\\#00#:p#->#1<

>2/1\0p:2/\::>1-:>#v_1v

vg11<\*g11!:g 0-1:::<p<

>!*+!!\0g11p\ 0p1-:#^_v

 

=={{header|Burlesque}}==

 

-.'sgve!

J{JL[2./+.' j.*PppP.+PPj.+}m[

.+

}{vv{"*"}}PPie} 's sv

 

=={{header|C}}==

 

#define SIZE (1 << 4)

}

return 0;

 

===Automaton===

This solution uses a cellular automaton (''rule 90'') with a proper initial status.

#include <stdlib.h>

#include <stdbool.h>

}

free(cp);

 

{

int i;

 

free(b);

 

{

sierpinski_triangle(4);

return EXIT_SUCCESS;

 

=={{header|C sharp|C#}}==

using System.Collections;

 

}

}

 

class Program {

static void Main(string[] args) {

}

}

 

{{trans|C}}

{{works with|C sharp|C#|6.0+}}

class Sierpinsky

{

}

}

 

{{trans|OCaml}}

{{works with|C sharp|C#|3.0+}}

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(s);

}

 

Or, with fold / reduce (a.k.a. aggregate):

 

using System.Collections.Generic;

using System.Linq;

foreach(string s in Sierpinski(4)) { Console.WriteLine(s); }

}

 

=={{header|C++}}==

{{works with|C++11}}

A STL-centric recursive solution that uses the new lambda functions in C++11.

#include <string>

#include <list>

sierpinski(4, ostream_iterator<string>(cout, "\n"));

return 0;

 

=={{header|Clojure}}==

{{trans|Common Lisp}}

With a touch of Clojure's sequence handling.

(:require [clojure.contrib.math :as math]))

 

(bit-xor (bit-shift-left v 1) (bit-shift-right v 1))))))

 

 

=={{header|COBOL}}==

{{trans|Fortran}} and retains a more Fortran-like coding style than is really idiomatic in COBOL.

program-id. sierpinski-triangle-program.

data division.

if r is equal to zero then display ' * ' with no advancing.

if r is not equal to zero then display ' ' with no advancing.

 

=={{header|Common Lisp}}==

(loop with size = (expt 2 order)

repeat size

do (fresh-line)

(loop for i below (integer-length v)

 

Printing each row could also be done by printing the integer in base 2 and replacing zeroes with spaces: <tt>(princ (substitute #\Space #\0 (format nil "~%~2,vR" (1- (* 2 size)) v)))</tt>

 

Alternate approach:

(if (= n 0) '("*")

(nconc (mapcar (lambda (e) (format nil "~A~A~0@*~A" (make-string (expt 2 (1- n)) :initial-element #\ ) e)) (sierpinski (1- n)))

(mapcar (lambda (e) (format nil "~A ~A" e e)) (sierpinski (1- n))))))

 

 

=={{header|Cowgol}}==

include "argv.coh";

 

print_nl();

y := y - 1;

 

{{out}}

=={{header|D}}==

===Run-time Version===

import std.stdio, std.algorithm, std.string, std.array;

 

}

d.join('\n').writeln;

{{out}}

<pre> *

===Compile-time Version===

Same output.

 

string sierpinski(int level) pure nothrow /*@safe*/ {

 

pragma(msg, 4.sierpinski);

 

===Simple Version===

{{trans|C}}

Same output.

import core.stdc.stdio: putchar;

 

void main() nothrow @safe @nogc {

4.showSierpinskiTriangle;

 

===Alternative Version===

This uses a different algorithm and shows a different output.

import std.algorithm: swap;

 

'\n'.putchar;

}

{{out}}

<pre> #

=={{header|Delphi}}==

{{trans|DWScript}}

 

{$APPTYPE CONSOLE}

begin

PrintSierpinski(4);

 

=={{header|DWScript}}==

{{trans|E}}

var

x, y, size : Integer;

 

PrintSierpinski(4);

 

=={{header|E}}==

def size := 2**order

for y in (0..!size).descending() {

out.println()

}

 

 

Non-ASCII version (quality of results will depend greatly on text renderer):

def size := 2**order

for y in (0..!size).descending() {

out.println()

}

 

=={{header|Elixir}}==

{{trans|Erlang}}

def sierpinski_triangle(n) do

f = fn(x) -> IO.puts "#{x}" end

end

 

 

=={{header|Elm}}==

{{trans|Haskell}}

import Html exposing (..)

import Html.Attributes as A exposing (..)

, ("font-size", "1em")

, ("text-align", "left")

 

Link to live demo: http://dc25.github.io/sierpinskiElm/

=={{header|Erlang}}==

{{trans|OCaml}}

-export([triangle/1]).

 

triangle(N, Down, Sp) ->

NewDown = [Sp++X++Sp || X<-Down]++[X++" "++X || X <- Down],

 

=={{header|Euphoria}}==

{{trans|BASIC}}

if n = 0 then

position(y,x) puts(1,'*')

 

clear_screen()

 

=={{header|F Sharp|F#}}==

let rec loop down space n =

if n = 0 then

let () =

 

=={{header|Factor}}==

{{trans|OCaml}}

IN: sierpinski

 

 

: sierpinski ( n -- )

 

=={{header|FALSE}}==

 

=={{header|FOCAL}}==

01.20 F X=0,S;S L(X)=0

01.30 S L(S/2)=1

 

03.10 F X=0,S;S K(X)=FABS(L(X-1)-L(X+1))

 

{{out}}

 

=={{header|Forth}}==

begin

dup 1 and if [char] * else bl then emit

loop 2drop ;

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

This method calculates a Pascal's triangle and replaces every odd number with a * and every even number with a space. The limitation of this approach is the size of the numbers in the Pascal's triangle. Tryng to print an order 8 Sierpinski's triangle will overflow a 32 bit integer and an order 16 will overflow a 64 bit integer.

implicit none

end do

end subroutine Triangle

 

=={{header|GAP}}==

SierpinskiTriangle := function(n)

local i, j, s, b;

* * * * * * * *

* * * * * * * *

 

=={{header|gnuplot}}==

Making and printing a text string, using bit-twiddling to decide whether each character should be a space or a star.

 

# Must have x<y. x<0 is the left side of the triangle.

# If x<-y then it's before the left edge and the return is a space.

 

# Print rows 0 to 15, which is the order 4 triangle per the task.

 

=={{header|Go}}==

"Δ" (Greek capital letter delta) looks good for grain, as does Unicode triangle, "△". ASCII "." and "^" are pleasing. "/\\", "´`", and "◢◣"" make interesting wide triangles.

 

import (

fmt.Println(r)

}

 

=={{header|Groovy}}==

Solution:

stPoints = { order, base=[0,0] ->

def right = [base[0], base[1]+2**order]

stPoints(order).each { grid[it[0]][it[1]] = (order%10).toString() }

grid

 

Test:

println()

stGrid(1).reverse().each { println it.sum() }

stGrid(5).reverse().each { println it.sum() }

println()

 

{{out}}

 

=={{header|Haskell}}==

sierpinski n = map ((space ++) . (++ space)) down ++

map (unwords . replicate 2) down

space = replicate (2 ^ (n - 1)) ' '

 

{{out}}

<pre>

 

We can see how the approach above (centering a preceding block over two duplicates) generates a framing rectangle at each stage, by making the right padding (plus the extra space between duplicates) more distinct and visible:

 

sierpinski :: Int -> [String]

 

main :: IO ()

{{Out}}

<pre> ▲---------------

 

Using bitwise and between x and y coords:

 

sierpinski n = map row [m, m-1 .. 0] where

| otherwise = " "

 

 

{{Trans|JavaScript}}

 

 

-- Top down, each row after the first is an XOR / Rule90 rewrite.

 

main :: IO ()

 

Or simply as a right fold:

 

sierpinski n =

foldr

 

main :: IO ()

 

{{Out}}

 

=={{header|Haxe}}==

{

static function main()

}

}

 

=={{header|Icon}} and {{header|Unicon}}==

This is a text based adaption of a program from the IPL and Icon Graphics book. The triangle is presented with a twist. Based on an idea from "Chaos and Fractals" by Peitgen, Jurgens, and Saupe.

 

procedure main(A)

writes((y=1,"\n")|"",canvas[x,y]," ") # print

 

 

{{libheader|Icon Programming Library}}

=={{header|IDL}}==

The only 'special' thing here is that the math is done in a byte array, filled with the numbers 32 and 42 and then output through a "<tt>string(array)</tt>" which prints the ascii representation of each individual element in the array.

s = (t = bytarr(3+2^(n+1))+32b)

t[2^n+1] = 42b

for i=1,n_elements(t)-2 do if s[i-1] eq s[i+1] then t[i]=32b else t[i]=42b

end

 

=={{header|J}}==

There are any number of succinct ways to produce this in J.

Here's one that exploits self-similarity:

 

Here, (,.~ , ])^:4 ,: '* ' is the basic structure (with 4 iterations) and the rest of it is just formatting.

 

Here's one that leverages the relationship between Sierpinski's and Pascal's triangles:

 

Here, !/~ i._16 gives us [[Pascal's_triangle|pascal's triangle]] (and we want a power of 2 (or, for the formatting we are using here a negative of a power of 2) for the size of the square in which contains the triangle, and (2 + |/~) i._16 is a [[Boolean_values#J|boolean]] representation where the 1s correspond to odd values in pascal's triangle, and the rest is just formatting.

Replace translations.

Recursive solution.

 

public class SierpinskiTriangle {

}

 

{{out}}

=={{header|JavaFX Script}}==

{{trans|Python}}

var down = ["*"];

var space = " ";

}

 

 

=={{header|JavaScript}}==

mapping the binary pattern to centred strings.

 

 

// Sierpinski triangle of order N constructed as

 

})(4);

 

Output (N=4)

====Imperative====

 

var n = 1 << o,

line = new Array(2 * n),

document.write("<pre>\n");

triangle(6);

 

===ES6===

Directly in terms of the built-in Array methods '''.map''', '''.reduce''', and '''.from''', and without much abstraction, possibly at the cost of some legibility:

 

// sierpinski :: Int -> String

.reduce(

(xs, _, i) => {

},

 

 

{{Trans|Haskell}}

Centering any preceding triangle block over two adjacent duplicates:

 

 

// sierpinski :: Int -> [String]

const sierpTriangle = n =>

 

 

 

 

 

 

 

 

 

 

{{Out}}

<pre> ▲---------------

Or constructed as 2^N lines of Pascal's triangle mod 2,

and mapped to centred {1:asterisk, 0:space} strings.

// sierpinski :: Int -> [Bool]

 

 

 

 

]);

 

 

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

 

 

 

 

{{Out}}

<pre> *

* * * * * * * *

* * * * * * * * * * * * * * * *</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

x = fill(token, 1, 1)

for _ in 1:n

end

 

 

=={{header|Kotlin}}==

{{trans|C}}

 

const val ORDER = 4

println()

}

 

{{out}}

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

</pre>

 

=={{header|Liberty BASIC}}==

call triangle 1, 1, nOrder

end

call triangle x+length*2, y+length, n

END IF

 

=={{header|Logo}}==

; limit=15 gives the order 4 form per the task.

; The range of :y is arbitrary, any rows of the triangle can be printed.

]

print []

 

=={{header|Lua}}==

Ported from the list-comprehension Python version.

 

lines = {}

lines[1] = '*'

end

 

{{out}}

<pre>

 

=={{header|Maple}}==

local i, j, values, position;

values := [ seq(" ",i=1..2^n-1), "*" ];

printf("%s\n",cat(op(convert(values, list))));

end do:

{{out}}

<pre>

</pre>

 

Cellular automaton (rule 90) based solution:

Using built-in function:

 

=={{header|MATLAB}}==

STRING was introduced in version R2016b.

d = string('*');

for k = 0 : n - 1

end

disp(d.join(char(10)))

{{out}}

<pre>

</pre>

===Cellular Automaton Version===

tr = + ~(-n : n);

for k = 1:n

tr(k + 1, :) = bitget(90, 1 + filter2([4 2 1], tr(k, :)));

end

 

===Mixed Version===

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

end row

return

{{out}}

<pre>

=={{header|Nim}}==

{{trans|C}}

 

for y in countdown(size, 0):

else:

stdout.write "* "

 

{{out}}

 

=={{header|OCaml}}==

let rec loop down space n =

if n = 0 then

 

let () =

 

=={{header|Oforth}}==

automat(rule, n) runs cellular automaton for rule "rule" for n generations.

 

| i |

StringBuffer new

 

: sierpinskiTriangle(n)

 

{{out}}

 

=={{header|Oz}}==

fun {NextTriangle Triangle}

Sp = {Spaces {Length Triangle}}

SierpinskiTriangles = {Iterate NextTriangle ["*"]}

in

 

=={{header|PARI/GP}}==

{{trans|C}}

my(s=2^n-1);

forstep(y=s,0,-1,

)

};

{{out}}

<pre> *

{{trans|C}}

{{works with|Free Pascal}}

 

function ipow(b, n : Integer) : Integer;

else

truth := false

 

var

l, i : Integer;

writeln(b)

end

 

triangle(4)

 

=={{header|Perl}}==

===version 1===

my ($n) = @_;

my @down = '*';

}

 

 

===one-liner===

 

=={{header|Phix}}==

{{Trans|C}}

<span style="color: #008080;">procedure</span> <span style="color: #000000;">sierpinski</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span>

<span style="color: #000000;">sierpinski</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre style="font-size: 2px">

 

=={{header|Phixmonti}}==

2 swap power 1 - var lim

lim 0 -1 3 tolist for

5 for

sierpinski

 

=={{header|PHP}}==

{{Trans|JavaScript}}

 

 

function sierpinskiTriangle($order) {

 

sierpinskiTriangle(4);

 

{{out}}

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

</pre>

 

=={{header|PicoLisp}}==

{{trans|Python}}

(let (D '("*") S " ")

(do N

D ) )

 

 

=={{header|PL/I}}==

declare t (79,79) char (1);

declare (i, j, k) fixed binary;

end make_triangle;

 

 

=={{header|PL/M}}==

 

DECLARE ORDER LITERALLY '4';

 

CALL BDOS(0,0);

{{out}}

<pre> *

Solution using line buffer in an integer array oline, 0 represents ' '

(space), 1 represents '*' (star).

lvars k = 2**n, j, l, oline, nline;

initv(2*k+3) -> oline;

enddefine;

 

 

Alternative solution, keeping all triangle as list of strings

lvars acc = ['*'], spaces = ' ', j;

for j from 1 to n do

enddefine;

 

 

=={{header|PostScript}}==

This draws the triangles in a string-rewrite fashion, where all edges form a single polyline. 9 page document showing progession.

%%BoundingBox 0 0 300 300

 

0 1 8 { 300 300 scale 0 1 12 div moveto

X + F + F fill showpage } for

 

=={{header|PowerShell}}==

{{Trans|JavaScript}}

$n = [Math]::Pow(2, $o)

$line = ,' '*(2*$n+1)

$line[$n+$i+1] = '█'

}

 

=={{header|Processing}}==

 

===Characters in drawing canvas version===

size(410, 230);

background(255);

sTriangle(x+l*2, y+l, l/2, n-1);

}

===Text in console version===

{{trans|Java}}

print(getSierpinskiTriangle(3));

}

return ns;

}

 

=={{header|Prolog}}==

Works with SWI-Prolog;

Len is 2 ** (N+1) - 1,

length(L, Len),

rule_90(' ',' ','*', '*').

rule_90(' ',' ',' ', ' ').

{{out}}

<pre> ?- sierpinski_triangle(4).

 

=={{header|PureBasic}}==

If N = 0

DrawText( Y,X, "*",#Blue)

Repeat

Until WaitWindowEvent()=#PB_Event_CloseWindow

 

=={{header|Python}}==

d = ["*"]

for i in xrange(n):

return d

 

 

 

Or, using fold / reduce {{works with|Python|3.x}}

 

def sierpinski(n):

return functools.reduce(aggregate, range(n), ["*"])

 

 

and fold/reduce, wrapped as concatMap, can provide the list comprehensions too:

 

from functools import reduce

 

 

{{Out}}

<pre> *

 

Use Python's long integer and bit operator to make an infinite triangle:

while True:

print(bin(x)[2:].replace('0', ' '))

 

=={{header|Quackery}}==

{{trans|Forth}}

 

iff char * else space

emit

2drop ] is triangle ( order --> )

 

 

{{out}}

=={{header|R}}==

Based on C# but using some of R's functionality to abbreviate code where possible.

len <- 2^(n+1)

b <- c(rep(FALSE,len/2),TRUE,rep(FALSE,len/2))

}

}

 

Shortened to a function of one line.

c(paste(ifelse(b<<- c(rep(FALSE,2^(n+1)/2),TRUE,rep(FALSE,2^(n+1)/2)),"*"," "),collapse=""),replicate(2^n-1,paste(ifelse(b<<-xor(c(FALSE,b[1:2^(n+1)]),c(b[2:(2^(n+1)+1)],FALSE)),"*"," "),collapse="")))

}

 

=={{header|Racket}}==

 

#lang racket

(define (sierpinski n)

(map (λ(x) (~a x " " x)) prev)))))

(for-each displayln (sierpinski 5))

 

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Perl}}

my @down = '*';

my $space = ' ';

}

 

=={{header|REXX}}==

parse arg n mark . /*get the order of Sierpinski triangle.*/

if n=='' | n=="," then n=4 /*Not specified? Then use the default.*/

say z /*display a line of the triangle. */

end /*j*/ /* [↑] finished showing triangle. */

'''output''' &nbsp; when using the default input of order: &nbsp; <tt> 4 </tt>

 

 

=={{header|Ring}}==

# Project : Sierpinski triangle

 

triangle(x+length*2, y+length, n)

ok

Output:

<pre>

=={{header|Ruby}}==

From the command line:

 

or, {{trans|Python}}

triangle = ["*"]

n.times do |i|

end

 

 

Using fold / reduce (aka. inject):

 

(0...n).inject(["*"]) {|triangle, i|

space = " " * (2**i)

end

 

 

=={{header|Run BASIC}}==

dim xy$(40)

for i = 1 to 40

call triangle x+length*2, y+length, n

END IF

<pre> *

* *

* * * * * * * *

* * * * * * * * * * * * * * * *</pre>

 

=={{header|Scala}}==

The Ruby command-line version (on Windows):

 

The Forth version:

def star(n: Long) = if ((n & 1L) == 1L) "*" else " "

def stars(n: Long): String = if (n == 0L) "" else star(n) + " " + stars(n >> 1)

(bitmap << 1) ^ bitmap

}

 

The Haskell version:

def sierpinski(n: Int): List[String] = {

lazy val down = sierpinski(n - 1)

}

sierpinski(n) foreach println

 

=={{header|Scheme}}==

{{trans|Haskell}}

(for-each

(lambda (x) (display (list->string x)) (newline))

(map (lambda (x) (append x (list #\ ) x)) acc))

(append spaces spaces)

 

=={{header|Seed7}}==

 

const func array string: sierpinski (in integer: n) is func

begin

writeln(join(sierpinski(4), "\n"));

 

=={{header|Sidef}}==

var triangle = ['*']

{ |i|

}

 

 

=={{header|Swift}}==

{{trans|Java}}

 

// Easy get/set of charAt

line[n + i + 1] = "*"

}

 

=={{header|Tcl}}==

{{trans|Perl}}

 

proc map {lambda list} {

}

 

 

=={{header|TI-83 BASIC}}==

Uses Wolfram Rule 90.

:ClrHome

:Output(1,8,"^")

:L3→L2

:End

 

=={{header|uBasic/4tH}}==

n = 2^n

 

Print

Next

 

=={{header|Unlambda}}==

`k``s``s``s``s`s`k`s``s`ksk`k``s``si`kk`k``s`kkk

`k``s`k`s``si`kk``s`kk``s``s``s``si`kk`k`s`k`s``s`ksk`k`s`k`s`k`si``si`k`ki

`k``s`k`s``si`k`ki``s`kk``s``s``s``si`kk`k`s`k`s`k`si`k`s`k`s``s`ksk``si`k`ki

This produces an infinite, left-justified triangle:

<pre style="height:30ex;overflow:scroll;">

=={{header|Ursala}}==

the straightforward recursive solution

 

the cheeky cellular automaton solution

#import nat

 

rule = -$<0,&,0,0,&,0,0,0>@rSS zipp0*ziD iota8

evolve "n" = @iNC ~&x+ rep"n" ^C\~& @h rule*+ swin3+ :/0+ --<0>

an example of each (converting from booleans to characters)

 

{{out}}

<pre style="height:30ex;overflow:scroll;">

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

</pre>

 

=={{header|VBA}}==

Dim lim As Integer: lim = 2 ^ n - 1

For y = lim To 0 Step -1

sierpinski i

Next i

<pre style="font-size: 4px">

#

=={{header|VBScript}}==

{{trans|PowerShell}}

Sub triangle(o)

n = 2 ^ o

 

triangle(4)

 

=={{header|Vedit macro language}}==

The macro writes the fractal into an edit buffer where it can be viewed and saved to file if required.

This allows creating images larger than screen, the size is only limited by free disk space.

Buf_Switch(Buf_Free) // Open a new buffer for output

Ins_Char(' ', COUNT, #3*2+2) // fill first line with spaces

Ins_Char(#21, OVERWRITE)

Ins_Char('*', OVERWRITE)

 

===Recursive===

{{trans|BASIC}}

Vedit macro language does not have recursive functions, so some pushing and popping is needed to implement recursion.

#2 = 1 // y

#3 = 16 // length (height of the triangle / 2)

Num_Pop(1,4)

}

 

=={{header|Wren}}==

{{trans|C}}

for (y in size-1..0) {

System.write(" " * y)

for (x in 0...size-y) System.write((x&y != 0) ? " " : "* ")

System.print()

 

{{out}}

=={{header|X86 Assembly}}==

Translation of XPL0. Assemble with tasm, tlink /t

.code

.486

loop tri10 ;next I

ret

 

{{out}}

 

=={{header|XPL0}}==

def Order=4, Size=1<<Order;

int S1, S2, I;

S2:= S2 xor S1>>1;

];

 

{{out}}

=={{header|Yabasic}}==

{{trans|Phix}}

local i, s$

sierpinski(i)

next

 

=={{header|zkl}}==

{{trans|D}}

foreach n in (level + 1){

sp:=" "*(2).pow(n);

d.apply(fcn(a){ String(a," ",a) }));

}

{{out}}

<pre>