Golf a transcendental number

Question

Definitions

• An algebraic number is a number that is a zero of a non-zero polynomial with integer coefficients. For example, the square root of 2 is algebraic, because it is a zero of x^2 - 2.
• A transcendental number is a real number which is not algebraic.

Task

You are to choose a transcendental number.

Then, write a program/function that takes a positive integer n and output the n-th decimal digit after the decimal point of your chosen transcendental number. You must state clearly in your submission, which transcendental number is used.

You can use 0-indexing or 1-indexing.

Example

e^2=7.389056098... is a transcendental number. For this number:

n output
1 3
2 8
3 9
4 0
5 5
6 6
7 0
8 9
9 8
...

Note that the initial 7 is ignored.

As I mentioned above, you can choose other transcendental numbers.

Scoring

This is code-golf. Lowest score in bytes wins.

Answer 1

Python, 3 bytes

min

Try it online!

Takes a number string, outputs its smallest digit as a smallest character. For example, 254 gives 2. The decimal with these digits starts

0.0123456789011111111101222222220123333333012344444401234555550123456666012345678801234567

This is OEIS A054054.

Claim: This number c is transcendental

Proof: Note that c is very sparse: almost all of its digits are zero. That's because large n, there's high probability n has a zero digit, giving a digit min of zero. Moreover, c has long runs of consecutive zeroes. We use an existing result that states this means c is transcendental.

Following this math.SE question, let Z(k) represent the position of the k'th nonzero digit of c, and let c_k be that nonzero digit, a whole number between 1 and 9. Then, we express the decimal expansion of c, but only taking the nonzero digits, as as the sum over k=1,2,3,... of c_k/10^Z(k).

We use the result of point 4 of this answer by George Lowther: that c is transcendental if there are infinitely many runs of zeroes that are at least a constant fraction of the number of digits so far. Formally, there must be an ε>0 so that Z(k+1)/Z(k) > 1+ε for infinitely many k. We'll use ε=1/9

For any number of digits d, take k with Z(k) = 99...99 with d nines. Such a k exists because this digit in c is a 9, and so nonzero. Counting up from 99...99, these numbers all contain a zero digit, so it marks the start of a long run of zeroes in c. The next nonzero digit isn't until Z(k+1) = 1111...11 with d+1 ones. The ratio Z(k+1)/Z(k) slightly exceeds 1+1/9.

This satisfies the condition for every d, implying the result.

Answer 2

Pyth, 1 byte

h

Input and output are strings. The function takes the first digit of the index. The resulting transcendental number looks like:

0.0123456789111111111122222222223 ...

This is transcendental because it is 1/9 plus a number which has stretches of zeroes of length at least a constant fraction of the number. Based on this math.stackexchange answer, that means that the number is transcendental.

There are stretches of zeroes are from digit 100 ... 000 to 199 ... 999, so ratio of Z(k+1) to Z(k) is 2 infinitely often.

Thus, the above number minus 1/9 is transcendental, and so the above number is transcendental.

Answer 3

Python 2, 19 bytes

lambda n:1>>(n&~-n)

The n^th digit is 1 if n is a power of 2 and 0 otherwise.

Try it online!

Answer 4

brainfuck, 2 bytes

,.

Similarly to some other answers, returns the first decimal digit and ignores the rest.

Answer 5

Jelly, 3 bytes

e!€

Uses Liouville's constant.

Try it online!

Answer 6

Retina, 4 bytes

1!`.

Returns the first digit of the input number. Because that port was so boring, here are some more ports:

O`.
1!`.

(8 bytes) Returns the minimum digit of the input number.

.+
$*
+`^(11)+$
$#1$*
^1$

(25 bytes) Returns 1 if the input number is a power of 2.

.+
$*_

$.`
+1`.(\d*)_
$1
1!`.

(30 bytes) Champernowne's constant.

Answer 7

Brachylog 2, 7 bytes

⟦₁c;?∋₎

Try it online!

Calculates digits of the Champernowne constant (possibly times a power of ten due to indexing issues, which clearly don't matter here). Basically, this just concatenates together integers, and then takes the nth digit.

Answer 8

Python 2, 13 bytes

Input and output are strings.

lambda n:n[0]

The number's nth digit is the most significant digit of n when it is written in decimal.

Answer 9

MATL, 7 bytes

4YA50<A

This uses the first of the two numbers given here divided by 3 (which maintains transcendence):

1.100110000000000110011...

Input is 1-based. Try it online! Or see the first 20 decimals.

Explanation

4YA     % Convert to base 4 using chars '0', '1', '2', '3' as digits
50<A    % Are all digits less than '2'? Gives 0 (false) or 1 (true) 

Answer 10

JavaScript, 51 bytes

This function computes nth digit of Champernowne's Constant. Add f= at the beginning and invoke like f(arg). Note that n is 1-indexed.

n=>[..."1".repeat(n)].map((c,i)=>c*++i).join``[n-1]

Explanation

This function takes in a single argument n. It, then, creates an n-characters long String of repetitive 1s. Then, it splits that String into an Array of 1s . After that, it iterates over every element of the Array and multiplies them with their index in the Array incremented by 1. Then, it joins the Array together over "" (empty String) to form a String. At last, it returns the nth element of the obtained String.

Note: The type of the returned value is always String.

Test Snippet

let f =

n=>[..."1".repeat(n)].map((c,i)=>c*++i).join``[n-1]

i.oninput = e => o.innerHTML = f(parseInt(e.target.value,10));

<input id=i><pre id=o></pre>

Answer 11

Python 2, 43 bytes

Champernowne's constant.

lambda n:"".join(`i`for i in range(n+1))[n]

Answer 12

APL (Dyalog), 3 bytes

2|⍴

Try it online! (the test suite generates a range of numbers from 1 to 10000, converts them to a string, and then applies the train 2|⍴ on them).

Takes the input number as a string and returns its length mod 2. So 123 => 3 mod 2 => 1.

The sequence starts off like so:

1  1  1  1  1  1  1  1  1  0  0  0  0  0  0  ...

so this can be generalised like so: 9 1s 90 0s 900 1s ...

Multiplying this number by 9 gives us a Liouville number, which is proven to be transcendental.

Answer 13

Haskell, 25 bytes 17 bytes

(!!)$concat$map show[1..]

Champernowne's Constant can be 0 or 1 indexed as C10*.01 is still transcendental.

Edit: as per nimis comment you can use the list monad to reduce this to

(!!)$show=<<[1..]

Answer 14

JavaScript, 73 bytes

This is a program which computes the nth digit of the Liouville Constant, where n is the input number given by invoking the function g as g(arg) (and n is 1-indexed). Note that the newline in the code is necessary.

f=n=>n<1?1:n*f(n-1);g=(n,r=0)=>{for(i=0;i<=n;i++)if(f(i)==n)r=1
return r}

Explanation

The program consists of two functions, f and g. f is a recursive factorial-computing function, and g is the main function of the program. g assumes to have a single argument n. It defines a default argument r with a value of 0. It, then, iterates over all the Integers from 0 to n, and, in each iteration, checks whether the function f applied over i (the current index) equals n, i.e. whether n is a factorial of i. If that happens to be the case, r's value is set to 1. At the end of the function, r is returned.

Snippet for Testing

f=n=>n<1?1:n*f(n-1);g=(n,r=0)=>{for(i=0;i<=n;i++)if(f(i)==n)r=1
return r}

i.oninput = e => o.innerHTML = g(parseInt(e.target.value,10))

<input id=i><pre id=o></pre>

Warning: Don't put a very large value in the Snippet's input box! Otherwise, your device may freeze!

Answer 15

Jelly, 1 byte

Ḣ

Try it online!

1st digit of quoted 0-indexed input.¹

^{1See isaacg's answer for proof of validity.}

Answer 16

Japt, 3 1+1= 2 1 byte

Another port of feersum's solution.

Takes input as a string.

g

Try it online

---

Explanation

   :Implicit input of string U
g  :The first character of the string

Answer 17

Pyth, 7 5 4 bytes

@jkS

Try it online!

Uses Champernowne's constant.

Saved 2 3 bytes thanks to Leaky Nun.

Answer 18

Java 8, 18 bytes

Same as Dennis' answer for Python 2, the Fredholm number

n->(n&(n-1))>0?0:1

Answer 19

Charcoal, 24 bytes (noncompeting)

ＮαＡＩＵＶN⟦ＵＧPi⁺α¹⟧β§β⁺α›α⁰

Try it online!

Note: As of post time, does not work for n where n is a positive multiple of 14.

Explanation

Ｎα                             Input number to a
   Ａ                  β        Assign to b
     Ｉ                         Cast
       ＵＶN                    Evaluate variable N
            ⟦ＵＧPi⁺α¹⟧         With arguments GetVariable(Pi) and a+1
                        §β⁺α›α⁰ Print b[a+(a>0)]

Answer 20

05AB1E, 3 1 byte

EDIT: Using the proof from the other answers, returns the first digit of input

¬

1-indexed for π (only up to 100000 digits)

žs¤

How it works

žs  # Implicit input. Gets n digits of pi (including 3 before decimal)
  ¤ # Get last digit

Or, if you prefer e (still 1-indexed) (only up to 10000 digits)

žt¤

Try it online!

Answer 21

TI-BASIC, 16 bytes

Basically tests if the input N (1-indexed) is a triangular number. This is the same as returning the Nth digit of 0.1010010001…, which is proven to be transcendental. The sequence of digits is OEIS A010054.

Input N
int(√(2N
2N=Ans(Ans+1

Answer 22

Duocentehexaquinquagesimal, 1 byte

Ties isaacg's Pyth answer, Erik the Outgolfer's Jelly answer, Neil A.'s 05AB1E answer, and Shaggy's Japt answer for #1.

.

Try it online!

Answer 23

Pyt, 5 bytes

Đř!∈Ɩ

Try it online!

Liouville Constant

Đ           implicit input (n); duplicate
 ř!         get [1!,2!,...,n!]
   ∈        is n in that list?
    Ɩ       coerce to integer; implicit print

Answer 24

Regex (ECMAScript), 13 bytes

((xx|)x*)\1+$

Try it online!

Takes its input in unary, as a string of x characters whose length represents the number. The output is returned as the length of capture group \2.

Returns the \$n\$th digit of \$0.00020202220202220202220222220202222202220202220222220...\$, where the \$n\$th digit is \$2\$ if \$n\$ is a composite number, and \$0\$ otherwise.

           # tail = N = input number
((xx|)x*)  # \1 = the largest proper divisor of N;
           # \2 = 2 if \1 >= 2, or 0 otherwise;
           # tail -= \1
\1+$       # Assert that \1 divides tail

If the return value of \2 is defined to be \$0\$ when it is unset, then this can be reduced to 12 bytes, with \$0.00010101110101110101110111110101111101110101110111110...\$ as the transcendental number:

(x?(x)*)\1+$

Try it online!

Regex (ECMAScript), 14 bytes

((x*)(?=\2)x)*

Try it online!

The output of this one is also returned as the length of capture group \2.

Returns the \$n\$th digit of \$0.01001100001111000000001111111100000000000000001...\$ (with 1-indexing). The \$n\$th digit of this transcendental number is the 2nd digit of the binary expansion of \$n+1\$, OEIS A079944.

                # tail = N = input number
(
    (x*)(?=\2)  # \2 = floor(tail / 2); tail -= \2
    x           # tail -= 1
)*              # Iterate the above as many times as possible

Answer 25

Fourier, 16 bytes

I~NL~S10PS~XN/Xo

Try it online!

As other answers have done, outputs the first digit of the input.

An explanation of the code:

N = User Input
S = log(N)
X = 10 ^ S
Print (N/X)

Answer 26

JavaScript (ES6)

Just a few ports of some other solutions

---

feersum's Python solution, 12 bytes

n=>(""+n)[0]

f=
n=>(""+n)[0]
o.innerText=f(i.value=1)
i.oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

---

Dennis' Python solution, 13 bytes

n=>1>>(n&--n)

f=
n=>1>>(n&--n)
o.innerText=f(i.value=1)
i.oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

---

xnor's Python solution, 20 bytes

n=>Math.min(...""+n)

Answer 27

Brain-Flak, 6 + 3 ( -c) = 9 bytes

({}<>)

Try it online!

1st digit of 0-index string input (hence the -c flag).

Answer 28

C#, 13 bytes

n=>(n+"")[0];

From feersum's solution. Almost same solution than the js port.

Try it online

Answer 29

J, 2 Bytes

The same solution everyone else is using:

{.

Returns the first digit of n. IO is on strings

Liouville's Constant, 9 Bytes

(=<.)!inv

Returns 1 if input is the factorial of an integer.

Pi, 13 Bytes

{:":<[email protected]^

The last non-decimal digit of pi times 10^n.

Answer 30

Jelly, 2 bytes

LḂ

Try it online!

Take the length of the input number modulo 2. Equivalent to this APL answer.