Sierpinski triangle: Difference between revisions
→{{header|Factor}}
(26 intermediate revisions by 11 users not shown) | |||
Line 35:
{{trans|Python}}
<
V d = [String(‘*’)]
L(i) 0 .< n
Line 42:
R d
print(sierpinski(4).join("\n"))</
{{out}}
Line 65:
=={{header|8080 Assembly}}==
<
puts: equ 9 ; CP/M syscall to print a string
putch: equ 2 ; CP/M syscall to print a character
Line 125:
pop b
ret
nl: db 13,10,'$'</
{{out}}
Line 149:
=={{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
Line 190:
jnz line
ret
nl: db 13,10,'$'</
{{out}}
Line 214:
=={{header|ACL2}}==
<
(if (endp (rest prev))
(list 1)
Line 252:
(let ((height (1- (expt 2 levels))))
(print-odds (pascal-triangle height)
height)))</
=={{header|Action!}}==
<
BYTE x,y,size=[16]
Line 280:
FI
y==-1
OD</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sierpinski_triangle.png Screenshot from Atari 8-bit computer]
Line 304:
=={{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;
Line 356:
Sierpinski(N);
end loop;
end Sieteri_Triangles;</
alternative using modular arithmetic:
<
with Ada.Text_IO;
Line 386:
end if;
Sierpinski (N);
end Main;</
{{out}}
<pre>XXXXXXXXXXXXXXXX
Line 410:
{{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
Line 425:
);
printf(($gl$,sierpinski(4)))</
=={{header|ALGOL W}}==
{{Trans|C}}
<
integer SIZE;
SIZE := 16;
Line 442:
write();
end for_y
end.</
=={{header|AppleScript}}==
Line 448:
{{Trans|Haskell}}
Centering any previous triangle block over two adjacent duplicates:
<
-- sierpinski :: Int -> [String]
Line 550:
on unwords(xs)
intercalate(space, xs)
end unwords</
{{Out}}
<pre> *
Line 571:
Or generating each line as an XOR / Rule 90 / Pascal triangle rewrite of the previous line.
{{Trans|JavaScript}}
<
-- sierpinskiTriangle :: Int -> String
Line 717:
return lst
end tell
end zipWith</
{{Out}}
<pre> *
Line 739:
=={{header|Arturo}}==
<
s: shl 1 order
loop (s-1)..0 'y [
Line 751:
]
sierpinski 4</
{{out}}
Line 773:
=={{header|ATS}}==
<syntaxhighlight lang="ats">
(* ****** ****** *)
//
Line 816:
//
} (* end of [main0] *)
</syntaxhighlight>
=={{header|AutoHotkey}}==
ahk [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=150 discussion]
<
MsgBox % Triangle(A_Index)
Line 838:
Triangle(n-1,x+u,y+u) ; smaller triangle down right
Return t
}</
=={{header|APL}}==
<
=={{header|AWK}}==
<
# syntax: GAWK -f WST.AWK [-v X=anychar] iterations
# example: GAWK -f WST.AWK -v X=* 2
Line 868:
}
exit(0)
}</
=={{header|BASH (feat. sed & tr)}}==
Line 876:
other language just as well, but is particularly well suited for
tools like sed and tr.
<
#!/bin/bash
Line 900:
rec $1 | tr 'dsx' ' *'
</syntaxhighlight>
=={{header|Bash}}==
{{trans|BASH (feat. sed & tr)}}
{{works with|Bash|3.2.57}}
{{works with|Bash|5.2.9}}
<syntaxhighlight lang="bash">
#!/bin/bash
### BASH (pure-bash)
### https://rosettacode.org/wiki/Bourne_Again_SHell
### Ported from bash+sed+tr version
### Tested with bash versions 3.2.57 and 5.2.9
### This version completely avoids any number-theoretic workarounds.
### Instead, it repeatedly replaces characters by "blocks of characters".
### The strategy is in no way bash-specific,
### it would work with any other language just as well,
### but is particularly well suited for Bash Parameter Expansion
### ${parameter/pattern/string}
### syntax used for pure-bash global-pattern-substitution.
### (Search "man bash" output for "Parameter Expansion" for additional details
### on the
### ${parameter/pattern/string}
### and
### ${parameter:-word}
### syntax)
# Basic principle:
#
#
# x -> dxd d -> dd s -> s
# xsx dd s
#
# In the end all 'd' and 's' are removed.
function rec(){
if [ $1 == 0 ]
then
echo "x"
else
rec $[ $1 - 1 ] | while read line ; do
A="$line" ; A="${A//d/dd}" ; A="${A//x/dxd}" ; echo "$A"
A="$line" ; A="${A//d/dd}" ; A="${A//x/xsx}" ; echo "$A"
done
fi
}
### If the script has no arguments, then the default is n=4
### Else n is the first argument to the script
export n="${1:-4}"
B="$(rec "$n")" ; B="${B//d/ }" ; B="${B//s/ }" ; B="${B//x/*}"
echo "$B"
</syntaxhighlight>
=={{header|BASIC}}==
Line 907 ⟶ 961:
<!-- {{works with|RapidQ}} doesn't work for me -- Erik Siers, 12 March 2012 -->
<
CLS
Line 920 ⟶ 974:
triangle x + length * 2, y + length, length / 2, n - 1
END IF
END SUB</
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.
Line 926 ⟶ 980:
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
clg
call triangle (1, 1, 60)
Line 941 ⟶ 995:
end if
end subroutine
</syntaxhighlight>
==={{header|BBC BASIC}}===
<
OFF
Line 961 ⟶ 1,015:
PROCsierpinski(x%+l%+l%, y%+l%, l% DIV 2)
ENDIF
ENDPROC</
==={{header|FreeBASIC}}===
<
if l=0 then
locate y, x: print "*"
Line 975 ⟶ 1,029:
cls
sier(1,1,2^3)</
==={{header|IS-BASIC}}===
<
110 TEXT 40
120 CALL TRIANGLE(1,1,8)
Line 989 ⟶ 1,043:
190 CALL TRIANGLE(X+2*L,Y+L,INT(L/2))
200 END IF
210 END DEF</
=={{header|BCPL}}==
{{trans|C}}
<
manifest $( SIZE = 1 << 4 $)
Line 1,004 ⟶ 1,058:
wrch('*N')
$)
$)</
{{out}}
<pre> *
Line 1,027 ⟶ 1,081:
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
Line 1,033 ⟶ 1,087:
vg11<\*g11!:g 0-1:::<p<
>!*+!!\0g11p\ 0p1-:#^_v
@$$_\#!:#::#-^#1\$,+55<</
=={{header|Burlesque}}==
<
-.'sgve!
J{JL[2./+.' j.*PppP.+PPj.+}m[
Line 1,043 ⟶ 1,097:
.+
}{vv{"*"}}PPie} 's sv
4 'sgve!unsh</
=={{header|BQN}}==
<
{{out}}
Line 1,064 ⟶ 1,118:
=={{header|C}}==
<
#define SIZE (1 << 4)
Line 1,076 ⟶ 1,130:
}
return 0;
}</
===Automaton===
This solution uses a cellular automaton (''rule 90'') with a proper initial status.
<
#include <stdlib.h>
#include <stdbool.h>
Line 1,114 ⟶ 1,168:
}
free(cp);
}</
<
{
int i;
Line 1,133 ⟶ 1,187:
free(b);
}</
<
{
sierpinski_triangle(4);
return EXIT_SUCCESS;
}</
=={{header|C sharp|C#}}==
<
using System.Collections;
Line 1,180 ⟶ 1,234:
}
}
}</
<
class Program {
static void Main(string[] args) {
Line 1,189 ⟶ 1,243:
}
}
}</
{{trans|C}}
{{works with|C sharp|C#|6.0+}}
<
class Sierpinsky
{
Line 1,208 ⟶ 1,262:
}
}
}</
{{trans|OCaml}}
{{works with|C sharp|C#|3.0+}}
<
using System.Collections.Generic;
using System.Linq;
Line 1,238 ⟶ 1,292:
Console.WriteLine(s);
}
}</
Or, with fold / reduce (a.k.a. aggregate):
<
using System.Collections.Generic;
using System.Linq;
Line 1,267 ⟶ 1,321:
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>
Line 1,306 ⟶ 1,360:
sierpinski(4, ostream_iterator<string>(cout, "\n"));
return 0;
}</
=={{header|Clojure}}==
Line 1,312 ⟶ 1,366:
{{trans|Common Lisp}}
With a touch of Clojure's sequence handling.
<
(:require [clojure.contrib.math :as math]))
Line 1,337 ⟶ 1,391:
(bit-xor (bit-shift-left v 1) (bit-shift-right v 1))))))
(sierpinski-triangle 4)</
=={{header|CLU}}==
{{trans|Fortran}}
<
ss: stream := stream$create_output()
Line 1,367 ⟶ 1,421:
sierpinski(4)
)
end start_up</
{{out}}
<pre> *
Line 1,388 ⟶ 1,442:
=={{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.
Line 1,423 ⟶ 1,477:
if r is equal to zero then display ' * ' with no advancing.
if r is not equal to zero then display ' ' with no advancing.
compute c = c * (i - k) / (k + 1).</
=={{header|Comal}}==
<syntaxhighlight lang="comal">0010 DIM part$(FALSE:TRUE) OF 2
0020 part$(FALSE):=" ";part$(TRUE):="* "
0030 INPUT "Order? ":order#
0040 size#:=2^order#
0050 FOR y#:=size#-1 TO 0 STEP -1 DO
0060 PRINT " "*y#,
0070 FOR x#:=0 TO size#-y#-1 DO PRINT part$(x# BITAND y#=0),
0080 PRINT
0090 ENDFOR y#
0100 END</syntaxhighlight>
{{out}}
<pre>Order? 4
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *</pre>
=={{header|Common Lisp}}==
<
(loop with size = (expt 2 order)
repeat size
Line 1,432 ⟶ 1,516:
do (fresh-line)
(loop for i below (integer-length v)
do (princ (if (logbitp i 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>
Line 1,440 ⟶ 1,524:
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))))))
(mapc #'print (sierpinski 4))</
=={{header|Cowgol}}==
<
include "argv.coh";
Line 1,488 ⟶ 1,572:
print_nl();
y := y - 1;
end loop;</
{{out}}
Line 1,511 ⟶ 1,595:
=={{header|D}}==
===Run-time Version===
<
import std.stdio, std.algorithm, std.string, std.array;
Line 1,522 ⟶ 1,606:
}
d.join('\n').writeln;
}</
{{out}}
<pre> *
Line 1,543 ⟶ 1,627:
===Compile-time Version===
Same output.
<
string sierpinski(int level) pure nothrow /*@safe*/ {
Line 1,556 ⟶ 1,640:
pragma(msg, 4.sierpinski);
void main() {}</
===Simple Version===
{{trans|C}}
Same output.
<
import core.stdc.stdio: putchar;
Line 1,577 ⟶ 1,661:
void main() nothrow @safe @nogc {
4.showSierpinskiTriangle;
}</
===Alternative Version===
This uses a different algorithm and shows a different output.
<
import std.algorithm: swap;
Line 1,622 ⟶ 1,706:
'\n'.putchar;
}
}</
{{out}}
<pre> #
Line 1,693 ⟶ 1,777:
=={{header|Delphi}}==
{{trans|DWScript}}
<
{$APPTYPE CONSOLE}
Line 1,718 ⟶ 1,802:
begin
PrintSierpinski(4);
end.</
=={{header|Draco}}==
{{trans|C}}
<
proc nonrec main() void:
Line 1,733 ⟶ 1,817:
writeln()
od
corp</
{{out}}
<pre> *
Line 1,754 ⟶ 1,838:
=={{header|DWScript}}==
{{trans|E}}
<
var
x, y, size : Integer;
Line 1,771 ⟶ 1,855:
PrintSierpinski(4);
</syntaxhighlight>
=={{header|E}}==
<
def size := 2**order
for y in (0..!size).descending() {
Line 1,783 ⟶ 1,867:
out.println()
}
}</
<syntaxhighlight lang
Non-ASCII version (quality of results will depend greatly on text renderer):
<
def size := 2**order
for y in (0..!size).descending() {
Line 1,797 ⟶ 1,881:
out.println()
}
}</
=={{header|Elixir}}==
{{trans|Erlang}}
<
def sierpinski_triangle(n) do
f = fn(x) -> IO.puts "#{x}" end
Line 1,814 ⟶ 1,898:
end
RC.sierpinski_triangle(4)</
=={{header|Elm}}==
{{trans|Haskell}}
<
import Html exposing (..)
import Html.Attributes as A exposing (..)
Line 1,869 ⟶ 1,953:
, ("font-size", "1em")
, ("text-align", "left")
]</
Link to live demo: http://dc25.github.io/sierpinskiElm/
Line 1,875 ⟶ 1,959:
=={{header|Erlang}}==
{{trans|OCaml}}
<
-export([triangle/1]).
Line 1,885 ⟶ 1,969:
triangle(N, Down, Sp) ->
NewDown = [Sp++X++Sp || X<-Down]++[X++" "++X || X <- Down],
triangle(N-1, NewDown, Sp++Sp).</
=={{header|Euphoria}}==
{{trans|BASIC}}
<
if n = 0 then
position(y,x) puts(1,'*')
Line 1,900 ⟶ 1,984:
clear_screen()
triangle(1,1,8,4)</
=={{header|Excel}}==
Line 1,912 ⟶ 1,996:
{{Works with|Office 365 betas 2021}}
<
=LAMBDA(c,
LAMBDA(n,
Line 1,956 ⟶ 2,040:
)
)(grid)
)</
and also assuming the following generic bindings in the Name Manager for the WorkBook:
<
=LAMBDA(xs,
LAMBDA(ys,
Line 2,018 ⟶ 2,102:
)
)
)</
{{Out}}
Line 2,464 ⟶ 2,548:
=={{header|F Sharp|F#}}==
<
let rec loop down space n =
if n = 0 then
Line 2,476 ⟶ 2,560:
let () =
List.iter (fun (i:string) -> System.Console.WriteLine(i)) (sierpinski 4)</
=={{header|Factor}}==
{{trans|OCaml}}
<
IN: sierpinski
Line 2,496 ⟶ 2,580:
: sierpinski ( n -- )
[ { "*" } " " ] dip (sierpinski) print ;</
A more idiomatic version taking advantage of the '''''with''''', '''''each-integer''''', and '''''?''''' combinator as well as leveraging the looping combinator '''''each-integer'''''.
<syntaxhighlight lang="factor">USING: command-line io io.streams.string kernel math math.parser
namespaces sequences ;
IN: sierpinski
: plot ( i j -- )
bitand zero? "* " " " ? write ;
: pad ( n -- )
1 - [ " " write ] times ;
: plot-row ( n -- )
dup 1 + [ tuck - plot ] with each-integer ;
: sierpinski ( n -- )
dup '[ _ over - pad plot-row nl ] each-integer ;</syntaxhighlight>
=={{header|FALSE}}==
Requires the pick character to be substituted with 'O' in the portable interpreter linked-to from https://strlen.com/false-language/.
<syntaxhighlight lang="false">{ print spaces; in:n }
[[$0>][" " 1-]#%]w:
{ left shift; in:x,y out:x<<y }
[[$0>][\2*\ 1-]#%]l:
1 4 l;! { SIZE = 1<<4 }
$ { y = SIZE }
[$0>] { y > 0 }
[1-
$w;!
1ø { x = SIZE }
[$0>]
[1-
1ø$2ø\-&0= { !((x - y) & y) }
$ ["* "]?
~ [" "]?
]#%
10,
]#%%</syntaxhighlight>
=={{header|FOCAL}}==
<
01.20 F X=0,S;S L(X)=0
01.30 S L(S/2)=1
Line 2,521 ⟶ 2,638:
03.10 F X=0,S;S K(X)=FABS(L(X-1)-L(X+1))
03.20 F X=0,S;S L(X)=K(X)</
{{out}}
Line 2,544 ⟶ 2,661:
=={{header|Forth}}==
<
begin
dup 1 and if [char] * else bl then emit
Line 2,557 ⟶ 2,674:
loop 2drop ;
5 triangle</
=={{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
Line 2,590 ⟶ 2,707:
end do
end subroutine Triangle
end program Sierpinski_triangle</
=={{header|GAP}}==
<
SierpinskiTriangle := function(n)
local i, j, s, b;
Line 2,630 ⟶ 2,747:
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * * </
=={{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.
Line 2,650 ⟶ 2,767:
# Print rows 0 to 15, which is the order 4 triangle per the task.
print triangle(0,15)</
=={{header|Go}}==
"Δ" (Greek capital letter delta) looks good for grain, as does Unicode triangle, "△". ASCII "." and "^" are pleasing. "/\\", "´`", and "◢◣"" make interesting wide triangles.
<
import (
Line 2,679 ⟶ 2,796:
fmt.Println(r)
}
}</
=={{header|Golfscript}}==
Cambia el "3" a un número mayor para un triángulo más grande.
<
{{out}}
<pre>
Line 2,706 ⟶ 2,823:
=={{header|Groovy}}==
Solution:
<
stPoints = { order, base=[0,0] ->
def right = [base[0], base[1]+2**order]
Line 2,721 ⟶ 2,838:
stPoints(order).each { grid[it[0]][it[1]] = (order%10).toString() }
grid
}</
Test:
<
println()
stGrid(1).reverse().each { println it.sum() }
Line 2,736 ⟶ 2,853:
stGrid(5).reverse().each { println it.sum() }
println()
stGrid(6).reverse().each { println it.sum() }</
{{out}}
Line 2,876 ⟶ 2,993:
=={{header|Haskell}}==
<
sierpinski n = map ((space ++) . (++ space)) down ++
map (unwords . replicate 2) down
Line 2,882 ⟶ 2,999:
space = replicate (2 ^ (n - 1)) ' '
main = mapM_ putStrLn $ sierpinski 4</
{{out}}
<pre>
Line 2,903 ⟶ 3,020:
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]
Line 2,916 ⟶ 3,033:
main :: IO ()
main = mapM_ putStrLn $ sierpinski 4</
{{Out}}
<pre> ▲---------------
Line 2,937 ⟶ 3,054:
Using bitwise and between x and y coords:
<
sierpinski n = map row [m, m-1 .. 0] where
Line 2,945 ⟶ 3,062:
| otherwise = " "
main = mapM_ putStrLn $ sierpinski 4</
{{Trans|JavaScript}}
<
-- Top down, each row after the first is an XOR / Rule90 rewrite.
Line 2,973 ⟶ 3,090:
main :: IO ()
main = putStr $ sierpinski 4</
Or simply as a right fold:
<
sierpinski n =
foldr
Line 2,993 ⟶ 3,110:
main :: IO ()
main = (putStrLn . unlines . sierpinski) 4</
{{Out}}
Line 3,014 ⟶ 3,131:
=={{header|Haxe}}==
<
{
static function main()
Line 3,048 ⟶ 3,165:
}
}
}</
=={{header|Hoon}}==
<
=+ m=0
=+ o=(reap 1 '*')
Line 3,059 ⟶ 3,176:
++ top (turn o |=(l=@t (rap 3 gap l gap ~)))
++ bot (turn o |=(l=@t (rap 3 l ' ' l ~)))
--</
=={{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)
Line 3,077 ⟶ 3,194:
writes((y=1,"\n")|"",canvas[x,y]," ") # print
end</
{{libheader|Icon Programming Library}}
Line 3,096 ⟶ 3,213:
=={{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
Line 3,103 ⟶ 3,220:
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
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.
Line 3,122 ⟶ 3,239:
Replace translations.
Recursive solution.
<
public class SierpinskiTriangle {
Line 3,168 ⟶ 3,285:
}
</syntaxhighlight>
{{out}}
Line 3,192 ⟶ 3,309:
=={{header|JavaFX Script}}==
{{trans|Python}}
<
var down = ["*"];
var space = " ";
Line 3,205 ⟶ 3,322:
}
sierpinski(4);</
=={{header|JavaScript}}==
Line 3,215 ⟶ 3,332:
mapping the binary pattern to centred strings.
<
// Sierpinski triangle of order N constructed as
Line 3,273 ⟶ 3,390:
})(4);
</syntaxhighlight>
Output (N=4)
Line 3,296 ⟶ 3,413:
====Imperative====
<
var n = 1 << o,
line = new Array(2 * n),
Line 3,316 ⟶ 3,433:
document.write("<pre>\n");
triangle(6);
document.write("</pre>");</
===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 TRIANGLE ---------------
// sierpinski :: Int -> String
Line 3,330 ⟶ 3,449:
.reduce(
(xs, _, i) => {
const s =
return
...xs.map(x => `${x} ${x}`)
];
},
[
)
.join("\n");
//
return sierpinski(4);
})();</syntaxhighlight>
{{Trans|Haskell}}
Centering any preceding triangle block over two adjacent duplicates:
<
// ----- LINES OF SIERPINSKI TRIANGLE AT LEVEL N
// sierpinski :: Int -> [String]
const sierpTriangle = n =>
// Previous triangle centered with
0 < n ?
ap([
xs => ap([
)
])([" ", "-"])
.join(xs)
),
// above a pair of duplicates,
// placed one character apart.
map(s => `${s}+${s}`)
])([sierpTriangle(n - 1)])
.flat()
) : ["▲"];
// ---------------------- TEST -----------------------
const
// ---------------- GENERIC FUNCTIONS ----------------
//
// The sequential application of each of a list
// of functions to each of a list of values.
// apList([x => 2
// -> [2, 4, 6, 21, 22, 23]
xs => fs.flatMap(f => xs.map(f));
//
const
// A function defined by the right-to-left
// composition of all the functions in fs.
fs.reduce(
(f, g) => x => f(g(x)),
x => x
);
// map :: (a -> b) -> [a] -> [b]
// replicate :: Int -> a -> [a]
const replicate = n =>
// A list of n copies of x.
x => Array.from({
length: n
}, () => x);
// ---------------------- TEST -----------------------
return main();
})();</syntaxhighlight>
{{Out}}
<pre> ▲---------------
Line 3,429 ⟶ 3,556:
Or constructed as 2^N lines of Pascal's triangle mod 2,
and mapped to centred {1:asterisk, 0:space} strings.
<syntaxhighlight lang="javascript">(() => {
"use strict";
// --------------- SIERPINSKI TRIANGLE ---------------
// sierpinski :: Int -> [Bool]
// Reduce/folding from the last item (base of list)
// which has zero left indent.
//
`${a[1]} `
]), ["", ""])[0];
// pascalMod2Chars :: Int -> [[Char]]
const pascalMod2Chars = nRows =>
enumFromTo(1)(nRows - 1)
.reduce(sofar => {
const rows = sofar.slice(-1)[0];
// Rule 90 also
// relationship between left and right
)([" ", ...rows])([...rows, " "])
]);
}, [
["*"]
]);
// ---------------------- TEST -----------------------
const main = () =>
sierpinski(4);
// --------------------- GENERIC ---------------------
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
// A list constructed
// custom
// default tuple
xs => ys => xs.map(
(x, i) => f(x)(ys[i])
).slice(
0, Math.min(xs.length, ys.length)
);
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m =>
}, (_, i) => m + i);
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre> *
Line 3,515 ⟶ 3,647:
'''Works with gojq, the Go implementation of jq'''
'''Preliminaries'''
<syntaxhighlight lang="jq">def elementwise(f):
transpose | map(f) ;
# input: an array of decimal numbers
def bitwise_and:
# Input: an integer
# Output: a stream of 0s and 1s
def stream:
recurse(if . > 0 then ./2|floor else empty end) | . % 2 ;
# Input: a 0-1 array
def
reduce .[] as $c ( {power:1 , ans: 0};
.ans += ($c * .power) | .power *= 2 )
| .ans;
if any(.==0) then 0
else map([stream])
| (map(length) | min) as $min
| map( .[:$min] ) | elementwise(min) | toi
end;</syntaxhighlight>
<syntaxhighlight lang="jq">
def sierpinski:
pow(2; .) as $size
| range($size-1; -1; -1) as $y
| reduce range(0; $size - $y) as $x ( (" " * $y);
. + (if ([$x,$y]|bitwise_and) == 0 then "* " else " " end));
4 | sierpinski</syntaxhighlight>
{{out}}
As elsewhere.
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
x = fill(token, 1, 1)
for _ in 1:n
Line 3,585 ⟶ 3,700:
end
sierpinski(4) |> printsierpinski</
=={{header|Kotlin}}==
{{trans|C}}
<
const val ORDER = 4
Line 3,600 ⟶ 3,715:
println()
}
}</
{{out}}
Line 3,621 ⟶ 3,736:
* * * * * * * * * * * * * * * *
</pre>
=={{header|Lambdatalk}}==
===1) define===
<syntaxhighlight lang="scheme">
{def sierp
{def sierp.r
{lambda {:order :length :angle}
{if {= :order 0}
then M:length // move :length
else {sierp.r {- :order 1} // recurse
{/ :length 2}
{- :angle}}
T:angle // turn :angle
{sierp.r {- :order 1} // recurse
{/ :length 2}
{+ :angle}}
T:angle // turn :angle
{sierp.r {- :order 1} // recurse
{/ :length 2}
{- :angle}}
}}}
{lambda {:order :length}
{if {= {% :order 2} 0} // if :order is even
then {sierp.r :order :length 60} // recurse with 60°
else T60 // else turn 60°
{sierp.r :order :length -60} // recurse with -60°
}}}
-> sierp
</syntaxhighlight>
===2) draw===
Four curves drawn in 50ms on a PowerBookPro. using the turtle primitive.
<syntaxhighlight lang="scheme">
{svg {@ width="580" height="580" style="box-shadow:0 0 8px #000;"}
{polyline {@ points="{turtle 50 5 0 {sierp 1 570}}"
stroke="#ccc" fill="transparent" stroke-width="7"}}
{polyline {@ points="{turtle 50 5 0 {sierp 3 570}}"
stroke="#8ff" fill="transparent" stroke-width="5"}}
{polyline {@ points="{turtle 50 5 0 {sierp 5 570}}"
stroke="#f88" fill="transparent" stroke-width="3"}}
{polyline {@ points="{turtle 50 5 0 {sierp 7 570}}"
stroke="#000" fill="transparent" stroke-width="1"}}
</syntaxhighlight>
===3) output===
See http://lambdaway.free.fr/lambdawalks/?view=sierpinsky
=={{header|Liberty BASIC}}==
<
call triangle 1, 1, nOrder
end
Line 3,637 ⟶ 3,798:
call triangle x+length*2, y+length, n
END IF
END SUB</
=={{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.
Line 3,653 ⟶ 3,814:
]
print []
]</
=={{header|Lua}}==
Ported from the list-comprehension Python version.
<
lines = {}
lines[1] = '*'
Line 3,674 ⟶ 3,835:
end
print(sierpinski(4))</
{{out}}
<pre>
Line 3,696 ⟶ 3,857:
=={{header|Maple}}==
<
local i, j, values, position;
values := [ seq(" ",i=1..2^n-1), "*" ];
Line 3,710 ⟶ 3,871:
printf("%s\n",cat(op(convert(values, list))));
end do:
end proc:</
{{out}}
<pre>
Line 3,733 ⟶ 3,894:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Cellular automaton (rule 90) based solution:
<
Using built-in function:
<syntaxhighlight lang
=={{header|MATLAB}}==
STRING was introduced in version R2016b.
<
d = string('*');
for k = 0 : n - 1
Line 3,746 ⟶ 3,907:
end
disp(d.join(char(10)))
</syntaxhighlight>
{{out}}
<pre>
Line 3,767 ⟶ 3,928:
</pre>
===Cellular Automaton Version===
<
tr = + ~(-n : n);
for k = 1:n
tr(k + 1, :) = bitget(90, 1 + filter2([4 2 1], tr(k, :)));
end
char(10 * tr + 32)</
===Mixed Version===
<
=={{header|NetRexx}}==
{{trans|Java}}
<
options replace format comments java crossref symbols nobinary
Line 3,818 ⟶ 3,979:
end row
return
</syntaxhighlight>
{{out}}
<pre>
Line 3,841 ⟶ 4,002:
=={{header|Nim}}==
{{trans|C}}
<
for y in countdown(size, 0):
Line 3,851 ⟶ 4,012:
else:
stdout.write "* "
stdout.write "\n"</
{{out}}
Line 3,872 ⟶ 4,033:
=={{header|OCaml}}==
<
let rec loop down space n =
if n = 0 then
Line 3,884 ⟶ 4,045:
let () =
List.iter print_endline (sierpinski 4)</
=={{header|Oforth}}==
Line 3,892 ⟶ 4,053:
automat(rule, n) runs cellular automaton for rule "rule" for n generations.
<
| i |
StringBuffer new
Line 3,907 ⟶ 4,068:
: sierpinskiTriangle(n)
90 4 n * automat ;</
{{out}}
Line 3,933 ⟶ 4,094:
=={{header|Oz}}==
<
fun {NextTriangle Triangle}
Sp = {Spaces {Length Triangle}}
Line 3,951 ⟶ 4,112:
SierpinskiTriangles = {Iterate NextTriangle ["*"]}
in
{ForAll {Nth SierpinskiTriangles 5} System.showInfo}</
=={{header|PARI/GP}}==
{{trans|C}}
<
my(s=2^n-1);
forstep(y=s,0,-1,
Line 3,965 ⟶ 4,126:
)
};
Sierpinski(4)</
{{out}}
<pre> *
Line 3,987 ⟶ 4,148:
{{trans|C}}
{{works with|Free Pascal}}
<
function ipow(b, n : Integer) : Integer;
Line 4,004 ⟶ 4,165:
else
truth := false
end;</
<
var
l, i : Integer;
Line 4,046 ⟶ 4,207:
writeln(b)
end
end;</
<
triangle(4)
end.</
=={{header|Perl}}==
===version 1===
<
my ($n) = @_;
my @down = '*';
Line 4,065 ⟶ 4,226:
}
print "$_\n" foreach sierpinski 4;</
===one-liner===
<
perl -le '$l=40;$l2="!" x $l;substr+($l2^=$l2),$l/2,1,"\xFF";for(1..16){local $_=$l2;y/\0\xFF/ */;print;($lf,$rt)=map{substr $l2 x 2,$_%$l,$l;}1,-1;$l2=$lf^$rt;select undef,undef,undef,.1;}'</
=={{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>
Line 4,088 ⟶ 4,249:
<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">
Line 4,156 ⟶ 4,317:
=={{header|Phixmonti}}==
<
2 swap power 1 - var lim
lim 0 -1 3 tolist for
Line 4,170 ⟶ 4,331:
5 for
sierpinski
endfor</
=={{header|PHP}}==
Line 4,176 ⟶ 4,337:
{{Trans|JavaScript}}
<
function sierpinskiTriangle($order) {
Line 4,200 ⟶ 4,361:
sierpinskiTriangle(4);
</syntaxhighlight>
{{out}}
Line 4,220 ⟶ 4,381:
# # # # # # # # # # # # # # # #
</pre>
=={{header|Picat}}==
{{trans|E}}
<syntaxhighlight lang="picat">go =>
foreach(N in 1..4)
sierpinski(N),
nl
end,
nl.
sierpinski(N) =>
Size = 2**N,
foreach(Y in Size-1..-1..0)
printf("%s", [' ' : _I in 1..Y]),
foreach(X in 0..Size-Y-1)
printf("%s ", cond(X /\ Y == 0, "*", " "))
end,
nl
end.</syntaxhighlight>
{{out}}
<pre> *
* *
*
* *
* *
* * * *
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * * </pre>
=={{header|PicoLisp}}==
{{trans|Python}}
<
(let (D '("*") S " ")
(do N
Line 4,233 ⟶ 4,449:
D ) )
(mapc prinl (sierpinski 4))</
=={{header|PL/I}}==
<
declare t (79,79) char (1);
declare (i, j, k) fixed binary;
Line 4,284 ⟶ 4,500:
end make_triangle;
end sierpinski;</
=={{header|PL/M}}==
<
DECLARE ORDER LITERALLY '4';
Line 4,323 ⟶ 4,539:
CALL BDOS(0,0);
EOF</
{{out}}
<pre> *
Line 4,345 ⟶ 4,561:
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;
Line 4,365 ⟶ 4,581:
enddefine;
triangle(4);</
Alternative solution, keeping all triangle as list of strings
<
lvars acc = ['*'], spaces = ' ', j;
for j from 1 to n do
Line 4,378 ⟶ 4,594:
enddefine;
triangle2(4);</
=={{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
Line 4,396 ⟶ 4,612:
0 1 8 { 300 300 scale 0 1 12 div moveto
X + F + F fill showpage } for
%%EOF</
=={{header|PowerShell}}==
{{Trans|JavaScript}}
<
$n = [Math]::Pow(2, $o)
$line = ,' '*(2*$n+1)
Line 4,420 ⟶ 4,636:
$line[$n+$i+1] = '█'
}
}</
=={{header|Processing}}==
===Characters in drawing canvas version===
<
size(410, 230);
background(255);
Line 4,439 ⟶ 4,655:
sTriangle(x+l*2, y+l, l/2, n-1);
}
}</
===Text in console version===
{{trans|Java}}
<
print(getSierpinskiTriangle(3));
}
Line 4,478 ⟶ 4,694:
return ns;
}
</syntaxhighlight>
=={{header|Prolog}}==
Works with SWI-Prolog;
<
Len is 2 ** (N+1) - 1,
length(L, Len),
Line 4,522 ⟶ 4,738:
rule_90(' ',' ','*', '*').
rule_90(' ',' ',' ', ' ').
</syntaxhighlight>
{{out}}
<pre> ?- sierpinski_triangle(4).
Line 4,544 ⟶ 4,760:
=={{header|PureBasic}}==
<
If N = 0
DrawText( Y,X, "*",#Blue)
Line 4,563 ⟶ 4,779:
Repeat
Until WaitWindowEvent()=#PB_Event_CloseWindow
End</
=={{header|Python}}==
<
d = ["*"]
for i in xrange(n):
Line 4,573 ⟶ 4,789:
return d
print "\n".join(sierpinski(4))</
Or, using fold / reduce {{works with|Python|3.x}}
<
def sierpinski(n):
Line 4,587 ⟶ 4,803:
return functools.reduce(aggregate, range(n), ["*"])
print("\n".join(sierpinski(4)))</
and fold/reduce, wrapped as concatMap, can provide the list comprehensions too:
<
from functools import reduce
Line 4,620 ⟶ 4,836:
print(sierpinski(4))</
{{Out}}
<pre> *
Line 4,641 ⟶ 4,857:
Use Python's long integer and bit operator to make an infinite triangle:
<
while True:
print(bin(x)[2:].replace('0', ' '))
x ^= x<<1</
=={{header|Quackery}}==
Line 4,650 ⟶ 4,866:
{{trans|Forth}}
<
iff char * else space
emit
Line 4,664 ⟶ 4,880:
2drop ] is triangle ( order --> )
4 triangle</
{{out}}
Line 4,688 ⟶ 4,904:
=={{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))
Line 4,700 ⟶ 4,916:
}
}
sierpinski.triangle(5)</
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="")))
}
cat(sierpinski.triangle(5),sep="\n")</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(define (sierpinski n)
Line 4,720 ⟶ 4,936:
(map (λ(x) (~a x " " x)) prev)))))
(for-each displayln (sierpinski 5))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{trans|Perl}}
<syntaxhighlight lang="raku"
my @down = '*';
my $space = ' ';
Line 4,735 ⟶ 4,951:
}
.say for sierpinski 4;</
=={{header|REXX}}==
<
parse arg n mark . /*get the order of Sierpinski triangle.*/
if n=='' | n=="," then n=4 /*Not specified? Then use the default.*/
Line 4,754 ⟶ 4,970:
say z /*display a line of the triangle. */
end /*j*/ /* [↑] finished showing triangle. */
/*stick a fork in it, we're all done. */</
'''output''' when using the default input of order: <tt> 4 </tt>
Line 4,959 ⟶ 5,175:
=={{header|Ring}}==
<
# Project : Sierpinski triangle
Line 4,982 ⟶ 5,198:
triangle(x+length*2, y+length, n)
ok
</syntaxhighlight>
Output:
<pre>
Line 5,005 ⟶ 5,221:
=={{header|Ruby}}==
From the command line:
<
or, {{trans|Python}}
<
triangle = ["*"]
n.times do |i|
Line 5,018 ⟶ 5,234:
end
puts sierpinski_triangle(4)</
Using fold / reduce (aka. inject):
<
(0...n).inject(["*"]) {|triangle, i|
space = " " * (2**i)
Line 5,029 ⟶ 5,245:
end
puts sierpinski_triangle(4)</
=={{header|Run BASIC}}==
<
dim xy$(40)
for i = 1 to 40
Line 5,053 ⟶ 5,269:
call triangle x+length*2, y+length, n
END IF
END SUB</
<pre> *
* *
Line 5,071 ⟶ 5,287:
* * * * * * * * * * * * * * * *</pre>
=={{header|Rust}}==
<
use std::iter::repeat;
Line 5,109 ⟶ 5,325:
}
</syntaxhighlight>
{{out}}
<pre>
Line 5,132 ⟶ 5,348:
=={{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)
Line 5,144 ⟶ 5,360:
(bitmap << 1) ^ bitmap
}
}</
The Haskell version:
<
def sierpinski(n: Int): List[String] = {
lazy val down = sierpinski(n - 1)
Line 5,158 ⟶ 5,374:
}
sierpinski(n) foreach println
}</
=={{header|Scheme}}==
{{trans|Haskell}}
<
(for-each
(lambda (x) (display (list->string x)) (newline))
Line 5,173 ⟶ 5,389:
(map (lambda (x) (append x (list #\ ) x)) acc))
(append spaces spaces)
(- n 1))))))</
=={{header|Seed7}}==
<
const func array string: sierpinski (in integer: n) is func
Line 5,203 ⟶ 5,419:
begin
writeln(join(sierpinski(4), "\n"));
end func;</
=={{header|SETL}}==
<syntaxhighlight lang="setl">program sierpinski;
const size = 4;
loop for i in [0..size*4-1] do
putchar(' ' * (size*4-1-i));
c := 1;
loop for j in [0..i] do
putchar(if c mod 2=0 then " " else " *" end);
c := c*(i-j) div (j+1);
end loop;
print;
end loop;
end program;</syntaxhighlight>
{{out}}
<pre> *
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *</pre>
=={{header|Sidef}}==
<
var triangle = ['*']
{ |i|
Line 5,216 ⟶ 5,464:
}
say sierpinski_triangle(4)</
=={{header|Swift}}==
{{trans|Java}}
<syntaxhighlight lang="text">import Foundation
// Easy get/set of charAt
Line 5,263 ⟶ 5,511:
line[n + i + 1] = "*"
}
}</
=={{header|Tcl}}==
{{trans|Perl}}
<
proc map {lambda list} {
Line 5,289 ⟶ 5,537:
}
puts [sierpinski_triangle 4]</
=={{header|TI-83 BASIC}}==
Uses Wolfram Rule 90.
<
:ClrHome
:Output(1,8,"^")
Line 5,323 ⟶ 5,571:
:L3→L2
:End
</syntaxhighlight>
=={{header|uBasic/4tH}}==
<syntaxhighlight lang="text">Input "Triangle order: ";n
n = 2^n
Line 5,347 ⟶ 5,595:
Print
Next
End</
=={{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
`k`ki``s`k`s`k`si``s`kkk</
This produces an infinite, left-justified triangle:
<pre style="height:30ex;overflow:scroll;">
Line 5,397 ⟶ 5,645:
=={{header|Ursala}}==
the straightforward recursive solution
<
triangle = ~&a^?\<<&>>! ^|RNSiDlrTSPxSxNiCK9xSx4NiCSplrTSPT/~& predecessor</
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>
sierpinski = iota; --<&>@NS; iota; ^H/evolve@z @NS ^T/~& :/&</
an example of each (converting from booleans to characters)
<
examples = mat0 ~&?(`*!,` !)*** <sierpinski3,triangle4></
{{out}}
<pre style="height:30ex;overflow:scroll;">
Line 5,439 ⟶ 5,687:
* * * * * * * * * * * * * * * *
</pre>
=={{header|Uxntal}}==
<syntaxhighlight lang="Uxntal">( uxncli sierpinski.rom )
|100 @on-reset ( -> )
#10 STHk #01 SUB
&ver ( -- )
DUP
#00 EQUk ?{
&pad ( -- )
#2018 DEO
INC GTHk ?&pad
} POP
#00
&fill
ANDk #202a ROT ?{ SWP } POP #18 DEO
#2018 DEO
INC ADDk STHkr LTH ?&fill
POP2
#0a18 DEO
#01 SUB DUP #ff NEQ ?&ver
POP POPr
BRK</syntaxhighlight>
The triangle size is given by the first instruction <code>#10</code>, representing the number of rows to print.
=={{header|VBA}}==
{{Trans|Phix}}<
Dim lim As Integer: lim = 2 ^ n - 1
For y = lim To 0 Step -1
Line 5,456 ⟶ 5,731:
sierpinski i
Next i
End Sub</
<pre style="font-size: 4px">
#
Line 5,584 ⟶ 5,859:
=={{header|VBScript}}==
{{trans|PowerShell}}
<syntaxhighlight lang="vb">
Sub triangle(o)
n = 2 ^ o
Line 5,612 ⟶ 5,887:
triangle(4)
</syntaxhighlight>
=={{header|Vedit macro language}}==
Line 5,619 ⟶ 5,894:
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
Line 5,636 ⟶ 5,911:
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)
Line 5,669 ⟶ 5,944:
Num_Pop(1,4)
}
Return</
=={{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}}
Line 5,702 ⟶ 5,977:
=={{header|X86 Assembly}}==
Translation of XPL0. Assemble with tasm, tlink /t
<
.code
.486
Line 5,729 ⟶ 6,004:
loop tri10 ;next I
ret
end start</
{{out}}
Line 5,752 ⟶ 6,027:
=={{header|XPL0}}==
<
def Order=4, Size=1<<Order;
int S1, S2, I;
Line 5,764 ⟶ 6,039:
S2:= S2 xor S1>>1;
];
]</
{{out}}
Line 5,788 ⟶ 6,063:
=={{header|Yabasic}}==
{{trans|Phix}}
<
local i, s$
Line 5,813 ⟶ 6,088:
sierpinski(i)
next
</syntaxhighlight>
=={{header|Zig}}==
{{trans|C}}
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
const size: u16 = 1 << 4;
var y = size;
while (y > 0) {
y -= 1;
for (0..y) |_| try stdout.writeByte(' ');
for (0..size - y) |x| try stdout.writeAll(if (x & y != 0) " " else "* ");
try stdout.writeByte('\n');
}
}</syntaxhighlight>
===Automaton===
{{trans|C}}
{{works with|Zig|0.11.0dev}}
<syntaxhighlight lang="zig">const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
try sierpinski_triangle(allocator, stdout, 4);
}</syntaxhighlight><syntaxhighlight lang="zig">inline fn truth(x: u8) bool {
return x == '*';
}</syntaxhighlight><syntaxhighlight lang="zig">fn rule_90(allocator: Allocator, evstr: []u8) !void {
var cp = try allocator.dupe(u8, evstr);
defer allocator.free(cp); // free does "free" for last node in arena
for (evstr, 0..) |*evptr, i| {
var s = [2]bool{
if (i == 0) false else truth(cp[i - 1]),
if (i + 1 == evstr.len) false else truth(cp[i + 1]),
};
evptr.* = if ((s[0] and !s[1]) or (!s[0] and s[1])) '*' else ' ';
}
}</syntaxhighlight><syntaxhighlight lang="zig">fn sierpinski_triangle(allocator: Allocator, writer: anytype, n: u8) !void {
const len = std.math.shl(usize, 1, n + 1);
var b = try allocator.alloc(u8, len);
defer allocator.free(b);
for (b) |*ptr| ptr.* = ' ';
b[len >> 1] = '*';
try writer.print("{s}\n", .{b});
for (0..len / 2 - 1) |_| {
try rule_90(allocator, b);
try writer.print("{s}\n", .{b});
}
}</syntaxhighlight>
=={{header|zkl}}==
{{trans|D}}
<
foreach n in (level + 1){
sp:=" "*(2).pow(n);
Line 5,823 ⟶ 6,158:
d.apply(fcn(a){ String(a," ",a) }));
}
d.concat("\n").println();</
{{out}}
<pre>
|