Data commit

Task/Sierpinski-triangle/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Sierpinski_triangle
+note: Fractals

Task/Sierpinski-triangle/00-TASK.txt

@@ -0,0 +1,31 @@
+;Task
+Produce an ASCII representation of a [[wp:Sierpinski triangle|Sierpinski triangle]] of order   '''N'''.  
+
+
+;Example
+The Sierpinski triangle of order   '''4'''   should look like this: 
+<pre>
+                       *
+                      * *
+                     *   *
+                    * * * *
+                   *       *
+                  * *     * *
+                 *   *   *   *
+                * * * * * * * *
+               *               *
+              * *             * *
+             *   *           *   *
+            * * * *         * * * *
+           *       *       *       *
+          * *     * *     * *     * *
+         *   *   *   *   *   *   *   *
+        * * * * * * * * * * * * * * * *
+</pre>
+
+
+;Related tasks
+* [[Sierpinski triangle/Graphical]] for graphics images of this pattern.  
+* [[Sierpinski carpet]]
+<br><br>
+

Task/Sierpinski-triangle/11l/sierpinski-triangle.11l

@@ -0,0 +1,8 @@
+F sierpinski(n)
+   V d = [String(‘*’)]
+   L(i) 0 .< n
+      V sp = ‘ ’ * (2 ^ i)
+      d = d.map(x -> @sp‘’x‘’@sp) [+] d.map(x -> x‘ ’x)
+   R d
+
+print(sierpinski(4).join("\n"))

Task/Sierpinski-triangle/8080-Assembly/sierpinski-triangle.8080

@@ -0,0 +1,61 @@
+argmt:	equ	5Dh	; Command line argument
+puts:	equ	9	; CP/M syscall to print a string
+putch:	equ	2	; CP/M syscall to print a character
+	org	100h
+	mvi	b,4	; Default order is 4
+	mvi	e,' '	; Keep space in E since we're saving it anyway
+	lda	argmt	; Argument given?
+	cmp	e	; If not, use default
+	jz	start
+	sui	'0'	; Make sure given N makes sense
+	cpi	3	; <3?
+	jc	start
+	cpi	8	; >=8?
+	jnc	start
+	mov	b,a
+start:	mvi	a,1	; Find size (2 ** order)
+shift:	rlc
+	dcr	b
+	jnz	shift
+	mov	b,a	; B = size
+	mov	c,a	; C = current line
+line:	mov	d,c	; D = column
+indent:	mov	a,e	; Indent line
+	call	chout
+	dcr	d
+	jnz	indent	
+column:	mov	a,c	; line + col <= size?
+	add	d
+	dcr	a
+	cmp	b
+	jnc 	cdone
+	mov	a,c	; (line - 1) & col == 0?
+	dcr	a
+	ana	d
+	mov	a,e	; space if not, star if so
+	jnz	print
+	mvi	a,'*'
+print:	call	chout
+	mov	a,e
+	call	chout
+	inr	d
+	jmp	column
+cdone:	push	b	; done, print newline
+	push 	d
+	lxi	d,nl
+	mvi	c,puts
+	call	5
+	pop	d
+	pop	b
+	dcr	c	; next line
+	jnz	line
+	ret
+chout:	push	b	; save BC and DE
+	push	d
+	mov	e,a	; print character
+	mvi	c,putch
+	call	5
+	pop	d	; restore BC and DE
+	pop	b
+	ret
+nl:	db	13,10,'$'

Task/Sierpinski-triangle/8086-Assembly/sierpinski-triangle.8086

@@ -0,0 +1,42 @@
+putch:	equ	2		; MS-DOS syscall to print character
+puts:	equ	9 		; MS-DOS syscall to print string
+argmt:	equ	5Dh		; MS-DOS still has FCB in same place as CP/M
+	cpu	8086
+	org	100h
+section	.text
+	mov	cx,4		; Default order is 4
+	mov	al,[argmt]
+	sub	al,'3'		; Argument is there and makes sense? (3 - 7)
+	cmp	al,7-3
+	ja	start		; If not, use default
+	add	al,3		; If so, use it
+	mov	cl,al
+start:	mov	bl,1		; Let BL be the size (2 ** order)
+	shl	bl,cl
+	mov	bh,bl		; Let BH be the current line
+line:	mov	cl,bh		; Let CL be the column
+	mov	dl,' '		; Indent line with spaces
+	mov	ah,putch
+indent:	int	21h
+	loop	indent
+column:	mov	al,cl		; line + column <= size?
+	add	al,bh
+	cmp	al,bl
+	ja	.done		; then column is done
+	mov	al,bh		; (line - 1) & column == 0?
+	dec	al
+	test	al,cl
+	jnz	.print		; space if not, star if so
+	mov	dl,'*'
+.print:	int	21h
+	mov	dl,' '
+	int	21h
+	inc	cx		; next column
+	jmp	column
+.done:	mov	dx,nl		; done, print newline
+	mov	ah,puts
+	int	21h
+	dec	bh		; next line
+	jnz	line
+	ret
+nl:	db	13,10,'$'

Task/Sierpinski-triangle/ACL2/sierpinski-triangle.acl2

@@ -0,0 +1,39 @@
+(defun pascal-row (prev)
+   (if (endp (rest prev))
+       (list 1)
+       (cons (+ (first prev) (second prev))
+             (pascal-row (rest prev)))))
+
+(defun pascal-triangle-r (rows prev)
+   (if (zp rows)
+       nil
+       (let ((curr (cons 1 (pascal-row prev))))
+          (cons curr (pascal-triangle-r (1- rows) curr)))))
+
+(defun pascal-triangle (rows)
+   (cons (list 1)
+         (pascal-triangle-r rows (list 1))))
+
+(defun print-odds-row (row)
+   (if (endp row)
+       (cw "~%")
+       (prog2$ (cw (if (oddp (first row)) "[]" "  "))
+               (print-odds-row (rest row)))))
+
+(defun print-spaces (n)
+   (if (zp n)
+       nil
+       (prog2$ (cw " ")
+               (print-spaces (1- n)))))
+
+(defun print-odds (triangle height)
+   (if (endp triangle)
+       nil
+       (progn$ (print-spaces height)
+               (print-odds-row (first triangle))
+               (print-odds (rest triangle) (1- height)))))
+
+(defun print-sierpenski (levels)
+   (let ((height (1- (expt 2 levels))))
+      (print-odds (pascal-triangle height)
+                  height)))

Task/Sierpinski-triangle/ALGOL-68/sierpinski-triangle.alg

@@ -0,0 +1,16 @@
+PROC sierpinski = (INT n)[]STRING: (
+    FLEX[0]STRING d := "*";
+    FOR i TO n DO
+        [UPB d * 2]STRING next;
+        STRING sp := " " * (2 ** (i-1));
+        FOR x TO UPB d DO
+          STRING dx = d[x];
+          next[x] := sp+dx+sp;
+          next[UPB d+x] := dx+" "+dx
+        OD;
+        d := next
+    OD;
+    d
+);
+
+printf(($gl$,sierpinski(4)))

Task/Sierpinski-triangle/ALGOL-W/sierpinski-triangle.alg

@@ -0,0 +1,14 @@
+begin
+    integer SIZE;
+    SIZE := 16;
+    for y := SIZE - 1 step - 1 until 0 do begin
+        integer x;
+        for i := 0 until y - 1 do writeon( " " );
+        x := 0;
+        while x + y < SIZE do begin
+            writeon( if number( bitstring( x ) and bitstring( y ) ) not = 0 then "  " else "* " );
+            x := x + 1
+        end while_x_plus_y_lt_SIZE ;
+        write();
+    end for_y
+end.

Task/Sierpinski-triangle/APL/sierpinski-triangle.apl

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

Task/Sierpinski-triangle/ATS/sierpinski-triangle.ats

@@ -0,0 +1,42 @@
+(* ****** ****** *)
+//
+// How to compile:
+//
+// patscc -DATS_MEMALLOC_LIBC -o sierpinski sierpinski.dats
+//
+(* ****** ****** *)
+//
+#include
+"share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+#define SIZE 16
+
+implement
+main0 () =
+{
+//
+var x: int
+//
+val () =
+for (x := SIZE-1; x >= 0; x := x-1)
+{
+  var i: int
+  val () =
+  for (i := 0; i < x; i := i+1)
+  {
+    val () = print_char(' ')
+  }
+  var y: int
+  val () =
+  for (y := 0; y + x < SIZE; y := y+1)
+  {
+    val y = g0int2uint_int_uint(y)
+    val x = g0int2uint_int_uint(x)
+    val () = print_string(if (x land y) != 0 then "  " else "* ")
+  }
+  val ((*flushed*)) = print_newline()
+}
+//
+} (* end of [main0] *)

Task/Sierpinski-triangle/AWK/sierpinski-triangle.awk

@@ -0,0 +1,23 @@
+# WST.AWK - Waclaw Sierpinski's triangle contributed by Dan Nielsen
+# syntax: GAWK -f WST.AWK [-v X=anychar] iterations
+# example: GAWK -f WST.AWK -v X=* 2
+BEGIN {
+    n = ARGV[1] + 0 # iterations
+    if (n !~ /^[0-9]+$/) { exit(1) }
+    if (n == 0) { width = 3 }
+    row = split("X,X X,X   X,X X X X",A,",") # seed the array
+    for (i=1; i<=n; i++) { # build triangle
+      width = length(A[row])
+      for (j=1; j<=row; j++) {
+        str = A[j]
+        A[j+row] = sprintf("%-*s %-*s",width,str,width,str)
+      }
+      row *= 2
+    }
+    for (j=1; j<=row; j++) { # print triangle
+      if (X != "") { gsub(/X/,substr(X,1,1),A[j]) }
+      sub(/ +$/,"",A[j])
+      printf("%*s%s\n",width-j+1,"",A[j])
+    }
+    exit(0)
+}

Task/Sierpinski-triangle/Action-/sierpinski-triangle.action

@@ -0,0 +1,26 @@
+PROC Main()
+  BYTE x,y,size=[16]
+
+  Graphics(0)
+  PutE() PutE()
+
+  y=size-1
+  DO
+    FOR x=1 TO y+2
+    DO Put(' ) OD
+
+    FOR x=0 TO size-y-1
+    DO
+      IF (x&y)=0 THEN
+        Print("* ")
+      ELSE
+        Print("  ")
+      FI
+    OD
+    PutE()
+
+    IF y=0 THEN
+      EXIT
+    FI
+    y==-1
+  OD

Task/Sierpinski-triangle/Ada/sierpinski-triangle-1.ada

@@ -0,0 +1,53 @@
+with Ada.Text_Io; use Ada.Text_Io;
+with Ada.Strings.Fixed;
+with Interfaces; use Interfaces;
+
+procedure Sieteri_Triangles is
+   subtype Practical_Order is Unsigned_32 range 0..4;
+
+
+   function Pow(X : Unsigned_32; N : Unsigned_32) return Unsigned_32 is
+   begin
+      if N = 0 then
+         return 1;
+      else
+         return X * Pow(X, N - 1);
+      end if;
+   end Pow;
+
+   procedure Print(Item : Unsigned_32) is
+      use Ada.Strings.Fixed;
+      package Ord_Io is new Ada.Text_Io.Modular_Io(Unsigned_32);
+      use Ord_Io;
+      Temp : String(1..36) := (others => ' ');
+      First : Positive;
+      Last  : Positive;
+   begin
+      Put(To => Temp, Item => Item, Base => 2);
+      First := Index(Temp, "#") + 1;
+      Last  := Index(Temp(First..Temp'Last), "#") - 1;
+      for I in reverse First..Last loop
+         if Temp(I) = '0' then
+            Put(' ');
+         else
+            Put(Temp(I));
+         end if;
+      end loop;
+      New_Line;
+   end Print;
+
+   procedure Sierpinski (N : Practical_Order) is
+      Size : Unsigned_32 := Pow(2, N);
+      V : Unsigned_32 := Pow(2, Size);
+   begin
+      for I in 0..Size - 1 loop
+         Print(V);
+         V := Shift_Left(V, 1) xor Shift_Right(V,1);
+      end loop;
+   end Sierpinski;
+
+begin
+   for N in Practical_Order loop
+      Sierpinski(N);
+   end loop;
+end Sieteri_Triangles;

Task/Sierpinski-triangle/Ada/sierpinski-triangle-2.ada

@@ -0,0 +1,28 @@
+with Ada.Command_Line;
+with Ada.Text_IO;
+
+procedure Main is
+   subtype Order is Natural range 1 .. 32;
+   type Mod_Int is mod 2 ** Order'Last;
+
+   procedure Sierpinski (N : Order) is
+   begin
+      for Line in Mod_Int range 0 .. 2 ** N - 1 loop
+         for Col in Mod_Int range 0 .. 2 ** N - 1 loop
+            if (Line and Col) = 0 then
+               Ada.Text_IO.Put ('X');
+            else
+               Ada.Text_IO.Put (' ');
+            end if;
+         end loop;
+         Ada.Text_IO.New_Line;
+      end loop;
+   end Sierpinski;
+
+   N : Order := 4;
+begin
+   if Ada.Command_Line.Argument_Count = 1 then
+      N := Order'Value (Ada.Command_Line.Argument (1));
+   end if;
+   Sierpinski (N);
+end Main;

Task/Sierpinski-triangle/AppleScript/sierpinski-triangle-1.applescript

@@ -0,0 +1,103 @@
+------------------- SIERPINKSI TRIANGLE ------------------
+
+-- sierpinski :: Int -> [String]
+on sierpinski(n)
+    if n > 0 then
+        set previous to sierpinski(n - 1)
+        set padding to replicate(2 ^ (n - 1), space)
+
+        script alignedCentre
+            on |λ|(s)
+                concat(padding & s & padding)
+            end |λ|
+        end script
+
+        script adjacentDuplicates
+            on |λ|(s)
+                unwords(replicate(2, s))
+            end |λ|
+        end script
+
+        -- Previous triangle block centered,
+        -- and placed on 2 adjacent duplicates.
+        map(alignedCentre, previous) & map(adjacentDuplicates, previous)
+    else
+        {"*"}
+    end if
+end sierpinski
+
+
+--------------------------- TEST -------------------------
+on run
+    unlines(sierpinski(4))
+end run
+
+-------------------- GENERIC FUNCTIONS -------------------
+
+-- concat :: [[a]] -> [a] | [String] -> String
+on concat(xs)
+    if length of xs > 0 and class of (item 1 of xs) is string then
+        set acc to ""
+    else
+        set acc to {}
+    end if
+    repeat with i from 1 to length of xs
+        set acc to acc & item i of xs
+    end repeat
+    acc
+end concat
+
+-- intercalate :: Text -> [Text] -> Text
+on intercalate(strText, lstText)
+    set {dlm, my text item delimiters} to {my text item delimiters, strText}
+    set strJoined to lstText as text
+    set my text item delimiters to dlm
+    return strJoined
+end intercalate
+
+-- map :: (a -> b) -> [a] -> [b]
+on map(f, xs)
+    tell mReturn(f)
+        set lng to length of xs
+        set lst to {}
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, i, xs)
+        end repeat
+        return lst
+    end tell
+end map
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn
+
+-- replicate :: Int -> a -> [a]
+on replicate(n, a)
+    set out to {}
+    if n < 1 then return out
+    set dbl to {a}
+
+    repeat while (n > 1)
+        if (n mod 2) > 0 then set out to out & dbl
+        set n to (n div 2)
+        set dbl to (dbl & dbl)
+    end repeat
+    return out & dbl
+end replicate
+
+-- unlines, unwords :: [String] -> String
+on unlines(xs)
+    intercalate(linefeed, xs)
+end unlines
+
+on unwords(xs)
+    intercalate(space, xs)
+end unwords

Task/Sierpinski-triangle/AppleScript/sierpinski-triangle-2.applescript

@@ -0,0 +1,147 @@
+----------- SIERPINSKI TRIANGLE BY XOR / RULE 90 ---------
+
+-- sierpinskiTriangle :: Int -> String
+on sierpinskiTriangle(intOrder)
+
+    -- A Sierpinski triangle of order N
+    -- is a Pascal triangle (of N^2 rows)
+    -- mod 2
+
+    -- pascalModTwo :: Int -> [[String]]
+    script pascalModTwo
+        on |λ|(intRows)
+
+            -- addRow [[Int]] -> [[Int]]
+            script addRow
+
+                -- nextRow :: [Int] -> [Int]
+                on nextRow(row)
+                    -- The composition of AsciiBinary . mod two . add
+                    -- is reduced here to a rule from
+                    -- two parent characters above,
+                    -- to the child character below.
+
+                    -- Rule 90 also reduces to this XOR relationship
+                    -- between left and right neighbours.
+
+                    -- rule :: Character -> Character -> Character
+                    script rule
+                        on |λ|(a, b)
+                            if a = b then
+                                space
+                            else
+                                "*"
+                            end if
+                        end |λ|
+                    end script
+
+                    zipWith(rule, {" "} & row, row & {" "})
+                end nextRow
+
+                on |λ|(xs)
+                    xs & {nextRow(item -1 of xs)}
+                end |λ|
+            end script
+
+            foldr(addRow, {{"*"}}, enumFromTo(1, intRows - 1))
+        end |λ|
+    end script
+
+    -- The centring foldr (fold right) below starts from the end of the list,
+    -- (the base of the triangle) which has zero indent.
+
+    -- Each preceding row has one more indent space than the row below it.
+
+    script centred
+        on |λ|(sofar, row)
+            set strIndent to indent of sofar
+
+            {triangle:strIndent & intercalate(space, row) & linefeed & ¬
+                triangle of sofar, indent:strIndent & space}
+        end |λ|
+    end script
+
+    triangle of foldr(centred, {triangle:"", indent:""}, ¬
+        pascalModTwo's |λ|(intOrder ^ 2))
+
+end sierpinskiTriangle
+
+
+--------------------------- TEST -------------------------
+on run
+
+    set strTriangle to sierpinskiTriangle(4)
+
+    set the clipboard to strTriangle
+    strTriangle
+end run
+
+
+-------------------- GENERIC FUNCTIONS -------------------
+
+-- enumFromTo :: Int -> Int -> [Int]
+on enumFromTo(m, n)
+    if m > n then
+        set d to -1
+    else
+        set d to 1
+    end if
+    set lst to {}
+    repeat with i from m to n by d
+        set end of lst to i
+    end repeat
+    return lst
+end enumFromTo
+
+-- foldr :: (a -> b -> a) -> a -> [b] -> a
+on foldr(f, startValue, xs)
+    tell mReturn(f)
+        set v to startValue
+        set lng to length of xs
+        repeat with i from lng to 1 by -1
+            set v to |λ|(v, item i of xs, i, xs)
+        end repeat
+        return v
+    end tell
+end foldr
+
+-- intercalate :: Text -> [Text] -> Text
+on intercalate(strText, lstText)
+    set {dlm, my text item delimiters} to {my text item delimiters, strText}
+    set strJoined to lstText as text
+    set my text item delimiters to dlm
+    return strJoined
+end intercalate
+
+-- min :: Ord a => a -> a -> a
+on min(x, y)
+    if y < x then
+        y
+    else
+        x
+    end if
+end min
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn
+
+-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+on zipWith(f, xs, ys)
+    set lng to min(length of xs, length of ys)
+    set lst to {}
+    tell mReturn(f)
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, item i of ys)
+        end repeat
+        return lst
+    end tell
+end zipWith

Task/Sierpinski-triangle/Arturo/sierpinski-triangle.arturo

@@ -0,0 +1,13 @@
+sierpinski: function [order][
+    s: shl 1 order
+    loop (s-1)..0 'y [
+        do.times: y -> prints " "
+        loop 0..dec s-y 'x [
+            if? zero? and x y -> prints "* "
+            else -> prints "  "
+        ]
+        print ""
+    ]
+]
+
+sierpinski 4

Task/Sierpinski-triangle/AutoHotkey/sierpinski-triangle.ahk

@@ -0,0 +1,19 @@
+Loop 6
+   MsgBox % Triangle(A_Index)
+
+Triangle(n,x=0,y=1) { ; Triangle(n) -> string of dots and spaces of Sierpinski triangle
+   Static t, l                                  ; put chars in a static string
+   If (x < 1) {                                 ; when called with one parameter
+      l := 2*x := 1<<(n-1)                      ; - compute location, string size
+      VarSetCapacity(t,l*x,32)                  ; - allocate memory filled with spaces
+      Loop %x%
+         NumPut(13,t,A_Index*l-1,"char")        ; - new lines in the end of rows
+   }
+   If (n = 1)                                   ; at the bottom of recursion
+      Return t, NumPut(46,t,x-1+(y-1)*l,"char") ; - write "." (better at proportional fonts)
+   u := 1<<(n-2)
+   Triangle(n-1,x,y)                            ; draw smaller triangle here
+   Triangle(n-1,x-u,y+u)                        ; smaller triangle down-left
+   Triangle(n-1,x+u,y+u)                        ; smaller triangle down right
+   Return t
+}

Task/Sierpinski-triangle/BASIC/sierpinski-triangle.basic

@@ -0,0 +1,14 @@
+DECLARE SUB triangle (x AS INTEGER, y AS INTEGER, length AS INTEGER, n AS INTEGER)
+
+CLS
+triangle 1, 1, 16, 5
+
+SUB triangle (x AS INTEGER, y AS INTEGER, length AS INTEGER, n AS INTEGER)
+    IF n = 0 THEN
+        LOCATE y, x: PRINT "*";
+    ELSE
+        triangle x, y + length, length / 2, n - 1
+        triangle x + length, y, length / 2, n - 1
+        triangle x + length * 2, y + length, length / 2, n - 1
+    END IF
+END SUB

Task/Sierpinski-triangle/BASIC256/sierpinski-triangle.basic

@@ -0,0 +1,14 @@
+clg
+call triangle (1, 1, 60)
+end
+
+subroutine triangle (x, y, l)
+	if l = 0 then
+		color blue
+		text (x, y, "*")
+	else
+		call triangle (x, y + l, int(l/2))
+		call triangle (x + l, y, int(l/2))
+		call triangle (x + l * 2, y + l, int(l/2))
+	end if
+end subroutine

Task/Sierpinski-triangle/BBC-BASIC/sierpinski-triangle.basic

@@ -0,0 +1,17 @@
+      MODE 8
+      OFF
+
+      order% = 5
+      PROCsierpinski(0, 0, 2^(order%-1))
+      REPEAT UNTIL GET
+      END
+
+      DEF PROCsierpinski(x%, y%, l%)
+      IF l% = 0 THEN
+        PRINT TAB(x%,y%) "*";
+      ELSE
+        PROCsierpinski(x%, y%+l%, l% DIV 2)
+        PROCsierpinski(x%+l%, y%, l% DIV 2)
+        PROCsierpinski(x%+l%+l%, y%+l%, l% DIV 2)
+      ENDIF
+      ENDPROC

Task/Sierpinski-triangle/BCPL/sierpinski-triangle.bcpl

@@ -0,0 +1,12 @@
+get "libhdr"
+
+manifest $( SIZE = 1 << 4 $)
+
+let start() be
+$(  for y = SIZE-1 to 0 by -1 do
+    $(  for i=1 to y do wrch(' ')
+        for x=0 to SIZE-y-1 do
+            writes((x & y) ~= 0 -> "  ", "** ")
+        wrch('*N')
+    $)
+$)

Task/Sierpinski-triangle/BQN/sierpinski-triangle.bqn

@@ -0,0 +1 @@
+Sierp ← {" •" ⊏˜ (⌽↕2⋆𝕩)⌽˘∾˘∾⟜0¨∧´∘∨⌜˜⥊↕2⥊˜𝕩}

Task/Sierpinski-triangle/Befunge/sierpinski-triangle.bf

@@ -0,0 +1,7 @@
+41+2>\#*1#2-#<:#\_$:1+v
+v:$_:#`0#\\#00#:p#->#1<
+>2/1\0p:2/\::>1-:>#v_1v
+>8#4*#*+#+,#5^#5g0:<  1
+vg11<\*g11!:g 0-1:::<p<
+>!*+!!\0g11p\ 0p1-:#^_v
+@$$_\#!:#::#-^#1\$,+55<

Task/Sierpinski-triangle/Burlesque/sierpinski-triangle.blq

@@ -0,0 +1,7 @@
+{JPp{
+  -.'sgve!
+  J{JL[2./+.' j.*PppP.+PPj.+}m[
+  j{J" "j.+.+}m[
+  .+
+}{vv{"*"}}PPie} 's sv
+4 'sgve!unsh

Task/Sierpinski-triangle/C++/sierpinski-triangle.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <string>
+#include <list>
+#include <algorithm>
+#include <iterator>
+
+using namespace std;
+
+template<typename OutIt>
+void sierpinski(int n, OutIt result)
+{
+    if( n == 0 )
+    {
+        *result++ = "*";
+    }
+    else
+    {
+        list<string> prev;
+        sierpinski(n-1, back_inserter(prev));
+
+        string sp(1 << (n-1), ' ');
+        result = transform(prev.begin(), prev.end(),
+            result,
+            [sp](const string& x) { return sp + x + sp; });
+        transform(prev.begin(), prev.end(),
+            result,
+            [sp](const string& x) { return x + " " + x; });
+    }
+}
+
+int main()
+{
+    sierpinski(4, ostream_iterator<string>(cout, "\n"));
+    return 0;
+}

Task/Sierpinski-triangle/C-sharp/sierpinski-triangle-1.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections;
+
+namespace RosettaCode {
+    class SierpinskiTriangle {
+        int len;
+        BitArray b;
+
+        public SierpinskiTriangle(int n) {
+            if (n < 1) {
+                throw new ArgumentOutOfRangeException("Order must be greater than zero");
+            }
+            len = 1 << (n+1);
+            b = new BitArray(len+1, false);
+            b[len>>1] = true;
+        }
+
+        public void Display() {
+            for (int j = 0; j < len / 2; j++) {
+                for (int i = 0; i < b.Count; i++) {
+                    Console.Write("{0}", b[i] ? "*" : " ");
+                }
+                Console.WriteLine();
+                NextGen();
+            }
+        }
+
+        private void NextGen() {
+            BitArray next = new BitArray(b.Count, false);
+            for (int i = 0; i < b.Count; i++) {
+                if (b[i]) {
+                    next[i - 1] = next[i - 1] ^ true;
+                    next[i + 1] = next[i + 1] ^ true;
+                }
+            }
+            b = next;
+        }
+    }
+}

Task/Sierpinski-triangle/C-sharp/sierpinski-triangle-2.cs

@@ -0,0 +1,8 @@
+namespace RosettaCode {
+    class Program {
+        static void Main(string[] args) {
+            SierpinskiTriangle t = new SierpinskiTriangle(4);
+            t.Display();
+        }
+    }
+}

Task/Sierpinski-triangle/C-sharp/sierpinski-triangle-3.cs

@@ -0,0 +1,16 @@
+using static System.Console;
+class Sierpinsky
+{
+    static void Main(string[] args)
+    {
+        int order;
+        if(!int.TryParse(args.Length > 0 ? args[0] : "", out order)) order = 4;
+        int size = (1 << order);
+        for (int y = size - 1; y >= 0; y--, WriteLine())
+        {
+            for (int i = 0; i < y; i++) Write(' ');
+            for (int x = 0; x + y < size; x++)
+                Write((x & y) != 0 ? "  " : "* ");
+        }
+    }
+}

Task/Sierpinski-triangle/C-sharp/sierpinski-triangle-4.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+class Program
+{
+    public static List<String> Sierpinski(int n)
+    {
+        var lines = new List<string> { "*" };
+        string space = " ";
+
+        for (int i = 0; i < n; i++)
+        {
+            lines = lines.Select(x => space + x + space)
+                         .Concat(lines.Select(x => x + " " + x)).ToList();
+            space += space;
+        }
+
+        return lines;
+    }
+
+    static void Main(string[] args)
+    {
+        foreach (string s in Sierpinski(4))
+            Console.WriteLine(s);
+    }
+}

Task/Sierpinski-triangle/C-sharp/sierpinski-triangle-5.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+class Program
+{
+    static List<string> Sierpinski(int n)
+    {
+	return Enumerable.Range(0, n).Aggregate(
+	   new List<string>(){"*"},
+	     (p, i) => {
+		string SPACE = " ".PadRight((int)Math.Pow(2, i));
+
+		var temp =  new List<string>(from x in p select SPACE + x + SPACE);
+		temp.AddRange(from x in p select x + " " + x);
+
+		return temp;
+	     }
+	);
+    }
+
+    static void Main ()
+    {
+	foreach(string s in Sierpinski(4)) { Console.WriteLine(s); }
+    }
+}

Task/Sierpinski-triangle/C/sierpinski-triangle-1.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+#define SIZE (1 << 4)
+int main()
+{
+	int x, y, i;
+	for (y = SIZE - 1; y >= 0; y--, putchar('\n')) {
+		for (i = 0; i < y; i++) putchar(' ');
+		for (x = 0; x + y < SIZE; x++)
+			printf((x & y) ? "  " : "* ");
+	}
+	return 0;
+}

Task/Sierpinski-triangle/C/sierpinski-triangle-2.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#ifndef _POSIX_C_SOURCE
+char *strdup(const char *s)
+{
+  int l = strlen(s);
+  char *r = malloc(l+1);
+  memcpy(r, s, l+1);
+  return r;
+}
+#endif
+
+#define truth(X) ((X)=='*'?true:false)
+void rule_90(char *evstr)
+{
+  int i;
+  int l = strlen(evstr);
+  bool s[3];
+  char *cp = strdup(evstr);
+
+  for(i=0;i < l; i++) {
+    s[1] = truth(cp[i]);
+    s[0] = (i-1) < 0 ? false : truth(cp[i-1]);
+    s[2] = (i+1) < l ? truth(cp[i+1]) : false;
+    if ( (s[0] && !s[2]) || (!s[0] && s[2]) ) {
+      evstr[i] = '*';
+    } else {
+      evstr[i] = ' ';
+    }
+  }
+  free(cp);
+}

Task/Sierpinski-triangle/C/sierpinski-triangle-3.c

@@ -0,0 +1,18 @@
+void sierpinski_triangle(int n)
+{
+  int i;
+  int l = 1<<(n+1);
+  char *b = malloc(l+1);
+
+  memset(b, ' ', l);
+  b[l] = 0;
+  b[l>>1] = '*';
+
+  printf("%s\n", b);
+  for(i=0; i < l/2-1;i++) {
+    rule_90(b);
+    printf("%s\n", b);
+  }
+
+  free(b);
+}

Task/Sierpinski-triangle/C/sierpinski-triangle-4.c

@@ -0,0 +1,5 @@
+int main()
+{
+  sierpinski_triangle(4);
+  return EXIT_SUCCESS;
+}

Task/Sierpinski-triangle/CLU/sierpinski-triangle.clu

@@ -0,0 +1,27 @@
+sierpinski = proc (size: int) returns (string)
+    ss: stream := stream$create_output()
+
+    for i: int in int$from_to(0, size*4-1) do
+        c: int := 1
+        for j: int in int$from_to(1, size*4-1-i) do
+            stream$putc(ss, ' ')
+        end
+        for k: int in int$from_to(0, i) do
+            if c//2=0 then
+                stream$puts(ss, "  ")
+            else
+                stream$puts(ss, " *")
+            end
+            c := c*(i-k)/(k+1)
+        end
+        stream$putc(ss, '\n')
+    end
+    return(stream$get_contents(ss))
+end sierpinski
+
+start_up = proc ()
+    stream$puts(
+        stream$primary_output(),
+        sierpinski(4)
+    )
+end start_up

Task/Sierpinski-triangle/COBOL/sierpinski-triangle.cobol

@@ -0,0 +1,36 @@
+identification division.
+program-id. sierpinski-triangle-program.
+data division.
+working-storage section.
+01  sierpinski.
+    05 n              pic 99.
+    05 i              pic 999.
+    05 k              pic 999.
+    05 m              pic 999.
+    05 c              pic 9(18).
+    05 i-limit        pic 999.
+    05 q              pic 9(18).
+    05 r              pic 9.
+procedure division.
+control-paragraph.
+    move 4 to n.
+    multiply n by 4 giving i-limit.
+    subtract 1 from i-limit.
+    perform sierpinski-paragraph
+    varying i from 0 by 1 until i is greater than i-limit.
+    stop run.
+sierpinski-paragraph.
+    subtract i from i-limit giving m.
+    multiply m by 2 giving m.
+    perform m times,
+    display space with no advancing,
+    end-perform.
+    move 1 to c.
+    perform inner-loop-paragraph
+    varying k from 0 by 1 until k is greater than i.
+    display ''.
+inner-loop-paragraph.
+    divide c by 2 giving q remainder r.
+    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).

Task/Sierpinski-triangle/Clojure/sierpinski-triangle.clj

@@ -0,0 +1,26 @@
+(ns example
+  (:require [clojure.contrib.math :as math]))
+
+; Length of integer in binary
+; (copied from a private multimethod in clojure.contrib.math)
+(defmulti #^{:private true} integer-length class)
+
+(defmethod integer-length java.lang.Integer [n]
+  (count (Integer/toBinaryString n)))
+(defmethod integer-length java.lang.Long [n]
+  (count (Long/toBinaryString n)))
+(defmethod integer-length java.math.BigInteger [n]
+  (count (.toString n 2)))
+
+(defn sierpinski-triangle [order]
+  (loop [size (math/expt 2 order)
+         v    (math/expt 2 (- size 1))]
+    (when (pos? size)
+      (println
+       (apply str (map #(if (bit-test v %) "*" " ")
+		       (range (integer-length v)))))
+      (recur
+       (dec size)
+       (bit-xor (bit-shift-left v 1) (bit-shift-right v 1))))))
+
+(sierpinski-triangle 4)

Task/Sierpinski-triangle/Comal/sierpinski-triangle.comal

@@ -0,0 +1,10 @@
+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

Task/Sierpinski-triangle/Common-Lisp/sierpinski-triangle-1.lisp

@@ -0,0 +1,7 @@
+(defun print-sierpinski (order)
+  (loop with size = (expt 2 order)
+        repeat size
+        for v = (expt 2 (1- size)) then (logxor (ash v -1) (ash v 1))
+        do (fresh-line)
+           (loop for i below (integer-length v)
+                 do (princ (if (logbitp i v) "*" " ")))))

Task/Sierpinski-triangle/Common-Lisp/sierpinski-triangle-2.lisp

@@ -0,0 +1,6 @@
+(defun sierpinski (n)
+  (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))

Task/Sierpinski-triangle/Cowgol/sierpinski-triangle.cowgol

@@ -0,0 +1,41 @@
+include "cowgol.coh";
+include "argv.coh";
+
+var order: uint8 := 4; # default order
+
+# Read order from command line if there is an argument
+ArgvInit();
+var argmt := ArgvNext();
+if argmt != 0 as [uint8] then
+    var a: int32;
+    (a, argmt) := AToI(argmt);
+    if a<3 or 7<a then
+        print("Order must be between 3 and 7.");
+        print_nl();
+        ExitWithError();
+    end if;
+    order := a as uint8;
+end if;
+
+var one: uint8 := 1; # shift argument can't be constant...
+var size: uint8 := one << order;
+
+var y: uint8 := size;
+while y > 0 loop
+    var x: uint8 := 0;
+    while x < y-1 loop
+        print_char(' ');
+        x := x + 1;
+    end loop;
+    x := 0;
+    while x + y <= size loop
+        if x & (y-1) != 0 then
+            print("  ");
+        else
+            print("* ");
+        end if;
+        x := x + 1;
+    end loop;
+    print_nl();
+    y := y - 1;
+end loop;

Task/Sierpinski-triangle/D/sierpinski-triangle-1.d

@@ -0,0 +1,12 @@
+void main() /*@safe*/ {
+    import std.stdio, std.algorithm, std.string, std.array;
+
+    enum level = 4;
+    auto d = ["*"];
+    foreach (immutable n; 0 .. level) {
+        immutable sp = " ".replicate(2 ^^ n);
+        d = d.map!(a => sp ~ a ~ sp).array ~
+            d.map!(a => a ~ " " ~ a).array;
+    }
+    d.join('\n').writeln;
+}

Task/Sierpinski-triangle/D/sierpinski-triangle-2.d

@@ -0,0 +1,14 @@
+import std.string, std.range, std.algorithm;
+
+string sierpinski(int level) pure nothrow /*@safe*/ {
+    auto d = ["*"];
+    foreach (immutable i; 0 .. level) {
+        immutable sp = " ".replicate(2 ^^ i);
+        d = d.map!(a => sp ~ a ~ sp).array ~
+            d.map!(a => a ~ " " ~ a).array;
+    }
+    return d.join('\n');
+}
+
+pragma(msg, 4.sierpinski);
+void main() {}

Task/Sierpinski-triangle/D/sierpinski-triangle-3.d

@@ -0,0 +1,17 @@
+void showSierpinskiTriangle(in uint order) nothrow @safe @nogc {
+    import core.stdc.stdio: putchar;
+
+    foreach_reverse (immutable y; 0 .. 2 ^^ order) {
+        foreach (immutable _; 0 .. y)
+            ' '.putchar;
+        foreach (immutable x; 0 .. 2 ^^ order - y) {
+            putchar((x & y) ? ' ' : '*');
+            ' '.putchar;
+        }
+        '\n'.putchar;
+    }
+}
+
+void main() nothrow @safe @nogc {
+    4.showSierpinskiTriangle;
+}

Task/Sierpinski-triangle/D/sierpinski-triangle-4.d

@@ -0,0 +1,42 @@
+import core.stdc.stdio: putchar;
+import std.algorithm: swap;
+
+
+void showSierpinskiTriangle(in uint nLevels) nothrow @safe
+in {
+    assert(nLevels > 0);
+} body {
+    alias Row = bool[];
+
+    static void applyRules(in Row r1, Row r2) pure nothrow @safe @nogc {
+        r2[0] = r1[0] || r1[1];
+        r2[$ - 1] = r1[$ - 2] || r1[$ - 1];
+        foreach (immutable i; 1 .. r2.length - 1)
+            r2[i] = r1[i - 1] != r1[i] || r1[i] != r1[i + 1];
+    }
+
+    static void showRow(in Row r) nothrow @safe @nogc {
+        foreach (immutable b; r)
+            putchar(b ? '#' : ' ');
+        '\n'.putchar;
+    }
+
+    immutable width = 2 ^^ (nLevels + 1) - 1;
+    auto row1 = new Row(width);
+    auto row2 = new Row(width);
+    row1[width / 2] = true;
+
+    foreach (immutable _; 0 .. 2 ^^ nLevels) {
+        showRow(row1);
+        applyRules(row1, row2);
+        row1.swap(row2);
+    }
+}
+
+
+void main() @safe nothrow {
+    foreach (immutable i; 1 .. 6) {
+        i.showSierpinskiTriangle;
+        '\n'.putchar;
+    }
+}

Task/Sierpinski-triangle/DWScript/sierpinski-triangle.dw

@@ -0,0 +1,17 @@
+procedure PrintSierpinski(order : Integer);
+var
+   x, y, size : Integer;
+begin
+   size := (1 shl order)-1;
+   for y:=size downto 0 do begin
+      Print(StringOfChar(' ', y));
+      for x:=0 to size-y do begin
+         if (x and y)=0 then
+            Print('* ')
+         else Print('  ');
+      end;
+      PrintLn('');
+   end;
+end;
+
+PrintSierpinski(4);

Task/Sierpinski-triangle/Delphi/sierpinski-triangle.delphi

@@ -0,0 +1,26 @@
+program SierpinskiTriangle;
+
+{$APPTYPE CONSOLE}
+
+procedure PrintSierpinski(order: Integer);
+var
+  x, y, size: Integer;
+begin
+  size := (1 shl order) - 1;
+  for y := size downto 0 do
+  begin
+    Write(StringOfChar(' ', y));
+    for x := 0 to size - y do
+    begin
+      if (x and y) = 0 then
+        Write('* ')
+      else
+        Write('  ');
+    end;
+    Writeln;
+  end;
+end;
+
+begin
+  PrintSierpinski(4);
+end.

Task/Sierpinski-triangle/Draco/sierpinski-triangle.draco

@@ -0,0 +1,12 @@
+word SIZE = 1 << 4;
+
+proc nonrec main() void:
+    unsigned SIZE x, y;
+    for y from SIZE-1 downto 0 do
+        for x from 1 upto y do write(' ') od;
+        for x from 0 upto SIZE - y - 1 do
+            write(if x & y ~= 0 then "  " else "* " fi)
+        od;
+        writeln()
+    od
+corp

Task/Sierpinski-triangle/E/sierpinski-triangle-1.e

@@ -0,0 +1,10 @@
+def printSierpinski(order, out) {
+    def size := 2**order
+    for y in (0..!size).descending() {
+        out.print(" " * y)
+        for x in 0..!(size-y) {
+            out.print((x & y).isZero().pick("* ", "  "))
+        }
+        out.println()
+    }
+}

Task/Sierpinski-triangle/E/sierpinski-triangle-2.e

@@ -0,0 +1 @@
+? printSierpinski(4, stdout)

Task/Sierpinski-triangle/E/sierpinski-triangle-3.e

@@ -0,0 +1,10 @@
+def printSierpinski(order, out) {
+    def size := 2**order
+    for y in (0..!size).descending() {
+        out.print("　" * y)
+        for x in 0..!(size-y) {
+            out.print((x & y).isZero().pick("◢◣", "　　"))
+        }
+        out.println()
+    }
+}

Task/Sierpinski-triangle/Elixir/sierpinski-triangle.elixir

@@ -0,0 +1,14 @@
+defmodule RC do
+  def sierpinski_triangle(n) do
+    f = fn(x) -> IO.puts "#{x}" end
+    Enum.each(triangle(n, ["*"], " "), f)
+  end
+
+  defp triangle(0, down, _), do: down
+  defp triangle(n, down, sp) do
+    newDown = (for x <- down, do: sp<>x<>sp) ++ (for x <- down, do: x<>" "<>x)
+    triangle(n-1, newDown, sp<>sp)
+  end
+end
+
+RC.sierpinski_triangle(4)

Task/Sierpinski-triangle/Elm/sierpinski-triangle.elm

@@ -0,0 +1,52 @@
+import String exposing (..)
+import Html exposing (..)
+import Html.Attributes as A exposing (..)
+import Html.Events exposing (..)
+import Html.App exposing (beginnerProgram)
+import Result exposing (..)
+
+sierpinski : Int -> List String
+sierpinski n =
+  let down n = sierpinski (n - 1)
+      space n = repeat (2 ^ (n - 1)) " "
+  in case n of
+       0 -> ["*"]
+       _ ->    List.map ((\st -> space n ++ st) << (\st -> st ++ space n)) (down n)
+            ++ List.map (join " " << List.repeat 2) (down n)
+
+main = beginnerProgram { model = "4", view = view, update = update }
+
+update newStr oldStr = newStr
+
+view : String -> Html String
+view levelString =
+  div []
+    ([ Html.form
+          []
+          [ label [ myStyle ] [ text "Level: "]
+          , input
+            [ placeholder "triangle level."
+            , value levelString
+            , on "input" targetValue
+            , type' "number"
+            , A.min "0"
+            , myStyle
+            ]
+            []
+          ]
+     ] ++
+     [ pre [] (levelString
+               |> toInt
+               |> withDefault 0
+               |> sierpinski
+               |> List.map (\s -> div [] [text s]))
+     ])
+
+myStyle : Attribute msg
+myStyle =
+  style
+    [ ("height", "20px")
+    , ("padding", "5px 0 0 5px")
+    , ("font-size", "1em")
+    , ("text-align", "left")
+    ]

Task/Sierpinski-triangle/Erlang/sierpinski-triangle.erl

@@ -0,0 +1,11 @@
+-module(sierpinski).
+-export([triangle/1]).
+
+triangle(N) ->
+    F = fun(X) -> io:format("~s~n",[X]) end,
+    lists:foreach(F, triangle(N, ["*"], " ")).
+
+triangle(0, Down, _) -> Down;
+triangle(N, Down, Sp) ->
+    NewDown = [Sp++X++Sp || X<-Down]++[X++" "++X || X <- Down],
+    triangle(N-1, NewDown, Sp++Sp).

Task/Sierpinski-triangle/Euphoria/sierpinski-triangle.euphoria

@@ -0,0 +1,12 @@
+procedure triangle(integer x, integer y, integer len, integer n)
+    if n = 0 then
+        position(y,x) puts(1,'*')
+    else
+        triangle (x,       y+len, floor(len/2), n-1)
+        triangle (x+len,   y,     floor(len/2), n-1)
+        triangle (x+len*2, y+len, floor(len/2), n-1)
+    end if
+end procedure
+
+clear_screen()
+triangle(1,1,8,4)

Task/Sierpinski-triangle/Excel/sierpinski-triangle-1.excel

@@ -0,0 +1,45 @@
+sierpinskiTriangle
+=LAMBDA(c,
+    LAMBDA(n,
+        IF(0 = n,
+            c,
+            LET(
+                prev, sierpinskiTriangle(c)(n - 1),
+
+                APPENDROWS(
+                    sierpCentered(prev)
+                )(
+                    sierpDoubled(prev)
+                )
+            )
+        )
+    )
+)
+
+
+sierpCentered
+=LAMBDA(grid,
+    LET(
+        nRows, ROWS(grid),
+        padding, IF(
+            SEQUENCE(nRows, nRows, 1, 1),
+            " "
+        ),
+
+        APPENDCOLS(
+            APPENDCOLS(padding)(grid)
+        )(padding)
+    )
+)
+
+
+sierpDoubled
+=LAMBDA(grid,
+    APPENDCOLS(
+        APPENDCOLS(grid)(
+            IF(SEQUENCE(ROWS(grid), 1, 1, 1),
+                " "
+            )
+        )
+    )(grid)
+)

Task/Sierpinski-triangle/Excel/sierpinski-triangle-2.excel

@@ -0,0 +1,59 @@
+APPENDCOLS
+=LAMBDA(xs,
+    LAMBDA(ys,
+        LET(
+            nx, COLUMNS(xs),
+            colIndexes, SEQUENCE(1, nx + COLUMNS(ys)),
+            rowIndexes, SEQUENCE(MAX(ROWS(xs), ROWS(ys))),
+
+            IFERROR(
+                IF(nx < colIndexes,
+                    INDEX(ys, rowIndexes, colIndexes - nx),
+                    INDEX(xs, rowIndexes, colIndexes)
+                ),
+                NA()
+            )
+        )
+    )
+)
+
+
+APPENDROWS
+=LAMBDA(xs,
+    LAMBDA(ys,
+        LET(
+            nx, ROWS(xs),
+            rowIndexes, SEQUENCE(nx + ROWS(ys)),
+            colIndexes, SEQUENCE(
+                1,
+                MAX(COLUMNS(xs), COLUMNS(ys))
+            ),
+
+            IFERROR(
+                IF(rowIndexes <= nx,
+                    INDEX(xs, rowIndexes, colIndexes),
+                    INDEX(ys, rowIndexes - nx, colIndexes)
+                ),
+                NA()
+            )
+        )
+    )
+)
+
+
+gridString
+=LAMBDA(grid,
+    LET(
+        ixCol, SEQUENCE(ROWS(grid), 1, 1, 1),
+
+        CHAR(10) & CONCAT(
+            APPENDCOLS(
+                IF(ixCol, "    ")
+            )(
+                APPENDCOLS(grid)(
+                    IF(ixCol, CHAR(10))
+                )
+            )
+        )
+    )
+)

Task/Sierpinski-triangle/F-Sharp/sierpinski-triangle.fs

@@ -0,0 +1,13 @@
+let sierpinski n =
+  let rec loop down space n =
+    if n = 0 then
+      down
+    else
+      loop (List.map (fun x -> space + x + space) down @
+              List.map (fun x -> x + " " + x) down)
+        (space + space)
+        (n - 1)
+  in loop ["*"] " " n
+
+let () =
+  List.iter (fun (i:string) -> System.Console.WriteLine(i)) (sierpinski 4)

Task/Sierpinski-triangle/FALSE/sierpinski-triangle.false

@@ -0,0 +1,21 @@
+{ 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,
+]#%%

Task/Sierpinski-triangle/FOCAL/sierpinski-triangle.focal

@@ -0,0 +1,14 @@
+01.10 A "ORDER",O;S S=2^(O+1)
+01.20 F X=0,S;S L(X)=0
+01.30 S L(S/2)=1
+01.40 F I=1,S/2;D 2;D 3
+01.90 Q
+
+02.10 F X=1,S-1;D 2.3
+02.20 T !;R
+02.30 I (L(X)),2.4,2.5
+02.40 T " "
+02.50 T "*"
+
+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)

Task/Sierpinski-triangle/Factor/sierpinski-triangle.factor

@@ -0,0 +1,17 @@
+USING: io kernel math sequences ;
+IN: sierpinski
+
+: iterate-triangle ( triange spaces -- triangle' )
+    [ [ dup surround ] curry map ]
+    [ drop [ dup " " glue ] map ] 2bi append ;
+
+: (sierpinski) ( triangle spaces n -- triangle' )
+    dup 0 = [ 2drop "\n" join ] [
+        [
+            [ iterate-triangle ]
+            [ nip dup append ] 2bi
+        ] dip 1 - (sierpinski)
+    ] if ;
+
+: sierpinski ( n -- )
+    [ { "*" } " " ] dip (sierpinski) print ;

Task/Sierpinski-triangle/Forth/sierpinski-triangle.fth

@@ -0,0 +1,14 @@
+: stars ( mask -- )
+  begin
+    dup 1 and if [char] * else bl then emit
+    1 rshift  dup
+  while space repeat drop ;
+
+: triangle ( order -- )
+  1 swap lshift   ( 2^order )
+  1 over 0 do
+    cr  over i - spaces  dup stars
+    dup 2* xor
+  loop 2drop ;
+
+5 triangle

Task/Sierpinski-triangle/Fortran/sierpinski-triangle.f

@@ -0,0 +1,29 @@
+program Sierpinski_triangle
+  implicit none
+
+  call Triangle(4)
+
+contains
+
+subroutine Triangle(n)
+  implicit none
+  integer, parameter :: i64 = selected_int_kind(18)
+  integer, intent(in) :: n
+  integer :: i, k
+  integer(i64) :: c
+
+  do i = 0, n*4-1
+    c = 1
+    write(*, "(a)", advance="no") repeat(" ", 2 * (n*4 - 1 - i))
+    do k = 0, i
+      if(mod(c, 2) == 0) then
+        write(*, "(a)", advance="no") "    "
+      else
+        write(*, "(a)", advance="no") "  * "
+      end if
+      c = c * (i - k) / (k + 1)
+    end do
+    write(*,*)
+  end do
+end subroutine Triangle
+end program Sierpinski_triangle

Task/Sierpinski-triangle/FreeBASIC/sierpinski-triangle.basic

@@ -0,0 +1,12 @@
+sub sier(x as uinteger, y as uinteger, l as uinteger)
+   if l=0 then
+       locate y, x: print "*"
+   else
+     sier(x,y+l,l\2)
+     sier(x+l,y,l\2)
+     sier(x+2*l,y+l,l\2)
+   end if
+end sub
+
+cls
+sier(1,1,2^3)

Task/Sierpinski-triangle/GAP/sierpinski-triangle.gap

@@ -0,0 +1,38 @@
+# Using parity of binomial coefficients
+SierpinskiTriangle := function(n)
+	local i, j, s, b;
+	n := 2^n - 1;
+	b := " ";
+	while Size(b) < n do
+		b := Concatenation(b, b);
+	od;
+	for i in [0 .. n] do
+		s := "";
+		for j in [0 .. i] do
+			if IsEvenInt(Binomial(i, j)) then
+				Append(s, "  ");
+			else
+				Append(s, "* ");
+			fi;
+		od;
+		Print(b{[1 .. n - i]}, s, "\n");
+	od;
+end;
+
+SierpinskiTriangle(4);
+               *
+              * *
+             *   *
+            * * * *
+           *       *
+          * *     * *
+         *   *   *   *
+        * * * * * * * *
+       *               *
+      * *             * *
+     *   *           *   *
+    * * * *         * * * *
+   *       *       *       *
+  * *     * *     * *     * *
+ *   *   *   *   *   *   *   *
+* * * * * * * * * * * * * * * *

Task/Sierpinski-triangle/Gnuplot/sierpinski-triangle.gnuplot

@@ -0,0 +1,16 @@
+# Return a string space or star to print at x,y.
+# 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.
+char(x,y) = (y+x>=0 && ((y+x)%2)==0 && ((y+x)&(y-x))==0 ? "*" : " ")
+
+# Return a string which is row y of the triangle from character
+# position x through to the right hand end x==y, inclusive.
+row(x,y) = (x<=y ? char(x,y).row(x+1,y) : "\n")
+
+# Return a string of stars, spaces and newlines which is the
+# Sierpinski triangle from row y to limit, inclusive.
+# The first row is y=0.
+triangle(y,limit) = (y <= limit ? row(-limit,y).triangle(y+1,limit) : "")
+
+# Print rows 0 to 15, which is the order 4 triangle per the task.
+print triangle(0,15)

Task/Sierpinski-triangle/Go/sierpinski-triangle.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+    "fmt"
+    "strings"
+    "unicode/utf8"
+)
+
+var order = 4
+var grain = "*"
+
+func main() {
+    t := []string{grain + strings.Repeat(" ", utf8.RuneCountInString(grain))}
+    for ; order > 0; order-- {
+        sp := strings.Repeat(" ", utf8.RuneCountInString(t[0])/2)
+        top := make([]string, len(t))
+        for i, s := range t {
+            top[i] = sp + s + sp
+            t[i] += s
+        }
+        t = append(top, t...)
+    }
+    for _, r := range t {
+        fmt.Println(r)
+    }
+}

Task/Sierpinski-triangle/Golfscript/sierpinski-triangle.golf

@@ -0,0 +1 @@
+' /\ /__\ '4/){.+\.{[2$.]*}%\{.+}%+\}3*;n*

Task/Sierpinski-triangle/Groovy/sierpinski-triangle-1.groovy

@@ -0,0 +1,16 @@
+def stPoints;
+stPoints = { order, base=[0,0] ->
+    def right = [base[0], base[1]+2**order]
+    def up = [base[0]+2**(order-1), base[1]+2**(order-1)]
+    (order == 0) \
+        ? [base]
+        : (stPoints(order-1, base) + stPoints(order-1, right) + stPoints(order-1, up))
+}
+
+def stGrid = { order ->
+    def h = 2**order
+    def w = 2**(order+1) - 1
+    def grid = (0..<h).collect { (0..<w).collect { ' ' } }
+    stPoints(order).each { grid[it[0]][it[1]] = (order%10).toString() }
+    grid
+}

Task/Sierpinski-triangle/Groovy/sierpinski-triangle-2.groovy

@@ -0,0 +1,13 @@
+stGrid(0).reverse().each { println it.sum() }
+println()
+stGrid(1).reverse().each { println it.sum() }
+println()
+stGrid(2).reverse().each { println it.sum() }
+println()
+stGrid(3).reverse().each { println it.sum() }
+println()
+stGrid(4).reverse().each { println it.sum() }
+println()
+stGrid(5).reverse().each { println it.sum() }
+println()
+stGrid(6).reverse().each { println it.sum() }

Task/Sierpinski-triangle/Haskell/sierpinski-triangle-1.hs

@@ -0,0 +1,7 @@
+sierpinski 0 = ["*"]
+sierpinski n = map ((space ++) . (++ space)) down ++
+               map (unwords . replicate 2) down
+    where down = sierpinski (n - 1)
+          space = replicate (2 ^ (n - 1)) ' '
+
+main = mapM_ putStrLn $ sierpinski 4

Task/Sierpinski-triangle/Haskell/sierpinski-triangle-2.hs

@@ -0,0 +1,14 @@
+import Data.List (intercalate)
+
+sierpinski :: Int -> [String]
+sierpinski 0 = ["▲"]
+sierpinski n =
+  [ flip
+      intercalate
+      ([replicate (2 ^ (n - 1))] <*> " -"),
+    (<>) <*> ('+' :)
+  ]
+    >>= (<$> sierpinski (n - 1))
+
+main :: IO ()
+main = mapM_ putStrLn $ sierpinski 4

Task/Sierpinski-triangle/Haskell/sierpinski-triangle-3.hs

@@ -0,0 +1,9 @@
+import Data.Bits ((.&.))
+
+sierpinski n = map row [m, m-1 .. 0] where
+	m = 2^n - 1
+	row y = replicate y ' ' ++ concatMap cell [0..m - y] where
+		cell x	| y .&. x == 0 = " *"
+			| otherwise = "  "
+
+main = mapM_ putStrLn $ sierpinski 4

Task/Sierpinski-triangle/Haskell/sierpinski-triangle-4.hs

@@ -0,0 +1,25 @@
+import Data.List (intersperse)
+
+-- Top down, each row after the first is an XOR / Rule90 rewrite.
+-- Bottom up, each line above the base is indented 1 more space.
+sierpinski :: Int -> String
+sierpinski = fst . foldr spacing ([], []) . rule90 . (2 ^)
+  where
+    rule90 = scanl next "*" . enumFromTo 1 . subtract 1
+      where
+        next =
+          const
+            . ( (zipWith xor . (' ' :))
+                  <*> (<> " ")
+              )
+        xor l r
+          | l == r = ' '
+          | otherwise = '*'
+    spacing x (s, w) =
+      ( concat
+          [w, intersperse ' ' x, "\n", s],
+        w <> " "
+      )
+
+main :: IO ()
+main = putStr $ sierpinski 4

Task/Sierpinski-triangle/Haskell/sierpinski-triangle-5.hs

@@ -0,0 +1,17 @@
+sierpinski :: Int -> [String]
+sierpinski n =
+  foldr
+    ( \i xs ->
+        let s = replicate (2 ^ i) ' '
+         in fmap ((s <>) . (<> s)) xs
+              <> fmap
+                ( (<>)
+                    <*> (' ' :)
+                )
+                xs
+    )
+    ["*"]
+    [n - 1, n - 2 .. 0]
+
+main :: IO ()
+main = (putStrLn . unlines . sierpinski) 4

Task/Sierpinski-triangle/Haxe/sierpinski-triangle.haxe

@@ -0,0 +1,35 @@
+class Main
+{
+	static function main()
+	{
+		triangle(3);
+	}
+	
+	static inline var SPACE = ' ';
+	static inline var STAR = '*';
+	
+	static function triangle(o) {
+		var n = 1 << o;
+		var line = new Array<String>();
+		
+		for (i in 0...(n*2)) line[i] = SPACE;
+		
+		line[n] = '*';
+		
+		for (i in 0...n) {
+			Sys.println(line.join(''));
+			var u ='*';
+			var start = n - i;
+			var end = n + i + 1;
+			var t = SPACE;
+			for (j in start...end) {
+				t = (line[j-1] == line[j+1] ? SPACE : STAR);
+				line[j-1] = u;
+				u = t;
+			}
+			
+			line[n+i] = t;
+			line[n+i+1] = STAR;
+		}
+	}
+}

Task/Sierpinski-triangle/Hoon/sierpinski-triangle.hoon

@@ -0,0 +1,9 @@
+|=  n=@ud
+=+  m=0
+=+  o=(reap 1 '*')
+|^  ?:  =(m n)  o
+    $(m +(m), o (weld top bot))
+++  gap  (fil 3 (pow 2 m) ' ')
+++  top  (turn o |=(l=@t (rap 3 gap l gap ~)))
+++  bot  (turn o |=(l=@t (rap 3 l ' ' l ~)))
+--

Task/Sierpinski-triangle/IDL/sierpinski-triangle.idl

@@ -0,0 +1,8 @@
+pro sierp,n
+  s = (t = bytarr(3+2^(n+1))+32b)
+  t[2^n+1] = 42b
+  for lines = 1,2^n do begin
+        print,string( (s = t) )
+        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

Task/Sierpinski-triangle/IS-BASIC/sierpinski-triangle.basic

@@ -0,0 +1,12 @@
+100 PROGRAM "Triangle.bas"
+110 TEXT 40
+120 CALL TRIANGLE(1,1,8)
+130 DEF TRIANGLE(X,Y,L)
+140   IF L=0 THEN
+150     PRINT AT Y,X:"*"
+160   ELSE
+170     CALL TRIANGLE(X,Y+L,INT(L/2))
+180     CALL TRIANGLE(X+L,Y,INT(L/2))
+190     CALL TRIANGLE(X+2*L,Y+L,INT(L/2))
+200   END IF
+210 END DEF

Task/Sierpinski-triangle/Icon/sierpinski-triangle.icon

@@ -0,0 +1,15 @@
+# text based adaptaion of
+
+procedure main(A)
+
+   width := 2 ^ ( 1 + (order := 0 < integer(\A[1]) | 4))  # order of arg[1] or 4
+   write("Triangle order= ",order)
+
+   every !(canvas := list(width)) := list(width," ")      # prime the canvas
+   every y := 1 to width & x := 1 to width do             # traverse it
+      if iand(x - 1, y - 1) = 0 then canvas[x,y] := "*"   # fill
+
+   every x := 1 to width & y := 1 to width do
+      writes((y=1,"\n")|"",canvas[x,y]," ")               # print
+
+end

Task/Sierpinski-triangle/J/sierpinski-triangle-1.j

@@ -0,0 +1 @@
+   |. _31]\ ,(,.~ , ])^:4 ,: '* '

Task/Sierpinski-triangle/J/sierpinski-triangle-2.j

@@ -0,0 +1 @@
+   ' *' {~ '1' = (- |."_1 [: ": 2 | !/~) i._16

Task/Sierpinski-triangle/Java/sierpinski-triangle.java

@@ -0,0 +1,44 @@
+public class SierpinskiTriangle {
+
+    public static void main(String[] args) {
+        System.out.println(getSierpinskiTriangle(4));
+    }
+
+    private static final String getSierpinskiTriangle(int n) {
+        if ( n == 0 ) {
+            return "*";
+        }
+
+        String s = getSierpinskiTriangle(n-1);
+        String [] split = s.split("\n");
+        int length = split.length;
+
+        //  Top triangle
+        StringBuilder sb = new StringBuilder();
+        String top = buildSpace((int)Math.pow(2, n-1));
+        for ( int i = 0 ; i < length ;i++ ) {
+            sb.append(top);
+            sb.append(split[i]);
+            sb.append("\n");
+        }
+
+        //  Two triangles side by side
+        for ( int i = 0 ; i < length ;i++ ) {
+            sb.append(split[i]);
+            sb.append(buildSpace(length-i));
+            sb.append(split[i]);
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    private static String buildSpace(int n) {
+        StringBuilder sb = new StringBuilder();
+        while ( n > 0 ) {
+            sb.append(" ");
+            n--;
+        }
+        return sb.toString();
+    }
+
+}

Task/Sierpinski-triangle/JavaFX-Script/sierpinski-triangle.javafx

@@ -0,0 +1,14 @@
+function sierpinski(n : Integer) {
+  var down = ["*"];
+  var space = " ";
+  for (i in [1..n]) {
+    down = [for (x in down) "{space}{x}{space}", for (x in down) "{x} {x}"];
+    space = "{space}{space}";
+  }
+
+  for (x in down) {
+    println("{x}")
+  }
+}
+
+sierpinski(4);

Task/Sierpinski-triangle/JavaScript/sierpinski-triangle-1.js

@@ -0,0 +1,58 @@
+(function (order) {
+
+    // Sierpinski triangle of order N constructed as
+    // Pascal triangle of 2^N rows mod 2
+    // with 1 encoded as "▲"
+    // and 0 encoded as " "
+    function sierpinski(intOrder) {
+        return function asciiPascalMod2(intRows) {
+            return range(1, intRows - 1)
+                .reduce(function (lstRows) {
+                    var lstPrevRow = lstRows.slice(-1)[0];
+
+                    // Each new row is a function of the previous row
+                    return lstRows.concat([zipWith(function (left, right) {
+                        // The composition ( asciiBinary . mod 2 . add )
+                        // reduces to a rule from 2 parent characters
+                        // to a single child character
+
+                        // Rule 90 also reduces to the same XOR
+                        // relationship between left and right neighbours
+
+                        return left === right ? " " : "▲";
+                    }, [' '].concat(lstPrevRow), lstPrevRow.concat(' '))]);
+                }, [
+                    ["▲"] // Tip of triangle
+                ]);
+        }(Math.pow(2, intOrder))
+
+        // As centred lines, from bottom (0 indent) up (indent below + 1)
+        .reduceRight(function (sofar, lstLine) {
+            return {
+                triangle: sofar.indent + lstLine.join(" ") + "\n" +
+                    sofar.triangle,
+                indent: sofar.indent + " "
+            };
+        }, {
+            triangle: "",
+            indent: ""
+        }).triangle;
+    };
+
+    var zipWith = function (f, xs, ys) {
+            return xs.length === ys.length ? xs
+                .map(function (x, i) {
+                    return f(x, ys[i]);
+                }) : undefined;
+        },
+        range = function (m, n) {
+            return Array.apply(null, Array(n - m + 1))
+                .map(function (x, i) {
+                    return m + i;
+                });
+        };
+
+    // TEST
+    return sierpinski(order);
+
+})(4);

Task/Sierpinski-triangle/JavaScript/sierpinski-triangle-2.js

@@ -0,0 +1,21 @@
+function triangle(o) {
+    var n = 1 << o,
+        line = new Array(2 * n),
+        i, j, t, u;
+    for (i = 0; i < line.length; ++i) line[i] = '&nbsp;';
+    line[n] = '*';
+    for (i = 0; i < n; ++i) {
+        document.write(line.join('') + "\n");
+        u = '*';
+        for (j = n - i; j < n + i + 1; ++j) {
+            t = (line[j - 1] == line[j + 1] ? '&nbsp;' : '*');
+            line[j - 1] = u;
+            u = t;
+        }
+        line[n + i] = t;
+        line[n + i + 1] = '*';
+    }
+}
+document.write("<pre>\n");
+triangle(6);
+document.write("</pre>");

Task/Sierpinski-triangle/JavaScript/sierpinski-triangle-3.js

@@ -0,0 +1,26 @@
+(() => {
+    "use strict";
+
+    // --------------- SIERPINSKI TRIANGLE ---------------
+
+    // sierpinski :: Int -> String
+    const sierpinski = n =>
+        Array.from({
+            length: n
+        })
+        .reduce(
+            (xs, _, i) => {
+                const s = " ".repeat(2 ** i);
+
+                return [
+                    ...xs.map(x => s + x + s),
+                    ...xs.map(x => `${x} ${x}`)
+                ];
+            },
+            ["*"]
+        )
+        .join("\n");
+
+    // ---------------------- TEST -----------------------
+    return sierpinski(4);
+})();

Task/Sierpinski-triangle/JavaScript/sierpinski-triangle-4.js

@@ -0,0 +1,70 @@
+(() => {
+    "use strict";
+
+    // ----- LINES OF SIERPINSKI TRIANGLE AT LEVEL N -----
+
+    // sierpinski :: Int -> [String]
+    const sierpTriangle = n =>
+        // Previous triangle centered with
+        // left and right padding,
+        0 < n ? (
+            ap([
+                map(
+                    xs => ap([
+                        compose(
+                            ks => ks.join(""),
+                            replicate(2 ** (n - 1))
+                        )
+                    ])([" ", "-"])
+                    .join(xs)
+                ),
+
+                // above a pair of duplicates,
+                // placed one character apart.
+                map(s => `${s}+${s}`)
+            ])([sierpTriangle(n - 1)])
+            .flat()
+        ) : ["▲"];
+
+
+    // ---------------------- TEST -----------------------
+    const main = () =>
+        sierpTriangle(4)
+        .join("\n");
+
+
+    // ---------------- GENERIC FUNCTIONS ----------------
+
+    // ap (<*>) :: [(a -> b)] -> [a] -> [b]
+    const ap = fs =>
+        // The sequential application of each of a list
+        // of functions to each of a list of values.
+        // apList([x => 2 * x, x => 20 + x])([1, 2, 3])
+        //     -> [2, 4, 6, 21, 22, 23]
+        xs => fs.flatMap(f => xs.map(f));
+
+
+    // compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
+    const compose = (...fs) =>
+        // 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]
+    const map = f => xs => xs.map(f);
+
+
+    // replicate :: Int -> a -> [a]
+    const replicate = n =>
+        // A list of n copies of x.
+        x => Array.from({
+            length: n
+        }, () => x);
+
+    // ---------------------- TEST -----------------------
+    return main();
+})();

Task/Sierpinski-triangle/JavaScript/sierpinski-triangle-5.js

@@ -0,0 +1,69 @@
+(() => {
+    "use strict";
+
+    // --------------- SIERPINSKI TRIANGLE ---------------
+
+    // sierpinski :: Int -> [Bool]
+    const sierpinski = intOrder =>
+        // Reduce/folding from the last item (base of list)
+        // which has zero left indent.
+
+        // Each preceding row has one more indent space
+        // than the row beneath it.
+        pascalMod2Chars(2 ** intOrder)
+        .reduceRight((a, x) => ([
+            `${a[1]}${x.join(" ")}\n${a[0]}`,
+            `${a[1]} `
+        ]), ["", ""])[0];
+
+
+    // pascalMod2Chars :: Int -> [[Char]]
+    const pascalMod2Chars = nRows =>
+        enumFromTo(1)(nRows - 1)
+        .reduce(sofar => {
+            const rows = sofar.slice(-1)[0];
+
+            // Rule 90 also reduces to the same XOR
+            // relationship between left and right neighbours.
+            return ([
+                ...sofar,
+                zipWith(
+                    l => r => l === r ? (
+                        " "
+                    ) : "*"
+                )([" ", ...rows])([...rows, " "])
+            ]);
+        }, [
+            ["*"]
+        ]);
+
+    // ---------------------- TEST -----------------------
+    // main :: IO ()
+    const main = () =>
+        sierpinski(4);
+
+
+    // --------------------- GENERIC ---------------------
+
+    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    const zipWith = f =>
+        // A list constructed by zipping with a
+        // custom function, rather than with the
+        // default tuple constructor.
+        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 =>
+        n => Array.from({
+            length: 1 + n - m
+        }, (_, i) => m + i);
+
+
+    // MAIN ---
+    return main();
+})();

Task/Sierpinski-triangle/Jq/sierpinski-triangle-1.jq

@@ -0,0 +1,21 @@
+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 toi:
+    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;

Task/Sierpinski-triangle/Jq/sierpinski-triangle-2.jq

@@ -0,0 +1,7 @@
+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

Task/Sierpinski-triangle/Julia/sierpinski-triangle.julia

@@ -0,0 +1,18 @@
+function sierpinski(n, token::AbstractString="*")
+	x = fill(token, 1, 1)
+	for _ in 1:n
+		h, w = size(x)
+		s = fill(" ", h,(w + 1) ÷ 2)
+		t = fill(" ", h,1)
+		x = [[s x s] ; [x t x]]
+	end
+	return x
+end
+
+function printsierpinski(m::Matrix)
+    for r in 1:size(m, 1)
+        println(join(m[r, :]))
+    end
+end
+
+sierpinski(4) |> printsierpinski

Task/Sierpinski-triangle/Kotlin/sierpinski-triangle.kotlin

@@ -0,0 +1,12 @@
+// version 1.1.2
+
+const val ORDER = 4
+const val SIZE  = 1 shl ORDER
+
+fun main(args: Array<String>) {
+    for (y in SIZE - 1 downTo 0) {
+        for (i in 0 until y) print(" ")
+        for (x in 0 until SIZE - y) print(if ((x and y) != 0) "  " else "* ")
+        println()
+    }
+}

Task/Sierpinski-triangle/Lambdatalk/sierpinski-triangle-1.lambdatalk

@@ -0,0 +1,24 @@
+{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

Task/Sierpinski-triangle/Lambdatalk/sierpinski-triangle-2.lambdatalk

@@ -0,0 +1,9 @@
+{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"}}

Task/Sierpinski-triangle/Liberty-BASIC/sierpinski-triangle.basic

@@ -0,0 +1,15 @@
+nOrder=4
+call triangle 1, 1, nOrder
+end
+
+SUB triangle x, y, n
+    IF n = 0 THEN
+        LOCATE x,y: PRINT "*";
+    ELSE
+        n=n-1
+        length=2^n
+        call triangle x, y+length, n
+        call triangle x+length, y, n
+        call triangle x+length*2, y+length, n
+    END IF
+END SUB

Task/Sierpinski-triangle/Logo/sierpinski-triangle.logo

@@ -0,0 +1,14 @@
+; Print rows of the triangle from 0 to :limit inclusive.
+; limit=15 gives the order 4 form per the task.
+; The range of :y is arbitrary, any rows of the triangle can be printed.
+
+make "limit 15
+for [y 0 :limit] [
+  for [x -:limit :y] [
+    type ifelse (and :y+:x >= 0                ; blank left of triangle
+                     (remainder :y+:x 2) = 0   ; only "even" squares
+                     (bitand :y+:x :y-:x) = 0  ; Sierpinski bit test
+                ) ["*] ["| |]                  ; star or space
+  ]
+  print []
+]

Task/Sierpinski-triangle/Lua/sierpinski-triangle.lua

@@ -0,0 +1,17 @@
+function sierpinski(depth)
+   lines = {}
+   lines[1] = '*'
+
+   for i = 2, depth+1 do
+      sp = string.rep(' ', 2^(i-2))
+      tmp = {}
+      for idx, line in ipairs(lines) do
+         tmp[idx] = sp .. line .. sp
+         tmp[idx+#lines] = line .. ' ' .. line
+      end
+      lines = tmp
+   end
+   return table.concat(lines, '\n')
+end
+
+print(sierpinski(4))

Task/Sierpinski-triangle/MATLAB/sierpinski-triangle-1.m

@@ -0,0 +1,7 @@
+n = 4;
+d = string('*');
+for k = 0 : n - 1
+  sp = repelem(' ', 2 ^ k);
+  d = [sp + d + sp, d + ' ' + d];
+end
+disp(d.join(char(10)))