Cantor set: Difference between revisions

See details at this Wikipedia webpage:   [https://en.wikipedia.org/wiki/Cantor_set Cantor set]

<br><br>

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

{{trans|Python}}

V HEIGHT = 5

 

L(i) 0 .< HEIGHT

V beg = WIDTH * i

{{out}}

<pre>

* * * * * * * * * * * * * * * *

</pre>

 

=={{header|Ada}}==

 

procedure Cantor_Set is

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

end loop;

{{out}}

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

*** *** *** *** *** *** *** ***

* * * * * * * * * * * * * * * *</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>

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

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

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

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

=={{header|Arturo}}==

 

height: 5

 

 

loop lines 'line

 

{{out}}

*** *** *** *** *** *** *** ***

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

=={{header|AWK}}==

# syntax: GAWK -f CANTOR_SET.AWK

# converted from C

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

}

{{out}}

<pre>

</pre>

 

{{trans|FreeBASIC}}

ancho = 81 : alto = 5

dim intervalo(alto, ancho)

print

next i

{{out}}

<pre>

</pre>

=={{header|C}}==

{{trans|Kotlin}}

 

#define WIDTH 81

print();

return 0;

 

{{output}}

* * * * * * * * * * * * * * * *

</pre>

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

{{trans|Java}}

 

namespace CantorSet {

}

}

{{out}}

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

*** *** *** *** *** *** *** ***

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

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

{{trans|D}}

 

const int WIDTH = 81;

 

return 0;

{{out}}

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

*** *** *** *** *** *** *** ***

* * * * * * * * * * * * * * * *</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}}

Same result of Java

 

=={{header|Excel}}==

 

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

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

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

 

|}

| style="text-align:left" | 1

|}

=={{header|Factor}}==

sequences.repeating ;

IN: rosetta-code.cantor-set

concat print ;

{{out}}

<pre>

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

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

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

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

=={{header|FreeBASIC}}==

Const ancho = 81

Const alto = 5

Next i

End

{{out}}

<pre>

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

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

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

}

 

{{out}}

* * * * * * * * * * * * * * * *

</pre>

=={{header|Groovy}}==

{{trans|Java}}

private static final int WIDTH = 81

private static final int HEIGHT = 5

}

}

{{out}}

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

*** *** *** *** *** *** *** ***

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

=={{header|Haskell}}==

===Interval bars===

{{Trans|Python}} (Functional version)

 

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

where

 

cantorLines :: Int -> String

cantorLines n =

 

showCantor :: [(Bool, Int)] -> String

{{Out}}

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

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

 

cantor = (go =<<)

where

m = quot (length x) 3

block = take m x

 

main :: IO ()

{{Out}}

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

===Dual representation===

Intervals as fraction pairs, and intervals as graphic bars:

import Data.Ratio (Ratio, denominator, numerator, (%))

 

 

cantor :: (Rational, Rational) -> [[(Rational, Rational)]]

where

go (x, y) = [(x, x + r), (y - r, y)]

('(' :) . (<> ")")

. intercalate ") ("

 

showRatio :: Rational -> String

go x

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

{{Out}}

<pre>(0, 1)

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

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

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

*** *** *** *** *** *** *** ***

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

=={{header|JavaScript}}==

{{Trans|Python}} (Functional version)

{{Trans|Haskell}}

 

 

];

 

 

 

 

 

 

 

// iterate :: (a -> a) -> a -> Gen [a]

 

 

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

length: n

}, () => {

const x = xs.next();

return x.done ? [] : [x.value];

}));

 

// MAIN ---

return main();

{{Out}}

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

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

 

{{Trans|Haskell}}

 

 

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

const

m = Math.floor(s.length / 3),

) : [s];

};

};

 

 

 

 

// iterate :: (a -> a) -> a -> Gen [a]

 

 

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

length: n

}, () => {

const x = xs.next();

return x.done ? [] : [x.value];

}));

 

// MAIN ---

return main();

{{Out}}

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

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

 

{{Trans|Haskell}}

{{Trans|Python}}

 

 

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.

 

 

 

const cantor = xs => {

return [

];

};

};

 

// intervalRatios :: [(Rational, Rational)] -> String

const intervalRatios = xs => {

};

 

// intervalBars :: [[(Rational, Rational)]] -> String

const go = w => xs =>

);

);

};

 

 

 

// Tuple (,) :: a -> b -> (a, b)

 

// abs :: Num -> Num

 

 

 

 

// floor :: Num -> Int

const

nr = (

properFraction

) : properFracRatio

)(x),

n = nr[0];

return 0 > nr[1] ? n - 1 : n;

};

 

 

// fst :: (a, b) -> a

 

 

// iterate :: (a -> a) -> a -> Gen [a]

 

// last :: [a] -> a

const last = xs =>

 

// lcm :: Int -> Int -> Int

 

 

 

 

// maximum :: Ord a => [a] -> a

 

// properFracRatio :: Ratio -> (Int, Ratio)

const properFracRatio = nd => {

};

 

// properFraction :: Real -> (Int, Real)

const properFraction = n => {

const i = Math.floor(n) + (n < 0 ? 1 : 0);

};

 

 

 

 

// ratioDiv :: Rational -> Rational -> Rational

};

 

// ratioMinus :: Rational -> Rational -> Rational

};

 

// ratioMult :: Rational -> Rational -> Rational

 

);

};

 

// rational :: Num a => a -> Rational

const rational = x =>

 

// replicateString :: Int -> String -> String

 

// showRatio :: Ratio -> String

const showRatio = r =>

r.toString()

) : r.n.toString() + (

1 !== r.d ? (

);

 

// signum :: Num -> Num

 

// snd :: (a, b) -> b

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

length: n

}, () => {

const x = xs.next();

return x.done ? [] : [x.value];

}));

 

// unlines :: [String] -> String

 

// MAIN ---

return main();

{{Out}}

<pre>(0, 1)

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

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

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

yields the same output as shown e.g. under `awk`, `julia`, etc.

jq -nr --argjson width 81 --argjson height 5 -f cantor.jq

=={{header|Julia}}==

{{trans|AWK}}

const height = 5

 

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

end

<pre>

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

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

</pre>

=={{header|Kotlin}}==

Simple terminal drawing.

 

const val WIDTH = 81

cantor(0, WIDTH, 1)

lines.forEach { println(it) }

 

{{output}}

* * * * * * * * * * * * * * * *

</pre>

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

*** *** *** *** *** *** *** ***

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

 

=={{header|Perl}}==

{{trans|Raku}}

use feature 'say';

 

}

 

 

{{Out}}

 

===regex version===

 

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

$_ = '#' x 81;

 

{{out}}

<pre>

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

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

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

</pre>

=={{header|Phixmonti}}==

 

5 >ps

cps

line ?

Other solution

 

5 >ps

endfor

endfor

{{out}}

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

 

=== Press any key to exit ===</pre>

 

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

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

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

=={{header|QB64}}==

{{trans|FreeBASIC}}

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

q q q q q q q q q q q q q q q q

</pre>

=={{header|R}}==

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

 

Currently, RosettaCode does not seem to accept image upload anymore.

So, you will have to run the program under R or RStudio IDE to get the diagram result.

=={{header|Racket}}==

{{trans|Kotlin}}

 

;; {trans|Kotlin}}

 

(module+ main

(for-each displayln (Cantor_set)))

{{out}}

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

* * * * * * * * * * * * * * * *

</pre>

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Kotlin}}

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

 

}

 

 

{{Out}}

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

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

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

 

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

</pre>

=={{header|Ring}}==

# Project : Cantor set

 

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

ok

Output image:

 

[https://www.dropbox.com/s/ap7c3301i0syh4e/CantorSet.jpg?dl=0 Cantor set]

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

 

</pre>

=={{header|Rust}}==

use convert_base::Convert;

use std::fmt;

}

 

{{out}}

<pre>

 

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

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

</pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

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

 

| intervals |

]

 

Output:

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

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

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

 

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

{{trans|C#}}

 

Const WIDTH = 81

End Sub

 

{{out}}

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

*** *** *** *** *** *** *** ***

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

 

=={{header|Wren}}==

{{trans|Kotlin}}

var height = 5

 

 

cantor.call(0, width, 1)

 

{{out}}

</pre>

 

=={{header|zkl}}==

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

}(0,WIDTH,1);

 

{{out}}

<pre>