[Question]
  [
The [van der Corput sequence](https://en.wikipedia.org/wiki/Van_der_Corput_sequence) is one of the simplest example of [low-discrepancy sequence](https://en.wikipedia.org/wiki/Low-discrepancy_sequence). Its `n`-th term is just `0.(n written in base 10 and mirrored)`, so its first terms are :
`0.1`, `0.2`,`0.3`,`0.4`, `0.5`,`0.6`,`0.7`, `0.8`,`0.9`,
`0.01`, `0.11`,`0.21`,`0.31`, `0.41`,`0.51`,`0.61`, `0.71`,`0.81`,`0.91`,
`0.02`, `0.12`,`0.22`,`0.32`, `0.42`,`0.52`,`0.62`, `0.72`,`0.82`,`0.92`, ...
# The challenge
Write a program or a function in any programming language that takes as input a positive integer `n` less than `10^6` and returns or print the first `n` terms of the van der Corput sequence. The output format can be a list of floating point numbers, a list of strings of the form `0.digits`, or a unique string where the terms are separated by commas and/or whitespaces, newlines.
[Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden. The shortest source code wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
Code:
```
>GN√ûR,
```
[Try it online!](http://05ab1e.tryitonline.net/#code=PkdOw55SLA&input=MzA)
Explanation:
```
>       # Increment, pushes input + 1
 G      # For N in range(1, input + 1):
  N     # Push N
   √û    # Convert to double, which appends `.0` at the end of an integer
    R   # Reverse top of the stack
     ,  # Pop and print with a newline
```
Uses CP-1252 encoding.
[Answer]
# Oracle SQL 11.2, ~~64~~ ~~62~~ 58 bytes
```
SELECT REVERSE(LEVEL||'.0')FROM DUAL CONNECT BY LEVEL<=:1;
```
Old version
```
SELECT '0.'||REVERSE(TRIM(LEVEL))FROM DUAL CONNECT BY LEVEL<=:1;
```
Concatenating '' to a number casts it to a string. It is 2 bytes shorter than using TRIM(), which is shorter than TO\_CHAR().
Since concatenating a string to a NUMBER results in a string, it is possible to use that string to manage the '0.' part of the result.
[Answer]
## CJam, ~~14~~ 11 bytes
*Thanks to Sp3000 for saving 3 bytes.*
```
ri{)d`W%S}/
```
[Test it here.](http://cjam.aditsu.net/#code=ri%7B)d%60W%25S%7D%2F&input=20)
### Explanation
```
ri     e# Read input and convert to integer N.
{      e# For each i from 0 to N-1...
  )    e#   Increment.
  d    e#   Convert to double.
  `    e#   Get string representation (which ends in ".0").
  W%   e#   Reverse.
  S    e#   Push a space.
}/
```
[Answer]
# Perl 6, ~~24~~ ~~22~~ 20 bytes
```
{"0."X~(^$_)¬ª.flip}
```
Thanks [Aleks-Daniel Jakimenko-A.](https://codegolf.stackexchange.com/users/49921/aleks-daniel-jakimenko-a) for yet another two bytes
**old version**
```
{("0."~.flip for ^$_)}
# Alternate below, same byte count
{map ^$_: "0."~*.flip}
```
EDIT: Thanks raiph for extra 2 bytes
**usage**
```
> my &f = {"0."X~(^$_)¬ª.flip}
-> ;; $_? is raw { #`(Block|333498568) ... }
> f(25)
(0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21 0.31 0.41 0.51 0.61 0.71 0.81 0.91 0.02 0.12 0.22 0.32 0.42)
```
[Answer]
# Mathematica, 40 bytes
```
"0."<>StringReverse@ToString@#&~Array~#&
```
---
**Test case**
```
%[20]
(* {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01,0.11,0.21,0.31,0.41,0.51,0.61,0.71,0.81,0.91,0.02} *)
```
[Answer]
# JavaScript (ES6), 58
An anonymous function returning a string with comma separated values
```
n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``
```
**TEST**
```
f=n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``
function test() { R.textContent = f(+I.value) }
test()
```
```
N:<input id=I type=number value=20 oninput="test()"><br><pre id=R></pre>
```
[Answer]
# Pyth, 8 bytes
```
m_`cd1SQ
```
[Try it online.](http://pyth.herokuapp.com/?code=m_%60cd1SQ&input=20&debug=0)
This is really just a combination of [this](https://codegolf.stackexchange.com/a/71542/30164) and [this](https://codegolf.stackexchange.com/a/71547/30164) answer. Therefore I'm making it a community wiki.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 23 bytes
```
:0re:""rcr:"0."rcw,@Sw\
```
This takes a number as input and outputs the result to STDOUT, separated by spaces.
Fairly straightforward. Unfortunately we have to concatenate the number with an empty string to convert this number to a string (`:""rc`), because there is no built-in conversion predicate yet.
The conversion to string is necessary, because if we reverse the digits of the number, then the leading zeros (e.g. `10` becomes `01`) would be lost.
[Answer]
# Pyth, 11 bytes
```
m+"0."_`dSQ
```
[Try it here!](http://pyth.herokuapp.com/?code=m%2B%220.%22_%60dSQ&input=20&debug=0)
### Explanation
```
m+"0."_`dSQ  # Q = input
m        SQ  # Map the range(1,Q) to...
 +           # ...the concatenation of:
  "0."_`d    # "0." and the reversed element
```
[Answer]
# Pyth - 10 bytes
```
_M+R".0"SQ
```
[Try it online here](http://pyth.herokuapp.com/?code=_M%2BR%22.0%22SQ&input=20&debug=0).
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 10 bytes
```
:"'0.'@VPh
```
[**Try it online!**](http://matl.tryitonline.net/#code=OiInMC4nQFZQaA&input=MjI)
```
:          % implicit input. Generate vector [1,2,...,input]
"          % for each
  '0.'     %   push string '0.'
  @        %   push loop variable (that is, 1,2,3,... in each iteration)
  V        %   convert to string
  P        %   reverse
  h        %   concatenate horizontally
           % implicit end of loop
           % implicit display of all stack contents
          
```
[Answer]
# Haskell, ~~36~~, 27 bytes
```
f n=reverse.show<$>[1.0..n]
```
Two bytes saved by nimi and an additional 7 by Lynn.
[Answer]
## Python 3, ~~47~~ 44 bytes
```
lambda n:[f'{i+1}.0'[::-1]for i in range(n)]
```
a shorter solution with Python 2
```
lambda n:['0.'+`i+1`[::-1]for i in range(n)]
```
Edit: gain 3 bytes using f-string interpolation from python 3.6, now we are even with python 2 solution.
**Test case**
```
>>> f(25)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52']
```
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), ~~[22](https://codegolf.stackexchange.com/revisions/233333/2)~~, 16 bytes
*4 bytes saved by JoKing*
```
IFS" 0."LPWaSDn|
```
[Try it online!](https://tio.run/##S8/PScsszvj/39MtWEnBQE/JJyA8Mdglr@b/fyNLQwA "Gol><> ‚Äì Try It Online")
[Answer]
## PowerShell, 52 bytes
```
while($a++-$args[0]){"0."+-join"$a"["$a".Length..0]}
```
A little longer than I'd like, but uses a couple of neat tricks.
The `while` loop is obvious, but the conditional is a little tricky - we have `$a` (which starts as `$null` when first referenced) and then subtract our input number `$args[0]`. In PowerShell, math operations on `$null` treat it as zero, so for input `20` for example this will result in `-20`. Since any non-zero number is `$true`, the loop conditional will be `$true` right up until `$a` equals our input number (at which point the subtraction will equal `0` or `$false`). The trick comes from the post-increment `++`, which doesn't execute until *after* the subtraction is calculated, so handling input of `1` will correctly output `0.1` and then stop the loop on the next iteration.
Each time in the loop, we just create a string literal which gets left on the pipeline and output accordingly. We construct this from `"0."` concatenated with the result of the unary `-join` operator that has acted on the char-array created from taking the string `"$a"` backwards (by indexing via the range `"$a".length..0`).
### Test Runs
```
PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 1
0.1
PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 20
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
0.51
0.61
0.71
0.81
0.91
0.02
```
[Answer]
# Bash, 36 bytes
```
for i in `seq $1`;do rev<<<$i.0;done
```
Takes a number as a command line argument, and outputs each term on a separate line. For example:
```
$ ./vdc.sh 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
```
[Answer]
# Japt, 12 bytes
```
U√≤1 ¬Æ+".0" w
```
[Test it online!](http://ethproductions.github.io/japt?v=master&code=VfIxIK4rIi4wIiB3&input=MjAw)
### How it works
```
           // Implicit: U = input integer
U√≤1 ¬Æ      // Create the inclusive range [1..U], and map each item Z to:
+".0" w    //  Z + ".0", reversed.
           // Implicit: output last expression
```
[Answer]
# [beeswax](http://esolangs.org/wiki/Beeswax), ~~57~~ 53 bytes
Working on the binary digit output problem for rosettacode I noticed that I could use the same short division algorithm for the van der Corput sequence, just using division and modulo by 10 instead of 2. The output is reversed in both cases.
Golfed down by 4 bytes, by mirroring the code:
```
`.0` XfE@~@L#;
 { %X<#dP@T~P9_
   q<#   N
    >:'bg?b
```
Hexagonal prettyprint, for easier orientation:
```
` . 0 `   X f E @ ~ @ L # ;
 {   % X < # d P @ T ~ P 9 _
    q < #       N
     > : ' b g ? b
```
Explanation of one cycle through the program, using the original code:
```
;#L@~@EfX `0.`
_9P~T@Pb#>X% {
      N   #>p
      d?gd':<
                                                  lstack   gstack
                                _9P              [0,0,10]‚Ä¢         create bee, set top to 10
                                   ~T            [0,10,n]‚Ä¢         flip top and 2nd, enter n
                                     @P          [n,10,1]‚Ä¢         flip top and 3rd, increment top
                                       b                           redirect to upper left
                     [n,10,1]‚Ä¢        E          [n,10,1]‚Ä¢      (2)clone bee in horizontal direction
flip lstack 1st/3rd  [1,10,n]‚Ä¢       @ f         [n,10,1]‚Ä¢  [1]‚Ä¢   push lstack top on gstack       
flip lstack 1st/2nd  [1,n,10]‚Ä¢       ~   X                         clone bee in all directions
flip 1st/3rd         [10,n,1]‚Ä¢      @     `0.`                     print "0." to STDOUT
skip if 1st>2nd      [10,n,1]‚Ä¢     L      >                     (1)redirect 
if 1st<2nd, del. bee              #        X                       clone bee in all directions
(if 1st>2nd, terminate program)  ;          % {  [n,10,1]‚Ä¢         1st=1st%2nd, output lstack 1st to STDOUT
                                            >p                     redirect
                                             <                     redirect
                                            :    [n,10,0]‚Ä¢         1st=1st/2nd
                                           '                       skip next instr. if 1st=0
                                          d                        redirect to upper right, loop back to (1)
                                         g       [n,10,1]   [1]‚Ä¢   push gstack top on lstack 1st
                                       d?                   []‚Ä¢    pop gstack, redirect to upper right
                                       N                           print newline to STDOUT
                                       P         [n,10,2]          increment lstack 1st
                                       E                           looped back to (2)
```
Example:
```
julia> beeswax("vandercorput.bswx",0,0.0,Int(20000))
i300
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
  .
  .
  .
0.492
0.592
0.692
0.792
0.892
0.992
0.003
Program finished!
```
[Answer]
# R, 59 Bytes
```
example(strsplit);cat(strReverse(sprintf('%s.0',1:scan())))
```
*explanation*
`example(strsplit)` creates the function `strReverse` (then it should be obvious)
Using `IRanges::reverse`, this could be golfed to 47 bytes
```
cat(IRanges::reverse(sprintf('%s.0',1:scan())))
```
[Answer]
# ùîºùïäùïÑùïöùïü, 12 chars / 15 bytes
```
‚©§‚ÅΩ1√Ø‚í®√ü)ƒñ‚çû.0·¥ô
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter3.html?eval=true&input=10&code=%E2%A9%A4%E2%81%BD1%C3%AF%E2%92%A8%C3%9F%29%C4%96%E2%8D%9E.0%E1%B4%99)`
It's... okay.
# Explanation
`‚©§‚ÅΩ1√Ø‚í®` creates a range `[1,√Ø]` to map over, `√ü)` converts mapitem (number) to string, `ƒñ‚çû.0` concats `.0` to the end, and `·¥ô` reverses the whole string.
[Answer]
# Python 2, 54 Bytes
```
def f(i):
    for i in range(1,i):print("."+str(i)[::-1])
```
**Explanation:**
Iterate through the set `[1,input)` and appends the reversed `i` to `.`.
*Still an be golfed more.*
[Answer]
# PHP, ~~45~~ 41 bytes
```
for(;$i++<$argv[1];)echo strrev(",$i.0");
```
Takes the input argument from CLI. Run like this:
```
php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100
```
* Saved 3 bytes by concatenating the string before reversing
[Answer]
# Retina, 39 bytes
```
1
1$`0. 
(1)+
$#1
+`(\d)0\.(\d*)
0.$2$1
```
Takes input in unary.
[Try it online here.](http://retina.tryitonline.net/#code=MQoxJGAwLiAKKDEpKwokIzEKK2AoXGQpMFwuKFxkKikKMC4kMiQx&input=MTExMTExMTExMTExMTExMTExMTExMQ)
[Answer]
# Gema, 45 characters
```
*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }
```
Sample run:
```
bash-4.3$ gema '*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }' <<< 12
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21 
```
[Answer]
## APL, 7
```
‚åΩ‚çé‚åΩ1‚çï‚ç≥‚éï
```
Explanation:
```
‚ç≥‚éï    creates a vector of numbers from 1 to user input
1‚çï‚ç≥‚éï  formats these numbers like ##.0
‚åΩ     inverts the whole string
‚åΩ‚çé   transforms back to numbers and inverts order 
```
[Answer]
# [Julia](http://julialang.org), ~~50~~ ~~38~~ ~~33~~ 31 bytes
I went for a different output format to shorten the code by 12 bytes. The function returns an array of strings now.
Shortened by 5 more bytes. Thanks to *Alex A.* for reminding me of string interpolation and using an anonymous function (getting rid of 2 more bytes).
```
n->["0."reverse("$i")for i=1:n]
```
or alternatively
```
n->[reverse("$(i/1)")for i=1:n]
```
Test
```
julia> @time f(10000)
  0.002260 seconds (60.01 k allocations: 2.823 MB)
10000-element Array{ASCIIString,1}:
 "0.1"
 "0.2"
 "0.3"
 "0.4"
 "0.5"
 "0.6"
 "0.7"
 "0.8"
 "0.9"
 "0.01"
 "0.11"
 "0.21"
 "0.31"
 "0.41"
 "0.51"
 "0.61"
 "0.71"
 "0.81"
 "0.91"
 "0.02"
 "0.12"
 "0.22"
 "0.32"
 ‚ãÆ
 "0.8799"
 "0.9799"
 "0.0899"
 "0.1899"
 "0.2899"
 "0.3899"
 "0.4899"
 "0.5899"
 "0.6899"
 "0.7899"
 "0.8899"
 "0.9899"
 "0.0999"
 "0.1999"
 "0.2999"
 "0.3999"
 "0.4999"
 "0.5999"
 "0.6999"
 "0.7999"
 "0.8999"
 "0.9999"
 "0.00001"
```
[Answer]
# Python 2, 40 bytes
```
lambda n:[`i+1.`[::-1]for i in range(n)]
```
Example:
```
>>> f=lambda n:[`i+1.`[::-1]for i in range(n)]
>>> f(30)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52', '0.62', '0.72', '0.82', '0.92', '0.03']
```
Algebraic solving:
```
corput(x) = reversed(str(float(x+1)))
          = reversed(str(x+1.))
          = str(x+1.)[::-1]
          = `x+1.`[::-1]
```
[Answer]
# jq 1.5, ~~40~~ 35 characters
(34 characters code + 1 character command line option.)
```
range(.)|"\(.+1).0"/""|reverse|add
```
Sample run:
```
bash-4.3$ jq -r 'range(.)|"\(.+1).0"/""|reverse|add' <<< 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
```
[On-line test](https://jqplay.org/jq?q=range%28.%29%7C%22%5C%28.%2B1%29.0%22/%22%22%7Creverse%7Cadd&j=12) (Passing `-r` through URL is not supported ‚Äì check Raw Output yourself.)
The same with links to documentation:
```
[range](https://stedolan.github.io/jq/manual/#range%28upto%29,range%28from;upto%29range%28from;upto;by%29)([.](https://stedolan.github.io/jq/manual/#.)) [|](https://stedolan.github.io/jq/manual/#|) "[\(](https://stedolan.github.io/jq/manual/#Stringinterpolation-%5C%28foo%29). [+](https://stedolan.github.io/jq/manual/#Addition-+) 1[)](https://stedolan.github.io/jq/manual/#Stringinterpolation-%5C%28foo%29).0" [/](https://stedolan.github.io/jq/manual/#Multiplication,division,modulo-*,/,and%) "" | [reverse](https://stedolan.github.io/jq/manual/#reverse) | [add](https://stedolan.github.io/jq/manual/#add)
```
As a more readable alternative, the above could be also written like this ([on-line](https://jqplay.org/jq?q=range%28.%29%20|%20.%20%2B%201%20|%20tostring%20|%20.%20%2B%20%22.0%22%20|%20split%28%22%22%29%20|%20reverse%20|%20join%28%22%22%29&j=12)):
```
range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")
```
[Answer]
# Dyalog APL, 6
```
‚åΩ¬®1‚çï¬®‚ç≥
```
This is an anonymous function that takes one argument, i.e.:
```
      ‚åΩ¬®1‚çï¬®‚ç≥ 20
 0.1   0.2   0.3   0.4   0.5   0.6   0.7   0.8   0.9   0.01   0.11   0.21   0.31   0.41   0.51   0.61   0.71   0.81   0.91
         0.02
      f‚Üê‚åΩ¬®1‚çï¬®‚ç≥
      f 20
 0.1   0.2   0.3   0.4   0.5   0.6   0.7   0.8   0.9   0.01   0.11   0.21   0.31   0.41   0.51   0.61   0.71   0.81   0.91
         0.02
```
Explanation:
```
     ‚ç≥    ‚çù get the integers from 1..n
  1‚çï¬®     ‚çù format each with 1 decimal
‚åΩ¬®        ‚çù reverse each string
```
[Answer]
# BBC BASIC, ~~89~~ ~~88~~ 87 bytes
```
0T=1:REP.P."0."FNR(STR$T):T=T+1:U.0
1DEFFNR(S$)IFS$="":=""EL.=FNR(MI.S$,2))+LE.S$,1)
```
Used abbreviations to shorten things as much as possible. Compatible with both Brandy Basic and BASIC 2 on the original machine.
For modern BBC BASICs you could also leave off the line numbers to save two more bytes.
]