Sierpinski carpet: Difference between revisions

{{trans|Python}}

V carpet = [String(‘#’)]

L 1..n

R carpet.join("\n")

=={{header|Action!}}==

DO

IF x MOD 3=1 AND y MOD 3=1 THEN

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sierpinski_carpet.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure Sierpinski_Carpet is

Divide_Square(Pattern, 3);

Print(Pattern);

=={{header|ALGOL 68}}==

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

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

INT x := in x, y := in y;

BOOL out;

OD;

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

{{Trans|C}}

As with the first C sample, uses pairs of characters for each point to give a squarer appreaence.

for depth := 3 do begin

integer dim;

end for_depth

end.

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre>

(ES5 Functional version)

-- sierpinskiCarpet :: Int -> [[Bool]]

end script

end if

{{Out}}

<pre>███

Or, defining the Sierpinski carpet weave more simply in terms of generic abstractions like '''zipWith''' and '''concatMap''':

on weave(xs)

script thread

end |λ|

end script

{{Out}}

<pre>█████████

=={{header|Applesoft BASIC}}==

110 POKE 49234,0

120 DEF FN M(X) = X - INT (D * 3) * INT (X / INT (D * 3))

210 HPLOT J,I

220 NEXT J

=={{header|Arturo}}==

X: x

Y: y

]

{{out}}

=={{header|Asymptote}}==

return

point(p, node + 1/3) + point(p, node - 1/3) - point(p, node);

size(9 inches, 6 inches);

=={{header|AutoHotkey}}==

{{trans|Python}}

ahk [http://www.autohotkey.com/forum/topic44657-150.html discussion]

MsgBox % Carpet(A_Index)

Else x //= 3, y //= 3

Return "."

=={{header|AWK}}==

#

# syntax: GAWK -f WSC.AWK [-v o={a|A}{b|B}] [-v X=anychar] iterations

}

exit(0)

{{out|Sample}}

<pre>

=={{header|BASIC256}}==

function in_carpet(x, y)

while x <> 0 and y <> 0

next k

end

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

{{works with|BBC BASIC for Windows}}

side% = 3^Order%

VDU 23,22,8*side%;8*side%;64,64,16,128

Y% DIV= 3

UNTIL X%=0 AND Y%=0

[[File:sierpinski_carpet_bbc.gif]]

The order, N, is specified by the first number on the stack. The upper limit is implementation dependent and is determined by the interpreter's cell size.

>p>40p"#"30g40g*!#v_$48*30g3%1-v^ >$55+,1v>

0 ^p03/3g03/3g04$_v#!*!-1%3g04!<^_^#- g00 <

=={{header|BQN}}==

1) a trit in the x-coordinate is 1, and

2) the trit in the same position in the y-coordinate is also 1.</blockquote>

Carpet ← { # 2D Array method using ∾.

{∾(3‿3⥊4≠↕9)⊏⟨(≢𝕩)⥊0,𝕩⟩}⍟(𝕩-1) 1‿1⥊1

•Show " #"⊏˜Carpet 4

╵"###########################

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

###########################"

┘

=={{header|Brainf***}}==

Double the first two prints for squarer output.

orders over 5 require larger cell sizes

+<<<-]>>>[<<<+>>>-]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>[>+<-]<-]>[-]+>[[-]<->]<[->+<]>

[<<+>>-]<<[>>+++++[<+++++++>-]<.[-]<<[-]<[-]<<<->>>>>-]<<<-]<<]<-]++++++++++.[-]

{{out}}

=={{header|C}}==

If you write coordinates of any point on the carpet in base 3, the pixel is blank if and only if any matching pair of digits are (1, 1).

int main()

return 0;

#include <stdlib.h>

#include <string.h>

// fclose(f);

return 0;

Recursive version:

#include <stdlib.h>

return 0;

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

{{trans|Ruby}}

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

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(s);

}

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

Performance focused variant (about 7x faster than the div/mod solutions at AMD Ryzen 7 4800H)

// BCT = Binary-Coded Ternary: pairs of bits form one digit [0,1,2] (0b11 is invalid digit)

return 0;

[[File:sierpinski_cpp.png|300px]]

#include <windows.h>

#include <math.h>

}

//--------------------------------------------------------------------------------------------------

=={{header|Clojure}}==

{{trans|Scheme}}

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

(if (in-carpet? x y) "*" " ")))))))

=={{header|Commodore BASIC}}==

110 PRINT

120 INPUT "ORDER"; O$

310 PRINT

320 NEXT Y

{{Out}}

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

This solution works by printing a square of # except where both of the coordinates of a cell contain a 1 in the same digit position in base 3. For example, the central empty square has a 1 in the highest base-3 digit of all its cells, and the smallest empty squares have 1s in the lowest base-3 digit.

(let ((size (expt 3 order)))

(flet ((trinary (x) (format nil "~3,vR" order x))

(princ (if (some #'ones (trinary i) (trinary j))

" "

=={{header|Crystal}}==

{{trans|Ruby}}

carpet = ["#"]

n.times do

end

{{out}}

=={{header|D}}==

{{trans|Python}}

auto sierpinskiCarpet(in int n) pure nothrow @safe {

void main() {

3.sierpinskiCarpet.writeln;

More functional style:

auto nextCarpet(in string[] c) pure nothrow {

.front

.binaryReverseArgs!writefln("%-(%s\n%)");

A more direct and efficient version:

char[][] sierpinskiCarpet(in size_t n) pure nothrow @safe {

writefln("%-(%s\n%)", 3.sierpinskiCarpet);

7.sierpinskiCarpet.length.writeln;

=={{header|Delphi}}==

=={{header|DWScript}}==

{{Trans|Java}}

begin

while (x<>0) and (y<>0) do begin

end;

=={{header|E}}==

{{trans|Python}}

while (x > 0 && y > 0) {

if (x %% 3 <=> 1 && y %% 3 <=> 1) {

println()

}

=={{header|Elixir}}==

{{trans|Ruby}}

def sierpinski_carpet(n), do: sierpinski_carpet(n, ["#"])

IO.puts "\nN=#{n}"

Enum.each(RC.sierpinski_carpet(n), fn line -> IO.puts line end)

{{out}}

=={{header|Erlang}}==

-module(carpet).

-export([main/0]).

carpet(X div 3, Y div 3)

end.

{{out}}

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

=={{header|ERRE}}==

PROGRAM SIERP_CARPET

CLOSE(1)

END PROGRAM

Output is redirected to file OUT.PRN: you can change this to SCRN: to screen or "LPTx:" for a parallel printer.

Output taken from OUT.PRN file:

=={{header|Euphoria}}==

include std/math.e

puts(1,'\n')

end for

=={{header|Excel}}==

{{Works with|Office 365 betas 2021}}

=LAMBDA(xs,

IF(0 <> xs, "█", " ")

)(triple)

)

and also assuming the following generic bindings in the Name Manager for the WorkBook:

=LAMBDA(xs,

LAMBDA(ys,

)

)

{{Out}}

=={{header|F_Sharp|F#}}==

{{trans|OCaml}}{{trans|Ruby}}

let blank x = new String(' ', String.length x)

aux n ["#"]

=={{header|Factor}}==

The order n sierpinski carpet is the &nbsp; [[Kronecker product| Kronecker product]] &nbsp; of order n-1 and order 1.

: sierpinski ( n -- )

curry times [ 1 = "#" " " ? ] matrix-map simple-table. ;

=={{header|Fan}}==

** Generates a square Sierpinski gasket

**

carpet(4)

}

=={{header|Fennel}}==

(if

(or (= 0 x) (= 0 y)) true

(for [i 0 3]

(make-carpet i)

=={{header|Forth}}==

{{trans|Fan}}

: 1? over 3 mod 1 = ; ( n1 n2 -- n1 n2 f)

: 3/ 3 / swap ; ( n1 n2 -- n2/3 n1)

;

=={{header|Fortran}}==

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

{{trans|Python}}

implicit none

end do

end subroutine Carpet

{{trans|QB64}}

===versión ASCII===

Function in_carpet(x As Uinteger, y As Uinteger) As Boolean

While x <> 0 And y <> 0

Next k

Sleep

{{trans|QB64}}

===versión gráfica===

Screenres 500, 545, 8

Windowtitle "Sierpinski Carpet"

carpet(253, 293, 243, 3)

Sleep

[[File:SC5gp1.png|right|thumb|Output SC5gp1.png]]

## SCff.gp 1/14/17 aev

## Plotting Sierpinski carpet fractal.

ttl = "Sierpinski carpet fractal, v.#1"

load "plotff.gp"

{{Output}}

<pre>

;plotscf.gp:

## plotscf.gp 12/7/16 aev

## Plotting a Sierpinski carpet fractal to the png-file.

plot -100

set output

;plotscf1.gp:

## plotscf1.gp 12/7/16 aev

## Plotting a Sierpinski carpet fractal to the png-file.

splot sc(x,y)

set output

;Plotting v.#2 and v.#3:

## pSCF.gp 12/7/16 aev

## Plotting Sierpinski carpet fractals.

filename = "SCF31gp"; ttl = "Sierpinski carpet fractal #31, ord ".ord;

load "plotscf1.gp"

{{Output}}

<pre>

=={{header|Go}}==

Variable "grain" shown set to "#" here, but it's fun to experiment with other values. "|", ". ", "[]", "___", "██", "░░"...

import (

fmt.Println(r)

}

=={{header|Groovy}}==

Solution, uses list-indexing of base 3 string representation:

def sierpinskiCarpet = { int order ->

}

sb.toString()

Test Program:

{{out}}

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

=={{header|Haskell}}==

inCarpet 0 _ = True

inCarpet _ 0 = True

printCarpet :: Int -> IO ()

{{trans|Ruby}}

nextCarpet carpet = border ++ map f carpet ++ border

where border = map (concat . replicate 3) carpet

main :: IO ()

Seems not very different from version above,

main = putStr . unlines . (!!3) $ iterate next ["#"]

where

(!) = zipWith (++)

which we could also read as:

carpet = unlines . (iterate weave ["██"] !!)

main :: IO ()

Or more applicatively, representing different phases of the weaving shuttle as <*> and <>:

carpet = unlines . (iterate weave ["██"] !!)

main :: IO ()

{{Out}}

<pre>██

{{works with|GHC}}

{{libheader|diagrams}}

import Control.Monad.Trans (lift)

import Data.Colour (Colour)

cell :: Colour Float -> Diagram Cairo R2

cell color = square 1 # lineWidth 0 # fillColor color

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

The IsFilled procedure is a translation of Java and Python.

procedure main(A)

}

return

{{out}}

<pre>Carpet order= 2

=={{header|Io}}==

Based on Python translation of Ruby.

carpet := list("@")

n repeat(

)

{{out}}

<pre>@@@@@@@@@@@@@@@@@@@@@@@@@@@

=={{header|J}}==

Like the sierpinski triangle, the carpet is straightforward to produce in J. One approach is based on repeatedly putting a function's argument in a box, forming 9 copies of it into a 3 by 3 array, and then replacing the contents of the middle box with blanks:

But N=:3 is big, so let's use N=:2

(a:(<1;1)}3 3$<)^:N' '

┌─────────────┬─────────────┬─────────────┐

││ │ │ │││ │ │ │││ │ │ ││

│└───┴───┴───┘│└───┴───┴───┘│└───┴───┴───┘│

or another way of getting the same image starts with the boolean array

1 1 1

1 0 1

((#:7 5 7){_2{.<)^:N' '

┌─────────────┬─────────────┬─────────────┐

││ │ │ │││ │ │ │││ │ │ ││

│└───┴───┴───┘│└───┴───┴───┘│└───┴───┴───┘│

That said, using spaces and '#' characters takes a bit more work. One approach would be:

scarp=:{{' #'{~(#:7 5 7) ,/@(1 3 ,/"2@|: */)^:y ,.1}}

scarp 2

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

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

Here, what we are doing is forming a tensor product of our #:7 5 7 boolean array with our argument and then collapsing two of the dimensions so they line up right. Our starting argument is the 1 by 1 array with the value 1. Once we have repeated this process enough times, we select spaces for our zeros and pound signs for our 1s.

=={{header|Java}}==

{{trans|Python}}

while (x!=0 && y!=0) {

if (x % 3 == 1 && y % 3 == 1)

System.out.println();

}

===Animated version===

[[File:sierpinski_carpet_java.png|300px|thumb|right]]

{{works with|java|8}}

import java.awt.event.ActionEvent;

import javax.swing.*;

});

}

=={{header|JavaScript}}==

{{works with|Firefox|1.5+}}

This version also produces a "graphic" via HTML and CSS.

<html>

<head>

</body>

{{out}}

[[File:Sierpinski carpet js.png]]

Creates an N by N array of boolean values, which are mapped to lines of characters for output.

// as lines of text.

}).join('\n');

Output (orders 1, 2 and 3):

===ES6===

'use strict';

return [1, 2, 3]

.map(sierpinskiCarpet);

{{Out}}

Or, defining the Sierpinksi carpet weave declaratively, in terms of '''zipWith''' and '''concatMap''':

'use strict';

// MAIN -----------------------------------------------

return main();

{{Out}}

<pre>█████████

This is like a "for" loop within a "for" loop in C-like languages, because range(0;n) generates a stream of n integers beginning at 0. The -1 is used to signal that a newline character is required.

def inCarpet(x; y):

x as $x | y as $y |

=={{header|Julia}}==

{{works with|Julia|0.6}}

x = fill(token, 1, 1)

for _ in 1:n

end

=={{header|Kotlin}}==

===ASCII Art Version===

{{trans|Python}}

fun inCarpet(x: Int, y: Int): Boolean {

}

{{out}}

===Graphical Animated Version===

{{trans|Java}}

import java.awt.*

f.isVisible = true

}

=={{header|Lua}}==

An excellent opportunity to show off tail calls, so, recursively..

print("n = " .. n)

local function S(x, y)

for n = 0, 4 do

carpet(n, function(b) return b and "■ " or " " end)

{{out}}

<pre style="font-size:50%">n = 0

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

WindowWidth = 508

WindowHeight = 575

Call carpet newX-side, newY, side, order

End If

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Replace a empty spot with a 3x3 empty matrix, and replace a full spot with an empty spot surrounded by 8 full spots:

empty={{0,0,0},{0,0,0},{0,0,0}}

n=3;

=={{header|MATLAB}}==

c = string('#');

for k = 1 : n

c = [c + c + c, c + c.replace('#', ' ') + c, c + c + c];

end

{{out}}

<pre>###########################

{{trans|BBC BASIC}}

{{works with|Nascom ROM BASIC|4.7}}

10 REM Sierpinski carpet

20 CLS

410 DATA 27085,14336,-13564,6399,18178,10927

420 DATA -8179,233

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

end edge

return isFilled

{{out}}

Sample shown with order "2".

=={{header|Nim}}==

{{trans|Python}}

proc inCarpet(x, y: int): bool =

echo()

{{out}}

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

=={{header|Objeck}}==

{{trans|Python}}

function : Main(args : String[]) ~ Nil {

Carpet(3);

};

}

=={{header|OCaml}}==

if x = 0 || y = 0 then true

else if x mod 3 = 1 && y mod 3 = 1 then false

done;

print_newline ()

{{trans|Ruby}}

List.map (fun x -> x ^ x ^ x) carpet @

List.map (fun x -> x ^ String.make (String.length x) ' ' ^ x) carpet @

let () =

=={{header|Oforth}}==

| dim i j k |

3 n pow ->dim

]

printcr

=={{header|Order}}==

Since the C Preprocessor cannot print newlines, this Order program produces a string for a simple C program to print:

#define ORDER_PP_DEF_8in_carpet ORDER_PP_FN( \

printf(ORDER_PP( 8carpet_to_string(8carpet(3)) ));

return 0;

(This example may take a long time to compile: change the <code>8carpet</code> parameter to 2 for a much quicker compile time and a smaller graphic.)

=={{header|Oz}}==

%% A carpet is a list of lines.

fun {NextCarpet Carpet}

in

%% print all lines of the Sierpinski carpet of order 3

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

===Plotting helper functions===

Note: wrtmat() can be found here on RC [[Brownian_tree#PARI.2FGP| Brownian tree page]].

\\ Improved simple plotting using matrix mat (color and scaling added).

\\ Matrix should be filled with 0/1. 7/6/16 aev

x\=3; y\=3;);\\wend

}

===Sierpinski carpet fractal.===

\\ Sierpinski carpet fractal (n - order, clr - color, dfn - data file name)

\\ 6/10/16, upgraded 11/29/16 aev

{pSierpinskiC(5,,"c:\\pariData\\SC5.dat");

iPlotV2("c:\\pariData\\SC5.dat",10);} \\ SierpC5a.png, color - dark-green

{{Output}}

=={{header|Pascal}}==

uses

Carpet(3);

{$IFNDEF UNIX} readln; {$ENDIF}

{{out}}

<pre>:> ./SierpinskiCarpet

=={{header|Perl}}==

@c = (map($_ x 3, @c), map($_.(' ' x length).$_, @c), map($_ x 3, @c))

for 1 .. 3;

=={{header|Phix}}==

{{Trans|Euphoria}}

<span style="color: #008080;">constant</span> <span style="color: #000000;">order</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">4</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>

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

{{out}}

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

=={{header|PHP}}==

function isSierpinskiCarpetPixelFilled($x, $y) {

sierpinskiCarpet($order);

echo PHP_EOL;

{{out}}

=={{header|Picat}}==

{{works with|Picat}}

in_carpet(X, Y) =>

while (X != 0, Y != 0)

nl

end.

{{out}}

<pre>

=={{header|PicoLisp}}==

{{trans|Ruby}}

(let Carpet '("#")

(do N

(mapcar '((S) (pack S S S)) Carpet) ) ) ) ) )

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

/* Sierpinski carpet */

end Carpet;

end Sierpinski_carpet;

The above is a translation of the Fortran version.

Output for n=3:

=={{header|PostScript}}==

%%BoundingBox 0 0 300 300

pop showpage

=={{header|PowerShell}}==

<h3>Text based solution</h3>

{{works with|PowerShell|2}}

{

$Carpet = @( '#' ) * [math]::Pow( 3, $N )

}

{{out}}

<pre>###########################

<h3>Graphics based solution</h3>

{{works with|PowerShell|3}}

{

# Define form

}

{{out}}

{{incomplete|powershell|Upload of files currently blocked. Needs output screenshot once file uploading is again allowed.}}

=={{header|Processing}}==

void setup() {

}

}

==={{header|Processing Python mode}}===

{{trans|Processing}}

def setup():

size(729, 729)

rect(xx + delta, yy + delta, delta, delta)

rectangles(xx + s / 3, yy + s / 3, s / 3)

=={{header|Prolog}}==

{{works with|SWI Prolog}}

This program produces an image file in SVG format.

write_sierpinski_carpet('sierpinski_carpet.svg', 486, 4).

format(Stream,

"<rect fill='black' x='~g' y='~g' width='~g' height='~g'/>\n",

{{out}}

=={{header|PureBasic}}==

{{trans|Python}}

While x>0 And y>0

If x%3=1 And y%3=1

PrintN("")

Next

=={{header|Python}}==

This inserts a space after every character; but this makes the spacing look better anyway.