Sekwencja van der Corputa jest jednym z najprostszych przykładów sekwencji o niskiej rozbieżności . Jego n-ty termin jest po prostu 0.(n written in base 10 and mirrored), więc jego pierwsze terminy to:

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

Wyzwanie

Napisz program lub funkcję w dowolnym języku programowania, który przyjmuje jako liczbę dodatnią liczbę całkowitą nmniejszą niż 10^6i zwraca lub drukuje pierwsze nwarunki sekwencji van der Corputa. Format wyjściowy może być listą liczb zmiennoprzecinkowych, listą ciągów formularza 0.digitslub unikatowym ciągiem, w którym terminy są oddzielone przecinkami i / lub spacjami, znakami nowej linii.

Standardowe luki są zabronione. Najkrótszy kod źródłowy wygrywa.

05AB1E , 6 bajtów

Kod:

>GNÞR,

Wypróbuj online!

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252.

Oracle SQL 11.2, 64 62 58 bajtów

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

Stara wersja

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

Łączenie „” z liczbą powoduje rzut na ciąg. Jest o 2 bajty krótszy niż przy użyciu TRIM (), który jest krótszy niż TO_CHAR ().

Ponieważ łączenie łańcucha z NUMBER powoduje utworzenie łańcucha, można go używać do zarządzania „0”. część wyniku.

CJam, 14 11 bajtów

Dzięki Sp3000 za oszczędność 3 bajtów.

ri{)d`W%S}/

Sprawdź to tutaj.

Wyjaśnienie

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 bajtów

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

Dzięki Aleks-Daniel Jakimenko-A. jeszcze dwa bajty

stara wersja

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

EDYCJA: Dzięki raiph za dodatkowe 2 bajty

stosowanie

> 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 bajtów

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

Przypadek testowy

%[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 bajtów

m_`cd1SQ

Wypróbuj online.

To naprawdę tylko połączenie tego i tej odpowiedzi. Dlatego robię z niej wiki społeczności.

Pyth, 11 bajtów

m+"0."_`dSQ

Wypróbuj tutaj!

Wyjaśnienie

m + „0.” _ `dSQ # Q = wejście

m SQ # Odwzoruj zakres (1, Q) na ...
 + # ... konkatenacja:
  „0.” _ `D #" 0. ” i element odwrócony

Pyth - 10 bajtów

_M+R".0"SQ

Wypróbuj online tutaj .

JavaScript (ES6), 58

Anonimowa funkcja zwracająca ciąg znaków z wartościami oddzielonymi przecinkami

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>

MATL , 10 bajtów

:"'0.'@VPh

Wypróbuj 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 bajtów

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

Dwa bajty zapisane przez nich i dodatkowe 7 przez Lynn.

Brachylog , 23 bajty

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

Pobiera to liczbę jako dane wejściowe i wyprowadza wynik do STDOUT, oddzielone spacjami.

Dość bezpośredni. Niestety musimy połączyć liczbę z pustym ciągiem, aby przekonwertować ten numer na ciąg ( :""rc), ponieważ nie ma jeszcze wbudowanego predykatu konwersji.

Konwersja na ciąg jest konieczna, ponieważ jeśli odwrócimy cyfry liczby, wówczas wiodące zera (np. 10Stają się 01) zostaną utracone.

PowerShell, 52 bajty

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

Trochę dłużej, niż chciałbym, ale używa kilku schludnych sztuczek.

whilePętla jest oczywista, ale uwarunkowane jest trochę trudne - mamy $a(która rozpoczyna się $nullprzy pierwszym odwoływać), a następnie odjąć nasz numer wejściowy $args[0]. W PowerShell operacje matematyczne $nulltraktują to jako zero, więc 20na przykład dla danych wejściowych spowoduje to -20. Ponieważ dowolna liczba niezerowa jest $true, warunek pętli będzie $trueaż do $azrównania się z naszą liczbą wejściową (w tym momencie odejmowanie będzie równe 0lub $false). Sztuką pochodzi z post-przyrostu ++, która nie została wykonana dopiero po odejmowanie jest obliczana, więc obsługa wejście 1poprawnie wyjścia 0.1, a następnie zatrzymać pętlę na następnej iteracji.

Za każdym razem w pętli tworzymy po prostu literał łańcuchowy, który zostaje pozostawiony w potoku i odpowiednio wyprowadzany. Konstruujemy to z "0."konkatenacji z wynikiem jednoargumentowego -joinoperatora, który działał na tablicę znaków utworzoną z pobierania łańcucha "$a"do tyłu (przez indeksowanie przez zakres "$a".length..0).

Testuje się

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 bajtów

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

Pobiera liczbę jako argument wiersza poleceń i wyświetla każdy termin w osobnej linii. Na przykład:

$ ./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 bajtów

Uò1 ®+".0" w

Przetestuj online!

Jak to działa

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

wosk pszczeli ,57 53 bajty

Pracując nad problemem wyjścia cyfr binarnych dla kodu rozeta zauważyłem, że mogę użyć tego samego algorytmu krótkiego podziału dla sekwencji van der Corput, używając po prostu dzielenia i modulo przez 10 zamiast 2. Wyjście jest odwrócone w obu przypadkach.

Zmniejszone o 4 bajty, odzwierciedlając kod:

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

Sześciokątny ładny odcisk dla łatwiejszej orientacji:

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

Objaśnienie jednego cyklu w programie przy użyciu oryginalnego kodu:

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

Przykład:

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 bajtów

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

wyjaśnienie

example(strsplit)tworzy funkcję strReverse(to powinno być oczywiste)

Za pomocą IRanges::reversetego można golfować do 47 bajtów

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

Python 3, 47 bajtów

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

krótsze rozwiązanie z Python 2

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

Przypadek testowy

>>> 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 znaków / 15 bajtów

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

Try it here (Firefox only).

W porządku.

Wyjaśnienie

⩤⁽1ï⒨tworzy zakres [1,ï]do odwzorowania, ß)konwertuje mapitem (liczba) na ciąg, Ė⍞.0konkatuje .0do końca i ᴙodwraca cały ciąg.

Python 2, 54 bajtów

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

Wyjaśnienie:

Iteruj przez zestaw [1,input)i dołącz odwrócony ido ..

Nadal być golfem więcej.

PHP, 45 41 bajtów

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

Pobiera argument wejściowy z CLI. Uruchom tak:

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

• Zaoszczędzono 3 bajty, łącząc ciąg przed cofnięciem

Siatkówka, 39 bajtów

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

Pobiera dane wejściowe jednoargumentowe.

Wypróbuj online tutaj.

Gema, 45 znaków

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

Przykładowy przebieg:

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 bajtów

Wybrałem inny format wyjściowy, aby skrócić kod o 12 bajtów. Funkcja zwraca teraz tablicę ciągów. Skrócony o 5 kolejnych bajtów. Podziękowania dla Alexa A. za przypomnienie mi o interpolacji ciągów i korzystanie z anonimowej funkcji (pozbycie się 2 kolejnych bajtów).

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

lub alternatywnie

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"

Python 2, 40 bajtów

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

Przykład:

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

Rozwiązywanie algebraiczne:

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

jq 1,5, 40 35 znaków

(Kod 34 znaków + opcja wiersza poleceń 1 znak.)

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

Przykładowy przebieg:

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

Test on-line (Przekazanie -radresu URL nie jest obsługiwane - sprawdź sam wynik wyjściowy).

To samo z linkami do dokumentacji:

zakres ( . ) | „ \ ( . + 1 ) .0” / „” | rewers | Dodaj

Jako bardziej czytelną alternatywę powyższe można również zapisać w następujący sposób ( on-line ):

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

BBC BASIC, 89 88 87 bajtów

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

Użyto skrótów, aby maksymalnie skrócić rzeczy. Kompatybilny zarówno z Brandy Basic, jak i BASIC 2 na oryginalnej maszynie.

W przypadku nowoczesnych BBC BASIC można również pominąć numery linii, aby zaoszczędzić dwa kolejne bajty.

Dyalog APL , 12 bajtów

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

Wypróbuj online!

Prosto do przodu: {ciąg funkcji '0.'przed ,odwróconą ⌽reprezentacją ⍕ciągu argumentu ⍵funkcji }dla każdej ¨liczby od 1 do 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

Dane wyjściowe to tablica o nazwie „o”

Groovy, 36 znaków

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

Przykładowy przebieg:

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]