Trình tự van der Corput là một trong những ví dụ đơn giản nhất về trình tự sai lệch thấp . nThuật ngữ thứ của nó chỉ là 0.(n written in base 10 and mirrored), vì vậy các điều khoản đầu tiên của nó là:

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, ...

Các thách thức

Viết chương trình hoặc hàm trong bất kỳ ngôn ngữ lập trình nào lấy đầu vào là số nguyên dương nnhỏ hơn 10^6và trả về hoặc in các số hạng đầu tiên ncủa chuỗi van der Corput. Định dạng đầu ra có thể là danh sách các số dấu phẩy động, danh sách các chuỗi của biểu mẫu 0.digitshoặc một chuỗi duy nhất trong đó các thuật ngữ được phân tách bằng dấu phẩy và / hoặc khoảng trắng, dòng mới.

Sơ hở tiêu chuẩn bị cấm. Mã nguồn ngắn nhất sẽ thắng.

05AB1E , 6 byte

Mã số:

>GNÞR,

Hãy thử trực tuyến!

Giải trình:

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

Sử dụng mã hóa CP-1252.

Oracle SQL 11.2, 64 62 58 byte

SELECT REVERSE(LEVEL||'.0')FROM DUAL CONNECT BY LEVEL<=:1;

Phiên bản cũ

SELECT '0.'||REVERSE(TRIM(LEVEL))FROM DUAL CONNECT BY LEVEL<=:1;

Ghép nối '' với một số biến nó thành một chuỗi. Nó ngắn hơn 2 byte so với sử dụng TRIM (), ngắn hơn TO_CHAR ().

Kể từ khi nối một chuỗi thành SỐ kết quả trong một chuỗi, có thể sử dụng chuỗi đó để quản lý '0.' một phần của kết quả.

CJam, 14 11 byte

Cảm ơn Sp3000 đã lưu 3 byte.

ri{)d`W%S}/

Kiểm tra nó ở đây.

Giải trình

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

Perl 6, 24 22 20 byte

{"0."X~(^$_)».flip}

Cảm ơn Aleks-Daniel Jakimenko-A. thêm hai byte nữa

phiên bản cũ

{("0."~.flip for ^$_)}
# Alternate below, same byte count
{map ^$_: "0."~*.flip}

EDIT: Cảm ơn raiph cho thêm 2 byte

sử dụng

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

Toán học, 40 byte

"0."<>StringReverse@ToString@#&~Array~#&

Trường hợp thử nghiệm

%[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} *)

Bình thường, 8 byte

m_`cd1SQ

Hãy thử trực tuyến.

Đây thực sự chỉ là sự kết hợp của điều này và câu trả lời này . Vì vậy, tôi đang biến nó thành một wiki cộng đồng.

Bình thường, 11 byte

m+"0."_`dSQ

Hãy thử nó ở đây!

Giải trình

m + "0." _ `dSQ # Q = đầu vào

m SQ # Ánh xạ phạm vi (1, Q) sang ...
 + # ... sự kết hợp của:
  "0." _ `D #" 0. " và phần tử đảo ngược

Pyth - 10 byte

_M+R".0"SQ

Hãy thử trực tuyến tại đây .

JavaScript (ES6), 58

Hàm ẩn danh trả về một chuỗi có các giá trị được phân tách bằng dấu phẩy

n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``

KIỂM TRA

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>

MATL , 10 byte

:"'0.'@VPh

Hãy thử trực tuyến!

:          % 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

Haskell, 36 , 27 byte

f n=reverse.show<$>[1.0..n]

Hai byte được lưu bởi nimi và thêm 7 bởi Lynn.

Brachylog , 23 byte

:0re:""rcr:"0."rcw,@Sw\

Điều này lấy một số làm đầu vào và xuất kết quả thành STDOUT, cách nhau bởi khoảng trắng.

Khá đơn giản. Thật không may, chúng ta phải nối số với một chuỗi trống để chuyển đổi số này thành một chuỗi (:""rc ) vì chưa có biến vị ngữ chuyển đổi tích hợp nào.

Việc chuyển đổi thành chuỗi là cần thiết, bởi vì nếu chúng ta đảo ngược các chữ số của số, thì các số 0 đứng đầu (ví dụ 10trở thành 01) sẽ bị mất.

PowerShell, 52 byte

while($a++-$args[0]){"0."+-join"$a"["$a".Length..0]}

Lâu hơn một chút so với tôi muốn, nhưng sử dụng một vài thủ thuật gọn gàng.

Các whilevòng lặp là hiển nhiên, nhưng có điều kiện là một chút khó khăn - chúng tôi có $a(mà bắt đầu như $nullkhi lần đầu tiên tham chiếu) và sau đó trừ đi số đầu vào của chúng tôi $args[0]. Trong PowerShell, các phép toán trên $nullcoi nó là 0, vì vậy, 20ví dụ, điều này sẽ dẫn đến kết quả -20. Vì bất kỳ số nào khác không $true, nên điều kiện vòng lặp sẽ $trueđúng cho đến khi $abằng số đầu vào của chúng tôi (tại thời điểm đó phép trừ sẽ bằng 0hoặc $false). Thủ thuật xuất phát từ gia tăng sau ++, không thực hiện cho đến khi tính toán trừ, do đó, việc xử lý đầu vào 1sẽ xuất chính xác0.1 và sau đó dừng vòng lặp trên lần lặp tiếp theo.

Mỗi lần trong vòng lặp, chúng ta chỉ cần tạo một chuỗi ký tự được để lại trên đường ống và đầu ra tương ứng. Chúng tôi xây dựng điều này từ "0."nối với kết quả của toán tử đơn nguyên -joinđã hành động trên mảng char được tạo từ việc lấy chuỗi "$a"ngược (bằng cách lập chỉ mục qua phạm vi "$a".length..0).

Chạy thử

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

Bash, 36 byte

for i in `seq $1`;do rev<<<$i.0;done

Lấy một số làm đối số dòng lệnh và xuất ra mỗi thuật ngữ trên một dòng riêng biệt. Ví dụ:

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

Japt, 12 byte

Uò1 ®+".0" w

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

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

sáp ong ,57 53 byte

Làm việc với bài toán đầu ra chữ số nhị phân cho rosettacode Tôi nhận thấy rằng tôi có thể sử dụng cùng một thuật toán chia ngắn cho chuỗi van der Corput, chỉ sử dụng phép chia và modulo bằng 10 thay vì 2. Đầu ra bị đảo ngược trong cả hai trường hợp.

Đánh xuống 4 byte, bằng cách phản chiếu mã:

`.0` XfE@~@L#;
 { %X<#dP@T~P9_
   q<#   N
    >:'bg?b

Hình lục giác đẹp, để định hướng dễ dàng hơn:

` . 0 `   X f E @ ~ @ L # ;
 {   % X < # d P @ T ~ P 9 _
    q < #       N
     > : ' b g ? b

Giải thích về một chu kỳ thông qua chương trình, sử dụng mã gốc:

;#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)

Thí dụ:

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!

R, 59 byte

example(strsplit);cat(strReverse(sprintf('%s.0',1:scan())))

giải trình

example(strsplit)tạo hàm strReverse(thì nó phải rõ ràng)

Sử dụng IRanges::reverse, điều này có thể được đánh gôn đến 47 byte

cat(IRanges::reverse(sprintf('%s.0',1:scan())))

Python 3, 47 byte

lambda n:['0.'+str(i+1)[::-1]for i in range(n)]

một giải pháp ngắn hơn với Python 2

lambda n:['0.'+`i+1`[::-1]for i in range(n)]

Trường hợp thử nghiệm

>>> 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']

, 12 ký tự / 15 byte

⩤⁽1ï⒨ß)Ė⍞.0ᴙ

Try it here (Firefox only).

Không sao đâu.

Giải trình

⩤⁽1ï⒨tạo một phạm vi [1,ï]để ánh xạ, ß)chuyển đổi mapitem (số) thành chuỗi, Ė⍞.0concats .0đến cuối và ᴙđảo ngược toàn bộ chuỗi.

Python 2, 54 byte

def f(i):
    for i in range(1,i):print("."+str(i)[::-1])

Giải trình:

Lặp lại thông qua các tập hợp [1,input)và nối các đảo ngược ivào ..

Vẫn là một sân golf nhiều hơn.

PHP, 45 41 byte

for(;$i++<$argv[1];)echo strrev(",$i.0");

Lấy đối số đầu vào từ CLI. Chạy như thế này:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100

• Đã lưu 3 byte bằng cách nối chuỗi trước khi đảo ngược

Võng mạc, 39 byte

1
1$`0. 
(1)+
$#1
+`(\d)0\.(\d*)
0.$2$1

Đưa đầu vào trong unary.

Hãy thử trực tuyến tại đây.

Gema, 45 ký tự

*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }

Chạy mẫu:

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 

Julia ,50 38 33 31 byte

Tôi đã đi đến một định dạng đầu ra khác nhau để rút ngắn mã thêm 12 byte. Hàm trả về một chuỗi các chuỗi bây giờ. Rút ngắn thêm 5 byte. Cảm ơn Alex A. đã nhắc nhở tôi về phép nội suy chuỗi và sử dụng hàm ẩn danh (loại bỏ thêm 2 byte).

n->["0."reverse("$i")for i=1:n]

Hay cách khác

n->[reverse("$(i/1)")for i=1:n]

Kiểm tra

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"

Python 2, 40 byte

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

Thí dụ:

>>> 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']

Giải đại số:

corput(x) = reversed(str(float(x+1)))
          = reversed(str(x+1.))
          = str(x+1.)[::-1]
          = `x+1.`[::-1]

jq 1.5, 40 35 ký tự

(Mã 34 ký tự + 1 ký tự tùy chọn dòng lệnh.)

range(.)|"\(.+1).0"/""|reverse|add

Chạy mẫu:

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

Bài kiểm tra trực tuyến (Chuyển -rqua URL không được hỗ trợ - hãy tự kiểm tra Đầu ra thô.)

Tương tự với các liên kết đến tài liệu:

phạm vi ( . ) | " \ ( . + 1 ) .0" / "" | đảo ngược |thêm vào

Là một thay thế dễ đọc hơn, ở trên cũng có thể được viết như thế này ( trực tuyến ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")

BBC BASIC, 89 88 87 byte

0T=1:REP.P."0."FNR(STR$T):T=T+1:U.0
1DEFFNR(S$)IFS$="":=""EL.=FNR(MI.S$,2))+LE.S$,1)

Sử dụng chữ viết tắt để rút ngắn mọi thứ càng nhiều càng tốt. Tương thích với cả Brandy Basic và BASIC 2 trên máy gốc.

Đối với BBC BASIC hiện đại, bạn cũng có thể bỏ các số dòng để lưu thêm hai byte.

APL Dyalog , 12 byte

{'0.',⌽⍕⍵}¨⍳

Hãy thử trực tuyến!

Chuyển tiếp thẳng: {chuỗi hàm '0.'trước biểu diễn chuỗi ,đảo ngược của đối số cho hàm cho mỗi số từ 1 đến n .⌽⍕⍵}¨ ⍳

Mã số 66

T=101; // set T to the number of iterations wanted
for(o=[],i=0;i<T;i++)o[i]="0."+(""+i).split("").reverse().join("") // 66b

Đầu ra là mảng được gọi là "o"

Groovy, 36 ký tự

{(1..it).collect{"$it.0".reverse()}}

Chạy mẫu:

groovy:000> ({(1..it).collect{"$it.0".reverse()}})(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]