The Cantor function is continuous everywhere and constant almost everywhere, but has an average slope of 1:


The function can be found recursively:


\$f_{n+1}(x)=\left\{\begin{matrix}\frac{1}{2}f_n(3x)&x\in[0,\frac{1}{3})\\ \frac{1}{2}&x\in[\frac{1}{3},\frac{2}{3})\\ \frac{1}{2}+\frac{1}{2}f_n(3x-2)&x\in[\frac{2}{3},1] \end{matrix}\right.\$

The Cantor function is the limit of this process, \$\lim\limits_{n\to\infty} f_n(x)\$:

iteration limit

The Challenge

Given real x (which can assume the form of a float or rational number) of the interval \$[0,1]\$ and nonnegative integer n, return \$f_n(x)\$.


  • This is so the shortest answer in bytes wins.

  • Assume only valid input will be given.

  • Error should be under one ten-thousandth (±0.0001) for the test cases.

Test Cases

In: 0.3 3
Out: 0.3875

In: 0.1 0
Out: 0.1

In: 0.29 4
Out: 0.375

In: 0.11 5
Out: 0.2415625
  • 2
    \$\begingroup\$ Related (draw \$f_n\$ in ASCII art) \$\endgroup\$
    – Luis Mendo
    Commented Jul 22, 2020 at 22:08
  • \$\begingroup\$ The average slope is actually 0. \$\endgroup\$ Commented Jul 23, 2020 at 18:44
  • 1
    \$\begingroup\$ Using the average slope formula m=(y2-y1)/(x2-x1) and the points (0,0) and (1,1) one can see the average slope is 1 @PyRulez \$\endgroup\$
    – golf69
    Commented Jul 23, 2020 at 18:47
  • \$\begingroup\$ In any case, the slope is 0 almost everywhere. \$\endgroup\$ Commented Jul 24, 2020 at 21:11

15 Answers 15


APL (Dyalog Extended), 25 27 bytes


Try it online!

Inline tacit function, which can be used as n f x.

Uses the method described in Luis Mendo's MATL answer. I changed one part of the algorithm:

  • This one doesn't consider integer and fractional parts separately; rather, the fractional part is included in the last digit. (e.g. the base-3 representation of 8.1 is [2, 2.1].) Later, at the step where 2s are changed into 1s, all digits ≥2 are reduced by 1 instead, and (+2 bytes) the fractional part of the last digit is removed if its integer part is 1.
{⊥1⊥1⌊⊤1∘≠⍛×\0,3⊤⍵×3*⍺}÷2*⊣  ⍝ Left: n, Right: x
{                ⍵×3*⍺}  ⍝ 3^n*x
               3⊤        ⍝ Convert to base 3; last digit may have fractional part
             0,  ⍝ Prepend 0 to avoid error on ⊤ over an empty array
       1∘≠⍛×\    ⍝ Keep each digit unless at least one 1 appears somewhere on its left
      ⊤  ⍝ Convert each digit to binary
    1⌊   ⍝ Clamp all digits >1 to 1 (effectively cuts the fractional part of
         ⍝ the last digit if its integer part is 1)
  1⊥     ⍝ Treat the binary of each digit as base 1 and convert back to a number
         ⍝ Since all numbers are <3, effectively "decrement if ≥2"
 ⊥  ⍝ Treat as base 2 and convert to single number
÷2*⊣  ⍝ Divide by 2^n
  • \$\begingroup\$ @LuisMendo He doesn't; I was just checking that myself, in case it helped me golf more bytes from my answer. (To be specific, 3 f 0.72 is returning 0.68 instead of the correct 0.625 that your answer gives.) \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 11:07
  • \$\begingroup\$ @LuisMendo Ah, so 1∘≠⍛×\ works for the first n-1 base 3 digits; it's only the case of when the nth digit is a 1 that his answer doesn't work. \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 11:15
  • \$\begingroup\$ Thanks for pointing out the error. I think I have a +2 bytes fix; I'll update the post when I get to my PC. \$\endgroup\$
    – Bubbler
    Commented Jul 23, 2020 at 13:13

MATL, 33 bytes


Inputs are n, then x.

Try it online! Or verify all test cases.


The code uses a non-recursive approach, based on the procedure for computing the Cantor function \$f_\infty(x)\$ that appears in Wikipedia, modified so that it computes \$f_n(x)\$ instead:

  1. Multiply \$x\$ by \$3^n\$.
  2. Decompose the result into integer part \$M\$ and decimal part \$F\$.
  3. Express \$M\$ in base \$3\$. Let \$B\$ be the resulting sequence of up to \$n\$ digits from the set \$\{0, 1, 2\}\$.
  4. If \$B\$ contains a \$1\$, replace every digit after the first \$1\$ by \$0\$.
  5. Replace any remaining \$2\$s with \$1\$s.
  6. Interpret the result as a binary number.
  7. If \$B\$ didn't contain \$1\$s, add \$F\$.
  8. Divide by \$2^n\$.

Some golfing tricks

  • Using a for loop instead of an if branch for step 4 saved quite a few bytes. The value for the branch condition (index of first \$1\$) needed to be used within the branch code (to replace subsequent digits by \$0\$). This is cumbersome in MATL, as the if branch consumes (pops) its condition. Instead, the loop solves this more elegantly: since the branch condition was either empty or a vector of indices of \$1\$s in \$B\$, it can be looped over: if it's empty the loop is simply not entered. And then the loop variable can be used within the loop code. The fact that the loop, unlike the conditional branch, may iterate several times (if there are more than one \$1\$ digit) is not harmful here, because the substitutions in step 4 are idempotent: they simply overwrite some of the previous \$0\$s with new \$0\$s.
  • Step 7 is partly handled within the for loop. Specifically, if the loop is entered, the decimal part \$F\$ should not be added later on. To implement this, the loop iteration replaces \$F\$ (previously stored in the stack) by \$0\$. This is done by a round-down operation (k), which is convenient because it uses only 1 byte and is, again, idempotent: the result remains equal to \$0\$ in all iterations after the first.
  • The MATL function that converts from binary to decimal (XB) treats any digit other than \$0\$ as if it were \$1\$, which is useful for steps 5 and 6.

Commented code

3         % Step 1. Push 3
y         % Implicit input: n. Duplicate from below: pushes n below and
          % above the 3
^         % Power: gives 3^n
i*        % Input: x. Multiply: gives x*3^n
1         % Step 2. Push 1
&\        % Two-output modulus: gives modulus (F) and quotient (M)
3_YA      % Step 3. Convert to base 3, with digis 0, 1, 2
t1=       % Step 4 and part of step 7. Duplicate. Compare each entry with 1
f         % Vector (possibly empty) of indices of true values; that is,
          % positions of digit 1
"         % For each index k
  O       %   Push 0
  @Q      %   Push k+1
  Jh(     %   Write 0 at positions k+1, k+2, ..., end
  wkw     %   Swap, round down, swap. This replaces F by 0
]         % End
XB        % Steps 5 and 6. Convert from binary to decimal, with digit 2
          % interpreted as 1
+         % Part of step 7. Add F, or 0
wW/       % Step 8. Swap (brings n to top), 2 raised to that, divide
          % Implicit display
  • \$\begingroup\$ So, much like my second approach, but without the bug... I'd better go back and fix my answer. \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 10:11
  • 1
    \$\begingroup\$ @Neil Nah. Your current 34 byte count is perfect :-P \$\endgroup\$
    – Luis Mendo
    Commented Jul 23, 2020 at 10:16
  • \$\begingroup\$ Sadly it didn't work for x=1. (In a deleted comment, @Bubbler pointed out that @fireflame241 had the same problem with his answer.) \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 10:44
  • \$\begingroup\$ (But the good news is that I can use @Bubbler's adjustment to your method, and this actually saves me 2 bytes overall, which is almost back down to the original byte count.) \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 10:46
  • \$\begingroup\$ Yeah, pity that MATL's base conversion cannot handle non-integer values \$\endgroup\$
    – Luis Mendo
    Commented Jul 23, 2020 at 11:07

APL (Dyalog Unicode), 38 bytes


Try it online!

Combines the cases of the recurrence using

$$ f_{n+1}(x) = \frac{1}{2}\begin{cases} 0+1×f_n(3x-0), x\in[0,1/3) \\ 1+0×f_n(3x-1), x\in[1/3,2/3)\\ 1+1×f_n(3x-2), x\in[2/3,1] \end{cases} $$

which can be condensed (note \$u=3x\$) to

$$ f_{n+1}\left(\frac{1}{3}u\right) = \frac{1}{2}\big( (u<1)+(\lfloor u\rfloor\neq 1)×f_n(u-\lfloor u \rfloor)\big) $$ (since comparisons resolve to True=1 or False=0). This fails for x=1 since then ⌊u is 3 instead of 2. Using ceiling instead of floor would then fail for x=0, so it ends up shorter to check specifically for x=1.

{ ... } ⍺=n; ⍵=x
×⍺×1-⍵: ⍝ If n>0 or x≠1:
 3×⍵      ⍝ Let u=3x
  (⍺-1)∇⊢-⌊ ⍝ f(n-1, u-floor(u)) (`1∘|` ←→ `⊢-⌊`)
  (1≠⌊)×    ⍝ Multiply by 1 unless floor(u)=1
  1∘≤+      ⍝ Add 1 unless 1 > u
 2÷⍨      ⍝ Half of this
⋄       ⍝ Else:
 ⍵        ⍝ x
  • \$\begingroup\$ @Bubbler Fixed. \$\endgroup\$ Commented Jul 22, 2020 at 23:14
  • \$\begingroup\$ Shouldn't u < 1 in your explanation be u ≥ 1? \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 9:55
  • \$\begingroup\$ If n>0 or x≠1 - you mean and? you can avoid x≠1 by replacing ⊢-⌊ with 2|⊢ \$\endgroup\$
    – ngn
    Commented Jul 31, 2020 at 7:00

Python 3, 54 bytes

f=lambda n,x:n and(1<x*3<2or x//.5+f(n-1,3*x%1))/2or x

Try it online!

Python 3 is used just for the /2 to do float division; Python 2 would be a byte longer with /2..


Python 3.8 (pre-release), 62 bytes

f=lambda n,x:n and[f(n-1,e:=3*x),1+e//2*f(n-1,e-2)][e>1]/2or x

Try it online!


Jelly, 30 bytes


A full program accepting \$x\$ and \$n\$ which prints a floating-point representation of \$f_n(x)\$

Try it online!


Wolfram Language (Mathematica), 69 bytes

of course mathematica has a built-in for this: CantorStaircase[x] but you cannot choose n


Try it online!

@JonathanAllan saved 2 bytes

Here is also another approach from @att which is great!

Wolfram Language (Mathematica), 57 bytes


Try it online!

  • \$\begingroup\$ Using a condition of x<2/3 and swapping the branches would save a byte. Can you place 3x in a variable, say y, in five bytes (or less)? If so you can save a byte (or more) by then replacing 1/3 with 1, 2/3 with 2 and the two occurrences of 3x with y. \$\endgroup\$ Commented Jul 22, 2020 at 21:39
  • \$\begingroup\$ 57 bytes \$\endgroup\$
    – att
    Commented Jul 23, 2020 at 0:44

JavaScript (ES6), 45 bytes

Expects (n)(x).


Try it online!


n =>                   // outer function taking n
  g = x =>             // inner recursive function taking x
    n-- ?              // decrement n; if it was not equal to 0:
      (                //   compute f_n(x):
        (x *= 3) < 1 ? //     multiply x by 3; if the result is less than 1:
          g(x)         //       use g(x)
        :              //     else:
          x < 2 ||     //       use 1 if x is less than 2
          1 + g(x - 2) //       otherwise, use 1 + g(x - 2)
      ) / 2            //   in all cases, divide the result by 2
    :                  // else:
      x                //   stop recursion and return f_0(x) = x

C (gcc), 73 \$\cdots\$ 69 68 bytes

float f(n,x)float x;{x*=3;x=n--?(x<1?f(n,x):x<2?:1+f(n,x-2))/2:x/3;}

Try it online!

Saved 4 bytes thanks to the man himself Arnauld!!!
Save a byte thanks to ceilingcat!!!

  • \$\begingroup\$ I was just about to suggest 69 bytes before your edit. \$\endgroup\$
    – Arnauld
    Commented Jul 23, 2020 at 13:23
  • \$\begingroup\$ That's a much better direction to golf in. Was just think how on earth do I factor out the /2 and the x<2, and there you have it: call recursively from two places. Since your golf is based on the original gave you -4 bytes - thanks! :D \$\endgroup\$
    – Noodle9
    Commented Jul 23, 2020 at 13:31
  • \$\begingroup\$ @ceilingcat Nice one - thanks! :D \$\endgroup\$
    – Noodle9
    Commented Mar 15 at 19:59
  • \$\begingroup\$ Although it does increase the size, "?:1+f(n,x-2)" should be written "?1:1+f(n,x-2)" to avoid compilation warning "-Wparenthesis" with gcc 11.4. Putting "1" as middle operand works just fine and it enhances its portability. Any way when left blank the compiler sets that middle operand to "1" i.e. to "true". See "gcc.gnu.org/onlinedocs/gcc/Warning-Options.html" \$\endgroup\$ Commented Apr 5 at 18:43
  • \$\begingroup\$ @ReneGirard Code-golf competitions aren't about portablitity, warnings, standards, best pratice, or anything but size. Size is the only thing that matters. Do not use this code in production or in fact for anything! The only decent thing to do with this code is to burn it and erase all traces of it from your memory! You have been warned. \$\endgroup\$
    – Noodle9
    Commented Apr 6 at 14:53

Python 3.8, 70 74 bytes

1 byte saved thanks to @FryAmTheEggman

f=lambda n,x:n and((1<=(t:=x*3))+f(n-1,t-2*(t>=2))*(t>=2or 1>t))/2or x

Try it online!


Perl 5, 78 bytes

sub f{my$b=pop;my$a=pop;$b--?($a<1/3?f(3*$a,$b):$a<2/3?1:1+f(3*$a-2,$b))/2:$a}

Try it online!

  • \$\begingroup\$ Nice again! You can save a few bytes using my($a,$b)=@_; instead of the pops though! \$\endgroup\$ Commented Jul 23, 2020 at 15:57

R, 76 ... 60 58 bytes

-6 bytes thanks to Robin Ryder, +1 byte to fix bug spotted by Neil, -2 bytes thanks to Giuseppe


Try it online!


    y=3*x                               # define y=3*x
                                        # to save characters later.
    if(n==0){ x }                       # if n==0 just return x
    else {                              # otherwise
         min(                           # whichever is smaller of:
            cantor(y%%2,n-1),           # - call self using y mod 2
                                        #   (this works for the first & last thirds
                                        #   but gives a result >1 for middle third)
            1)                          # - 1 (to fix the middle third)
         +(y>=2)                        # for the top third we need to add 1 to 
                                        # the result of the self call
        /2                              # finally, we divide all above results by 2
  • \$\begingroup\$ 72 bytes by avoiding some ifs. \$\endgroup\$ Commented Jul 23, 2020 at 9:32
  • 1
    \$\begingroup\$ Thanks! I managed to removed some more bytes in the meantime! \$\endgroup\$ Commented Jul 23, 2020 at 9:50
  • \$\begingroup\$ ...but combining this with your approach managed to shave-off another 2! Thanks again! \$\endgroup\$ Commented Jul 23, 2020 at 9:58
  • \$\begingroup\$ floor(y) can be y%/%1 for -3 bytes. \$\endgroup\$ Commented Jul 23, 2020 at 9:59
  • \$\begingroup\$ Super! Thanks again! \$\endgroup\$ Commented Jul 23, 2020 at 10:02

Charcoal, 35 bytes


Try it online! Link is to verbose version of code. Based on the Wikipedia entry, I convert the 3ⁿx to base 3, then massage the digits so that the result can be interpreted as base 2 and divided by 2ⁿ. Takes input in the order n, x. Explanation:


Input n.


Multiply x by 3ⁿ and convert it to base 3. The last entry includes any remaining fractional part.


Map over the digits. If there was a previous 1 then set this digit to zero, otherwise map the digit to itself, 1, or subtract 1, depending on the floor of the digit. This ensures that the last digit (with the remaining fractional part) is converted correctly.


Convert from base 2, divide by 2ⁿ, and output the final decimal as a string.

Previous 34-byte solution did not work for x=1, as it only considered the decimal part of x:


Try it online! Link is to verbose version of code. Takes input in the order n, x. Explanation:


Input n.


Multiply x by 3ⁿ.


Take the decimal part of that.


Loop n times.


Depending on the next base 3 digit of the above product, replace the decimal part with half of itself, half of 1, or half of the sum.


Output the final decimal as a string.


05AB1E, 31 bytes


Takes the loose inputs in the order \$n,x\$.

Port of @LuisMendo's MATL answer, so make sure to upvote him as well!

Try it online or verify all test cases.


3Im              # Push 3 to the power of the first input-integer
   *             # Multiply it by the (implicit) input-decimal
    1‰           # Get the divmod-1 to split the integer and decimal parts
      `s         # Pop and push them separated to the stack in reversed order
3в               # Convert the integer part to base-3 as list
  ¹£             # Only leave the first input-integer amount of base-3 digits
    ε            # Map this list to:
     T           #  Push 10
      Yè         #  Index `Y` into this
                 #  (`Y` is 2 by default, which wraps modulair indices into the 1)
     si          #  If the current digit we're mapping over is 1:
       1V        #   Set `Y` to 1
    ]            # Close both the if-statement and map
     2β          # Convert the resulting list from base-2 to an integer
       Y≠i }     # If `Y` is NOT 1:
          +      #  Add the decimal part that's still on the stack
            ¹o/  # And divide this by 2 to the power the first input-integer
                 # (after which the result is output implicitly)
  • \$\begingroup\$ If I put in 3 0.72 then I get 0.875 which seems wrong; I think it should be 0.625. \$\endgroup\$
    – Neil
    Commented Jul 23, 2020 at 11:11

PARI/GP, 71 bytes

Golfed version. Attempt This Online!


Ungolfed version. Attempt This Online!

f(x, n) = {
  my(y = 3*x);
  if(n == 0, x,
    if(y < 1, f(y, n-1)/2,
      if(y < 2, .5, .5 + f(y-2, n-1)/2)

print(f(0.3, 3));
print(f(0.1, 0));
print(f(0.29, 4));
print(f(0.11, 5));

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.