Corput dizisinin der Van en basit örneği biri düşük fark dizisi . Onun nterimi sadece terimdir 0.(n written in base 10 and mirrored), yani ilk terimleri şunlardır:

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

Meydan okuma

Herhangi bir programlama dilinde bir girdi veya ndaha küçük bir tamsayı alır ve van der Corput dizisinin 10^6ilk nterimlerini döndürür veya yazdırır . Çıktı formatı kayan nokta numaralarının bir listesi, formun dizelerinin bir listesi 0.digitsveya terimlerin virgüllerle ve / veya beyaz boşluklarla, yeni satırlarla ayrıldığı benzersiz bir dize olabilir.

Standart boşluklar yasaktır. En kısa kaynak kodu kazanır.

05AB1E , 6 bayt

Kod:

>GNÞR,

Çevrimiçi deneyin!

Açıklama:

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

CP-1252 kodlamasını kullanır.

Oracle SQL 11.2, 64 62 58 bayt

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

Eski versiyon

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

'' Sayı ile bitiştirmek onu bir dizgeye dönüştürür. TO_CHAR'dan () daha kısa TRIM () kullanmaktan 2 bayt daha kısadır.

Bir dizeyi bir NUMBER ile birleştirmek bir dizgeyle sonuçlandığından, '0' ı yönetmek için o dizeyi kullanmak mümkündür. sonucun bir parçası.

CJam, 14 11 bayt

3 byte tasarruf için Sp3000 sayesinde.

ri{)d`W%S}/

Burada test et.

açıklama

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 bayt

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

Teşekkürler Aleks-Daniel Jakimenko-A. bir başka iki bayt için

eski versiyon

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

EDIT: 2 bayt için teşekkür ederiz.

kullanım

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

Mathematica, 40 bayt

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

Test durumu

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

Pyth, 8 bayt

m_`cd1SQ

Çevrimiçi deneyin.

Bu gerçekten sadece bu ve bu cevabın bir birleşimidir . Bu yüzden bunu topluluk wiki yapıyorum.

Pyth, 11 bayt

m+"0."_`dSQ

Burada dene!

açıklama

m + "0." _ `dSQ # Q = giriş

m SQ # Aralığı (1, Q) ile ...
 + # ... şu şekilde birleşti:
  "0." _ `D #" 0. " ve ters eleman

Pyth - 10 bayt

_M+R".0"SQ

Burada çevrimiçi deneyin .

JavaScript (ES6), 58

Virgülle ayrılmış değerlere sahip bir dize döndüren anonim bir işlev

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

ÖLÇEK

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 bayt

:"'0.'@VPh

Çevrimiçi deneyin!

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

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

Nimi tarafından kaydedilen iki bayt ve Lynn tarafından 7 ek.

Brachylog , 23 bayt

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

Bu girdi olarak bir sayı alır ve sonucu boşlukla ayrılmış STDOUT'a çıkarır.

Yeterince açıksözlü. Maalesef, bu sayıyı bir dizgeye ( :""rc) dönüştürmek için sayıyı boş bir dizeyle birleştirmeliyiz , çünkü henüz bir yerleşik dönüşüm belirtimi yoktur.

Dizeye dönüşüm gereklidir, çünkü sayının rakamlarını tersine çevirirsek, baştaki sıfırlar (örneğin 10olur 01) kaybolur.

PowerShell, 52 bayt

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

İstediğimden biraz daha uzun, ama birkaç güzel numara kullandı.

whileDöngü açıktır, ama şartlı biraz zordur - Elimizdeki $a(olarak başladığı $nullilk başvurulan zaman) ve daha sonra bizim giriş sayısını çıkartıp $args[0]. PowerShell'de, matematik işlemleri $nullonu sıfıra indirir, bu nedenle 20örneğin girdi için bu ortaya çıkar -20. Sıfır olmayan herhangi bir sayı olduğu $true, döngü bağlı olacaktır $truedek ele $aeden giriş numarası (hangi çıkarma eşit olacaktır etmektedir eşit 0ya da $false). Hile sonrası artış gelir ++kadar çalıştırmak etmez, sonra çok girişi taşıma, çıkarma hesaplanır 1irade doğru çıkış 0.1ve daha sonra bir sonraki denemede döngü durur.

Döngüde her zaman, sadece boru hattında kalan ve buna göre çıktı veren bir string değişmezi yaratırız. Bunu , dizgeyi geri almaktan yaratılan karakter dizisine etki "0."eden unary -joinoperatörünün sonucuyla birleştirdik "$a"(aralık üzerinden indeksleyerek "$a".length..0).

Test Çalıştırması

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 bayt

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

Komut satırı argümanı olarak bir sayı alır ve her terimi ayrı bir satıra çıkarır. Örneğin:

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

Uò1 ®+".0" w

Çevrimiçi test edin!

Nasıl çalışır

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

balmumu ,57 53 bayt

Rosettacode için ikili rakam çıktı problemi üzerinde çalışmak, van der Corput dizisi için aynı kısa bölme algoritmasını, sadece 2 yerine 10 ve bölme ve modulo kullanarak kullanabileceğimi fark ettim.

Kodu yansıtarak, 4 byte ile aşağı Golf:

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

Daha kolay yönlendirme için altıgen görüntü:

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

Orijinal kod kullanılarak program boyunca bir çevrimin açıklaması:

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

Örnek:

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 Bayt

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

açıklama

example(strsplit)fonksiyonu yaratır strReverse(sonra açık olmalıdır)

Kullanarak IRanges::reverse, bu 47 bayt golf olabilir

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

Python 3, 47 bayt

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

Python 2 ile daha kısa bir çözüm

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

Test durumu

>>> 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, 12 karakter / 15 bayt

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

Try it here (Firefox only).

Sorun değil.

açıklama

⩤⁽1ï⒨[1,ï]eşlenecek bir aralık oluşturur , ß)mapitem'i (sayı) dizgeye dönüştürür , sonuna Ė⍞.0gizler .0ve ᴙdizgenin tamamını tersine çevirir.

Python 2, 54 Bayt

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

Açıklama:

Set üzerinden Uygulayın [1,input)ve ekler ters iiçin ..

Hala bir daha golf oynadı.

PHP, 45 41 bayt

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

Girdi argümanını CLI'den alır. Bu şekilde koş:

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

• Dizeyi ters çevirmeden birleştirerek 3 bayt kaydedildi

Retina, 39 bayt

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

Tekli girişi alır.

Burada çevrimiçi deneyin.

Gema, 45 karakter

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

Örnek çalışma:

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 bayt

Kodu 12 bayt kısaltmak için farklı bir çıktı formatına gittim. İşlev şimdi bir dizi dizge döndürür. 5 bayt daha kısaltılır. Bana dize enterpolasyonunu hatırlattığı ve adsız bir işlev kullandığı için (2 bayttan daha fazla kurtulmak için) Alex A.'ye teşekkür ederiz .

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

Veya alternatif olarak

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

Ölçek

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 bayt

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

Örnek:

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

Cebirsel çözme:

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

jq 1.5, 40 35 karakter

(34 karakter kod + 1 karakter komut satırı seçeneği.)

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

Örnek çalışma:

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

Çevrimiçi test ( -rURL'den geçmek desteklenmez - Ham Çıktıyı kendiniz kontrol edin.)

Belgelere bağlantı ile aynı:

aralık ( . ) | " \ ( . + 1 ) .0" / "" | geri |add

As a more readable alternative, the above could be also written like this (on-line):

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

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.

Dyalog APL, 12 bytes

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

Try it online!

Straight-forward: the function { string '0.' before , the reversed ⌽ string-representation ⍕ of the argument ⍵ to the function } for each ¨ of the numbers 1 through n ⍳.

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

Output is the array called "o"

Groovy, 36 characters

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

Sample run:

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]