Cantor set: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V HEIGHT = 5

 

L(i) 0 .< HEIGHT

V beg = WIDTH * i

{{out}}

<pre>

 

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

INT i

 

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

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

 

=={{header|Ada}}==

 

procedure Cantor_Set is

Ada.Text_IO.Put_Line (Image (L));

end loop;

{{out}}

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

 

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

# draw a Cantor Set using ASCII #

INT lines = 5; # number of lines for the set #

segment width OVERAB 3

OD

{{out}}

<pre>

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

Based on the Algol 68 sample.

% draw a Cantor Set using ASCII %

integer LINES; % number of lines for the set %

end for_l

end

{{out}}

<pre>

 

Using composable library functions whenever possible, for better productivity:

 

-- cantor :: [String] -> [String]

set my text item delimiters to dlm

str

{{Out}}

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

=={{header|Arturo}}==

 

height: 5

 

 

loop lines 'line

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f CANTOR_SET.AWK

# converted from C

cantor(start+seg*2,seg,indx+1)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

20 N = 4

30 W = 3^(N-1)

120 MID$(L$,P,S) = SPACE$(S)

130 P = P+S

{{out}}

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

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

global ancho, alto, intervalo

ancho = 81 : alto = 5

next i

End

{{out}}

<pre>

 

=={{header|BQN}}==

 

{{out}}

=={{header|C}}==

{{trans|Kotlin}}

 

#define WIDTH 81

print();

return 0;

 

{{output}}

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

{{trans|Java}}

 

namespace CantorSet {

}

}

{{out}}

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

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

{{trans|D}}

 

const int WIDTH = 81;

 

return 0;

{{out}}

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

 

=={{header|CLU}}==

rep = null

ac = array[char]

cs: string := cantor$make(81, 5, '*')

stream$puts(po, cs)

{{out}}

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

 

=={{header|COBOL}}==

PROGRAM-ID. CANTOR.

BLANK-CHAR.

MOVE SPACE TO CHAR(POS).

{{out}}

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

=={{header|D}}==

{{trans|C}}

 

enum WIDTH = 81;

writeln(lines[beg..beg+WIDTH]);

}

{{out}}

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

=={{header|Delphi}}==

{{Trans|Java}}

program Cantor_set;

 

Readln;

end.

 

{{out}}

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(n,

APPLYN(n)(

)

)

 

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

 

=LAMBDA(xs,

LAMBDA(ys,

)

)

 

{{Out}}

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1

| style="text-align:right; " | SHOWCANTOR(CANTOR(0))

 

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2

| style="text-align:right; " | SHOWCANTOR(CANTOR(1))

 

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3

| style="text-align:right; " | SHOWCANTOR(CANTOR(2))

███ ███

 

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4

| style="text-align:right; " | SHOWCANTOR(CANTOR(3))

█████████ █████████

███ ███ ███ ███

 

|}

 

=={{header|Factor}}==

sequences.repeating ;

IN: rosetta-code.cantor-set

concat print ;

{{out}}

<pre>

=={{header|Forth}}==

Where is says <code>[email protected]</code> it should say <code>c&#64;</code>, but I'm not keen on writing it as <code>c&amp;#64;</code> in the actual code.

 

4 \ iterations

: go print BEGIN step done? UNTIL ;

 

Output:

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

 

=={{header|FreeBASIC}}==

Const ancho = 81

Const alto = 5

Next i

End

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

fmt.Println(string(line[:]))

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static final int WIDTH = 81

private static final int HEIGHT = 5

}

}

{{out}}

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

===Interval bars===

{{Trans|Python}} (Functional version)

 

cantor :: [(Bool, Int)] -> [(Bool, Int)]

where

c True = '*'

{{Out}}

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

Or, using strings for the model as well as the display:

 

 

cantor :: [String] -> [String]

. pred

)

{{Out}}

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

===Dual representation===

Intervals as fraction pairs, and intervals as graphic bars:

import Data.Bifunctor (bimap)

import Data.List (intercalate, mapAccumL, maximumBy)

go x

| 1 /= x = '/' : show x

{{Out}}

<pre>(0, 1)

 

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

110 GRAPHICS HIRES 2

120 SET PALETTE BLACK,WHITE

180 CALL CANTOR(X+2*L/3,Y-HEIGHT,L/3,HEIGHT)

190 END IF

 

=={{header|J}}==

The argument to the cantor_dust monad is an integer that describes the depth of the dust. Shown here are results for cantor_dust 2 and for cantor_dust 3 . It works by checking for 1 digits in the base 3 representation of the coordinates. These background coordinates are plotted with # character using ASCII art. 1j1 #"1 expands the lines to improve aspect ratio on character cell (console) display. }:"1 curtails the extra space character line by line. < draws a pretty box.

odometer =: [: (4 $. $.) $&1

 

< (}:"1) 1j1 #"1 '#' (([: <"1 [: ;/"1 (#~ 1 e."1 [: (,/"2) 3 3&#:)) i)}a

)

 

<pre>

</pre>

With an `x' argument cantor_dust generalizes to higher dimensions. Try 3 cantor_dust 2

cantor_dust =: 2&$: :(dyad define)

shape =. x # 3 ^ y

< (}:"1) 1j1 #"1 '#' (([: <"1 [: ;/"1 (#~ 1 e."1 [: (,/"2) 3 3&#:)) i)} a

)

 

=={{header|Java}}==

{{trans|Kotlin}}

private static final int WIDTH = 81;

private static final int HEIGHT = 5;

}

}

{{out}}

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

{{Trans|Python}} (Functional version)

{{Trans|Haskell}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

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

Using strings for the model as well as the display:

{{Trans|Haskell}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

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

In the case of languages like Javascript which lack a built-in Ratio type, or standard Fraction/Ratio library, rendering stages of the set elaboration as lists of fraction pairs may take more work than rendering them as graphic lines.

 

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>(0, 1)

 

=={{header|jq}}==

def cantor($w; $h):

def init: [range(0; $h) | [range(0; $w) | "*"]];

cantor($width; $height)

{{out}}

With the above in a file, cantor.jq, the following incantation

=={{header|Julia}}==

{{trans|AWK}}

const height = 5

 

print(Char(lines[i, j]), j == width ? "\n" : "")

end

<pre>

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

=={{header|Kotlin}}==

Simple terminal drawing.

 

const val WIDTH = 81

cantor(0, WIDTH, 1)

lines.forEach { println(it) }

 

{{output}}

=={{header|Lua}}==

{{trans|python}}

local HEIGHT = 5

local lines = {}

end

print()

{{out}}

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

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

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

{{out}}

A graphic of a Cantor set is shown

=={{header|Modula-2}}==

{{trans|Kotlin}}

FROM Terminal IMPORT Write,WriteLn,ReadChar;

 

 

ReadChar;

 

=={{header|Nim}}==

{{trans|Kotlin}}

 

 

const

cantor(0, Width, 1)

for line in lines:

 

{{Out}}

=={{header|Objeck}}==

{{trans|Java}}

WIDTH : static : Int;

HEIGHT : static : Int;

};

}

 

{{Output}}

=={{header|Perl}}==

{{trans|Raku}}

use feature 'say';

 

}

 

 

{{Out}}

 

===regex version===

 

use strict; # https://rosettacode.org/wiki/Cantor_set

$_ = '#' x 81;

 

{{out}}

<pre>

=={{header|Phix}}==

Based on Algol 68, but even simpler, shorter, and sweeter!

<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span>

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

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

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

5 >ps

cps

line ?

Other solution

 

5 >ps

endfor

endfor

{{out}}

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

 

=={{header|Processing}}==

//Aamrun, 1st July 2022

 

cantorSet(100,10,900,10,1,10,5);

}

 

=={{header|Python}}==

===Imperative===

HEIGHT = 5

 

for i in xrange(HEIGHT):

beg = WIDTH * i

{{out}}

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

Separating ''(Bool, Int)'' model from ''String'' display:

{{Works with|Python|3.7}}

 

from functools import (reduce)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import (chain, islice)

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

===Dual representations – fractional and graphic===

{{Works with|Python|3.7}}

representations of its output.

'''

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>(0, 1)

Note: Other languages will need to zero out the a() array. In QB64 all arrays are initialized to zero at program start.

 

 

Dim Shared As Integer sw, sh, wide, high

Next

Next

 

=={{header|Quackery}}==

===Using an L-System===

 

[ nested quackery join ] ] is expand ( $ --> $ )

dip [ 3 / ] ] ]

2drop

 

{{out}}

[https://creativecommons.org/licenses/by-nc-sa/4.0 Attribution-NonCommercial-ShareAlike 4.0 International, CC BY-NC-SA 4.0] to neonira@gmail.com

 

cantorSet <- function() {

depth <- 6L

list(graph = g, data = df, set = cs)

}

{{out}}

 

{{trans|Kotlin}}

 

;; {trans|Kotlin}}

 

(module+ main

(for-each displayln (Cantor_set)))

{{out}}

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

(formerly Perl 6)

{{trans|Kotlin}}

my $width = 3 ** ($height - 1);

 

}

 

 

{{Out}}

 

=={{header|REXX}}==

w= linesize() /*obtain the width of the display term.*/

if w==0 then w= 81 /*Can't obtain width? Use the default.*/

say $ /*display a line of the Cantor Set. */

#= # % 3 /*the part (thirds) to be blanked out. */

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

# Project : Cantor set

 

cantor(x+floor(lens*2/3),y,floor(lens/3))

ok

Output image:

 

=={{header|Ruby}}==

This works by numbering the segments (starting with 0) in base 3. Print whitespace if this number contains the digit 1; a black square otherwise.

 

(0..lines).each do |exp|

puts chars.map{ |c| c * seg_size }.join

end

{{out}}

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

 

=={{header|Rust}}==

use convert_base::Convert;

use std::fmt;

}

 

{{out}}

<pre>

=={{header|Scala}}==

===Imperative Programming (Q&D)===

val (width, height) = (81, 5)

 

cantor(0, width, 1)

lines.foreach(l => println(l.mkString))

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/QrqaHeu/0 (JavaScript)]

or by [https://scastie.scala-lang.org/4JTi1zXzRq6H4yUlAYNTSw Scastie (JVM)].

 

===Functional Programming (Recommended)===

val (width, height) = (81, 5)

 

output.map(l => (0 to width).map(pos => if (l contains pos) '*' else ' ').mkString)

.mkString("\n"))

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/szUjPWO/7 (JavaScript)]

or by [https://scastie.scala-lang.org/ZaNUtEOcStuBfJImOnEz5Q Scastie (JVM)].

=={{header|Sidef}}==

{{trans|Raku}}

var width = 3**(height - 1)

var lines = height.of { "\N{FULL BLOCK}" * width }

}

 

{{out}}

<pre>

{{works with|GNU Smalltalk}}

Smalltalk represents Intervals' start and stop values as Fraction, so precision is kept for quilte a while.

 

| intervals |

]

 

Output:

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

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Const WIDTH = 81

End Sub

 

{{out}}

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

=={{header|Vlang}}==

{{trans|Go}}

width = 81

height = 5

println(line.bytestr())

}

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

var height = 5

 

 

cantor.call(0, width, 1)

 

{{out}}

 

=={{header|XPL0}}==

int N; char LineSeg; int Len, Third, I;

[if N>0 and Len>1 then

Text(0, LineSeg);

];

 

{{out}}

 

=={{header|zkl}}==

var lines=HEIGHT.pump(List,List.createLong(WIDTH,"\U2588;").copy); // full block

}(0,WIDTH,1);

 

{{out}}

<pre>