Sierpinski carpet: Difference between revisions

{{trans|Python}}

 

V carpet = [String(‘#’)]

L 1..n

R carpet.join("\n")

 

 

=={{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>

</pre>

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

(ES5 Functional version)

 

 

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

-- inCarpet :: Int -> Int -> Bool

on inCarpet(x, y)

true

else

inCarpet(x div 3, y div 3)

end if

 

 

on run

-- Carpets of orders 1, 2, 3

end run

 

 

-- showCarpet :: Int -> String

on showCarpet(n)

-- showRow :: [Bool] -> String

script showRow

 

 

 

-- enumFromTo :: Int -> Int -> [Int]

on enumFromTo(m, n)

else

end if

end enumFromTo

 

-- map :: (a -> b) -> [a] -> [b]

end map

 

 

-- Lift 2nd class handler function into 1st class script wrapper

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>█████████

█ ██ ██ █

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

 

 

=={{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>

</pre>

 

{{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]]

 

=={{header|Befunge}}==

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|C}}==

 

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++}}==

[[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|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|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|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

 

=={{header|Gnuplot}}==

[[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 ["██"] !!)

 

weave :: [String] -> [String]

weave xs =

g = flip f

 

main :: IO ()

 

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

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

weave :: [String] -> [String]

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>@@@@@@@@@@@@@@@@@@@@@@@@@@@

@ @@ @@ @@ @@ @@ @@ @@ @@ @

@@@@@@@@@@@@@@@@@@@@@@@@@@@</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:

#########

# ## ## #

# ## ## #

#########

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

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

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

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

 

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

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■</pre>

 

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>###########################

 

=={{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}}

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

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

</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|Python}}==

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

while True:

if x == 0 or y == 0:

else:

print ' ',

This version is elegant:

{{trans|Ruby}}

carpet = ["#"]

for i in xrange(n):

return "\n".join(carpet)

 

 

 

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import chain, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Iterations of the Sierpinski carpet:

▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓</pre>

 

=={{header|Quackery}}==

{{trans|Forth}}

 

 

[ 3 / swap ] is 3/ ( n1 n2 --> n2/3 n1 )

drop ] is carpet ( n --> )

 

 

{{out}}Shown at half size.

{{Works with|R|3.3.3 and above}}

[[File:SierpCRo5.png|200px|right|thumb|Output SierpCRo5.png]]

## Are x,y inside Sierpinski carpet (and where)? (1-yes, 0-no)

inSC <- function(x, y) {

## Executing:

pSierpinskiC(5);

{{Output}}

<pre>

{{Works with|R|3.3.3 and above}}

[[File:SierpCR2o5.png|200px|right|thumb|Output SierpCR2o5.png]]

## Plotting Sierpinski carpet fractal v.2. aev 4/2/17

## ord - order, fn - file name, ttl - plot title, clr - color

## Executing:

pSierpinskiC2(5);

{{Output}}

<pre>

 

=={{header|Racket}}==

#lang racket

(define (carpet n)

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

(for-each displayln (carpet 3))

 

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Tcl}}

{

(['#'], -> @c {

say @carpet[3];

 

 

=={{header|Relation}}==

Used _ instead of spaces beause wikitext compacts subsequents spaces

function incarpet(x,y)

set a = x

 

run carpet(3)

 

<pre>

 

=={{header|REXX}}==

parse arg N char . /*get the order of the carpet. */

if N=='' | N=="," then N= 3 /*if none specified, then assume 3. */

if length(z)<width then say z /*display the line if it fits on screen*/

call lineout 'Sierpinski.'N, z /*also, write the line to a (disk) file*/

This REXX program makes use of &nbsp; '''linesize''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

 

 

=={{header|Ring}}==

load "guilib.ring"

 

end

return true}

Output:

[[File:CalmoSoftCarpet.jpg]]

=={{header|Ruby}}==

{{trans|Tcl}}

carpet = ["#"]

n.times do

end

 

 

{{out}}

{{libheader|RubyGems}}

{{libheader|JRubyArt}}

attr_reader :limit

 

size(729, 729)

end

 

=={{header|Rust}}==

{{trans|Ruby}}

for i in 0..4 {

println!("\nN={}", i);

}

 

 

=={{header|Scala}}==

{{trans|Ruby}}

carpet.map(x => x + x + x) :::

carpet.map(x => x + x.replace('#', ' ') + x) :::

carpet.map(x => x + x + x))

 

 

=={{header|Scheme}}==

(define (in-carpet? x y)

(cond ((or (zero? x) (zero? y))

#\*

#\space)))

 

=={{header|Seed7}}==

 

const func boolean: inCarpet (in var integer: x, in var integer: y) is func

begin

carpet(3);

 

=={{header|Sidef}}==

3.times {

c = (c.map{|x| x * 3 } +

c.map{|x| x * 3 })

}

 

=={{header|Swift}}==

{{trans|Ruby}}

func sierpinski_carpet(n:Int) -> String {

func middle(str:String) -> String {

}

 

 

=={{header|Tcl}}==

 

proc map {lambda list} {

}

 

 

=={{header|UNIX Shell}}==

{{works with|Bash}}

Doesn't pretend to be efficient.

 

Note that this code inserts a space between characters; some versions of [http://en.wikipedia.org/wiki/Paste_(Unix) paste(1)] (notably the one that ships with OS X) won't allow an empty delimiter. If yours does, you can replace the <tt>-d ' '</tt> in the function body with <tt>-d </tt>' '<tt> </tt>for more compact output.

 

sierpinski_carpet() {

done

echo "$carpet"

 

Sample run:

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

</pre>

 

=={{header|Ursala}}==

The carpet function works for any natural number n and is tested on 0,1,2, and 3.

The carpet is stored as a list of lists of booleans but converted to characters for display.

#import nat

 

#show+

 

{{out}}

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

</pre>

 

 

 

 

 

{{out}}

 

=={{header|Wren}}==

{{trans|Python}}

while (true) {

if (x == 0 || y == 0) return true

}

 

 

{{out}}

 

Uses magic number division to avoid repeatedly using the div instruction in a loop.

;Tested in windows 7 Enterprise Service Pack 1 64 bit

;With the AMD FX(tm)-6300 processor

 

mov rcx,1

 

{{out|Sample}}

=={{header|XPL0}}==

[[File:CarpetXPL0.gif|right]]

 

proc DrawPat(X0, Y0, S); \Draw 3x3 pattern with hole in middle

if ChIn(1) then []; \wait for keystroke

SetVid($3); \restore normal text mode

 

 

 

 

 

 

=={{header|zkl}}==

{{trans|XPL0}}

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

foreach y,x in (3,3){

if(x.isEven or y.isEven){ // don't draw middle pattern

}

}

drawPat(0,0,(3).pow(5),img);

 

[[Category:Geometry]]