Die van der Corput-Sequenz ist eines der einfachsten Beispiele für Sequenzen mit geringer Diskrepanz . Sein n-ter Ausdruck ist gerecht 0.(n written in base 10 and mirrored), daher lauten seine ersten Ausdrücke:

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

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion in einer beliebigen Programmiersprache, die eine positive ganze Zahl nkleiner als 10^6eingibt und die ersten nTerme der van der Corput-Sequenz zurückgibt oder ausgibt. Das Ausgabeformat kann eine Liste von Gleitkommazahlen, eine Liste von Zeichenfolgen des Formulars 0.digitsoder eine eindeutige Zeichenfolge sein, bei der die Begriffe durch Kommas und / oder Leerzeichen und Zeilenumbrüche getrennt sind.

Standardlücken sind verboten. Der kürzeste Quellcode gewinnt.

05AB1E , 6 Bytes

Code:

>GNÞR,

Probieren Sie es online!

Erläuterung:

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

Verwendet die CP-1252-Codierung.

Oracle SQL 11.2, 64 62 58 Bytes

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

Alte Version

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

Durch Verketten von '' mit einer Zahl wird eine Zeichenfolge erstellt. Es ist 2 Bytes kürzer als TRIM (), was kürzer ist als TO_CHAR ().

Da das Verknüpfen einer Zeichenfolge mit einer NUMMER zu einer Zeichenfolge führt, kann diese Zeichenfolge zum Verwalten der '0' verwendet werden. Teil des Ergebnisses.

CJam, 14 11 Bytes

Danke an Sp3000 für das Speichern von 3 Bytes.

ri{)d`W%S}/

Teste es hier.

Erläuterung

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 Bytes

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

Vielen Dank, Aleks-Daniel Jakimenko-A. für noch zwei Bytes

alte Version

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

EDIT: Danke raiph für zusätzliche 2 Bytes

Verwendung

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

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

Testfall

%[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 Bytes

m_`cd1SQ

Probieren Sie es online aus.

Dies ist wirklich nur eine Kombination aus dieser und dieser Antwort. Deshalb mache ich daraus ein Community-Wiki.

Pyth, 11 Bytes

m+"0."_`dSQ

Probieren Sie es hier aus!

Erläuterung

m + "0". _ `dSQ # Q = Eingabe

m SQ # Ordnen Sie den Bereich (1, Q) ...
 + # ... die Verkettung von:
  0. _ `D # 0. und das umgekehrte Element

Pyth - 10 Bytes

_M+R".0"SQ

Probieren Sie es hier online aus .

JavaScript (ES6), 58

Eine anonyme Funktion, die eine Zeichenfolge mit durch Kommas getrennten Werten zurückgibt

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

PRÜFUNG

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 Bytes

:"'0.'@VPh

Probieren Sie es online!

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

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

Zwei Bytes von nimi und weitere 7 von Lynn.

Brachylog , 23 Bytes

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

Dies nimmt eine Zahl als Eingabe und gibt das Ergebnis an STDOUT aus, getrennt durch Leerzeichen.

Ziemliech direkt. Leider müssen wir die Zahl mit einer leeren Zeichenfolge verketten, um diese Zahl in eine Zeichenfolge ( :""rc) zu konvertieren , da es noch kein eingebautes Konvertierungsprädikat gibt.

Die Konvertierung in einen String ist notwendig, denn wenn wir die Ziffern der Zahl umkehren, gehen die führenden Nullen (zB 10werden 01) verloren.

PowerShell, 52 Byte

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

Ein bisschen länger als ich es gerne hätte, benutzt aber ein paar nette Tricks.

Die whileSchleife ist offensichtlich, aber die Bedingung ist ein wenig knifflig - wir haben $a(die beginnt als $nullwenn zuerst verwiesen wird) und subtrahieren dann unsere Eingabenummer $args[0]. In PowerShell wird es bei mathematischen Operationen $nullals Null behandelt, sodass dies beispielsweise bei der Eingabe 20zur Folge hat -20. Da jede Zahl ungleich Null ist $true, bleibt die Schleifenbedingung $truebis zu $aunserer eingegebenen Zahl bestehen (an diesem Punkt ist die Subtraktion gleich 0oder $false). Der Trick kommt vom Nachinkrement ++, das erst ausgeführt wird, nachdem die Subtraktion berechnet wurde. Die Eingabe von 1wird also korrekt ausgegeben 0.1und die Schleife bei der nächsten Iteration gestoppt.

Jedes Mal in der Schleife erstellen wir einfach ein String-Literal, das in der Pipeline verbleibt und entsprechend ausgegeben wird. Wir konstruieren dies aus der "0."Verkettung mit dem Ergebnis des unären -joinOperators, der auf das Zeichen-Array reagiert hat, das durch Rücknahme des Strings "$a"(durch Indizieren über den Bereich "$a".length..0) erstellt wurde.

Testläufe

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 Bytes

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

Nimmt eine Zahl als Befehlszeilenargument und gibt jeden Begriff in einer separaten Zeile aus. Beispielsweise:

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

Uò1 ®+".0" w

Online testen!

Wie es funktioniert

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

Bienenwachs ,57 53 Bytes

Als ich an dem Problem der Binärziffernausgabe für Rosettacode arbeitete, bemerkte ich, dass ich für die Van-der-Corput-Sequenz denselben Algorithmus für die Kurzdivision verwenden konnte, indem ich nur Division und Modulo durch 10 anstelle von 2 verwendete. Die Ausgabe ist in beiden Fällen umgekehrt.

4 Bytes weniger, indem der Code gespiegelt wird:

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

Sechseckiger Prettyprint zur leichteren Orientierung:

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

Erläuterung eines Zyklus durch das Programm unter Verwendung des Originalcodes:

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

Beispiel:

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 Bytes

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

Erläuterung

example(strsplit)schafft die Funktion strReverse(dann sollte es selbstverständlich sein)

Mit IRanges::reversekönnte dies auf 47 Bytes golfen werden

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

Python 3, 47 Bytes

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

eine kürzere Lösung mit Python 2

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

Testfall

>>> 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 Zeichen / 15 Byte

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

Try it here (Firefox only).

Es ist in Ordnung.

Erläuterung

⩤⁽1ï⒨Erstellt einen Bereich [1,ï]für die Zuordnung, ß)konvertiert Mapitem (Zahl) in Zeichenfolge, Ė⍞.0setzt sich .0bis zum Ende zusammen und ᴙkehrt die gesamte Zeichenfolge um.

Python 2, 54 Bytes

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

Erläuterung:

Iteriere durch den Satz [1,input)und hänge das Umgekehrte ian ..

Immer noch mehr golfen.

PHP, 45 41 Bytes

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

Übernimmt das Eingabeargument von CLI. Laufen Sie wie folgt:

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

• Durch Verketten der Zeichenfolge vor dem Umkehren wurden 3 Byte gespeichert

Retina, 39 Bytes

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

Nimmt unäre Eingaben auf.

Probieren Sie es hier online aus.

Gema, 45 Zeichen

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

Probelauf:

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 Bytes

Ich habe ein anderes Ausgabeformat gewählt, um den Code um 12 Byte zu verkürzen. Die Funktion gibt jetzt ein Array von Strings zurück. Verkürzt um 5 weitere Bytes. Vielen Dank an Alex A. , der mich an die Interpolation von Strings erinnert hat und eine anonyme Funktion verwendet hat (2 weitere Bytes wurden entfernt).

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

oder alternativ

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

Prüfung

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 Bytes

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

Beispiel:

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

Algebraisches Lösen:

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

jq 1,5, 40 35 Zeichen

(34 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

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

Probelauf:

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

Online-Test (Die Weitergabe -rüber eine URL wird nicht unterstützt. Prüfen Sie die Raw-Ausgabe selbst.)

Das gleiche mit Links zur Dokumentation:

Bereich ( . ) | " \ ( . + 1 ) .0" / "" | umkehren | hinzufügen

Als lesbarere Alternative könnte das oben Genannte auch so geschrieben werden ( online ):

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)

Verwendete Abkürzungen, um die Dinge so weit wie möglich zu verkürzen. Kompatibel mit Brandy Basic und BASIC 2 auf der Originalmaschine.

Bei modernen BBC-BASICs können Sie auch die Zeilennummern weglassen, um zwei weitere Bytes zu sparen.

Dyalog APL , 12 Bytes

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

Probieren Sie es online!

Straight-Forward: Die Funktion {Zeichenfolge '0.'vor ,dem reversed ⌽strang Darstellung ⍕des Arguments ⍵an die Funktion }für jede ¨der Zahlen 1 bis 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

Ausgabe ist das Array mit dem Namen "o"

Groovy, 36 Zeichen

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

Probelauf:

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]