Corput 시퀀스 데르 밴 의 간단한 예이다 낮은 편차 시퀀스 . 두 n번째 용어는 단지 0.(n written in base 10 and mirrored)이므로 첫 번째 용어는 다음과 같습니다.

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

도전

van der Corput 시퀀스 의 첫 번째 항 n보다 작은 양의 정수를 입력으로 받아 10^6리턴하거나 인쇄하는 프로그래밍 언어로 프로그램 또는 함수를 작성하십시오 n. 출력 형식은 부동 소수점 숫자 목록, 형식 문자열 목록 0.digits또는 용어가 쉼표 및 / 또는 공백, 줄 바꿈으로 구분되는 고유 한 문자열 일 수 있습니다.

표준 허점 은 금지되어 있습니다. 가장 짧은 소스 코드가 승리합니다.

05AB1E , 6 바이트

암호:

>GNÞR,

온라인으로 사용해보십시오!

설명:

>       # 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 인코딩을 사용합니다.

Oracle SQL 11.2, 64 62 58 바이트

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

구 버전

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

''를 숫자로 연결하면 문자열에 캐스트됩니다. TO_CHAR ()보다 짧은 TRIM ()을 사용하는 것보다 2 바이트 더 짧습니다.

문자열을 NUMBER로 연결하면 문자열이 생성되므로 해당 문자열을 사용하여 '0'을 관리 할 수 ​​있습니다. 결과의 일부.

CJam, 14 11 바이트

3 바이트를 절약 한 Sp3000에 감사합니다.

ri{)d`W%S}/

여기에서 테스트하십시오.

설명

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

펄 6, 24 22 20 바이트

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

감사합니다 Aleks-Daniel Jakimenko-A. 또 다른 2 바이트

구 버전

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

편집 : 여분의 2 바이트에 대한 감사의 raiph

용법

> 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 바이트

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

테스트 사례

%[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 바이트

m_`cd1SQ

온라인으로 사용해보십시오.

이건 정말 단지 조합 이 와 이 대답. 따라서 커뮤니티 위키로 만들고 있습니다.

Pyth, 11 바이트

m+"0."_`dSQ

여기 사용해보십시오!

설명

m + "0."_`dSQ # Q = 입력

m SQ # 범위 (1, Q)를 ...
 + # ...의 연결 :
  "0."_`d # "0." 반전 된 요소

Pyth-10 바이트

_M+R".0"SQ

여기에서 온라인으로 사용해보십시오 .

자바 스크립트 (ES6), 58

쉼표로 구분 된 값을 가진 문자열을 반환하는 익명 함수

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

테스트

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 바이트

:"'0.'@VPh

온라인으로 사용해보십시오!

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

하스켈, 36 , 27 바이트

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

nimi는 2 바이트를 절약하고 Lynn은 7 바이트를 더 절약했습니다.

Brachylog , 23 바이트

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

숫자를 입력으로 사용하고 결과를 공백으로 구분하여 STDOUT에 출력합니다.

매우 간단합니다. 불행히도 :""rc내장 변환 술어가 없으므로이 숫자를 빈 문자열로 연결하여이 숫자를 문자열 ( )로 변환해야합니다.

숫자의 자릿수를 반대로 바꾸면 앞에 오는 0 이 사라 10지므로 문자열로의 변환이 필요 01합니다.

PowerShell, 52 바이트

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

내가 원하는 것보다 조금 길지만 몇 가지 깔끔한 트릭을 사용합니다.

while루프는 분명하지만, 조건이 조금 까다 롭습니다 - 우리가 $a(로 시작하는 $null처음 참조 될 때) 다음 우리의 입력 번호를 뺍니다 $args[0]. PowerShell에서 수학 연산 $null은 0 으로 처리하므로 20예를 들어 입력 하면 결과가됩니다 -20. 0이 아닌 숫자이므로 $true, 루프 조건부 것 $true까지 바로 $a우리의 입력 번호 (되는 감산 같을 것이다 가리 동일 0하거나 $false). 트릭 후행 증가에서 비롯 ++될 때까지 실행되지 않고, 이후 이렇게 입력 처리, 감산 계산 1의지를 정확하게 출력 0.1하고 다음 반복의 루프를 중지.

루프에서 매번 파이프 라인에 남겨지고 그에 따라 출력되는 문자열 리터럴을 만듭니다. 우리 는 문자열을 뒤로 가져 와서 (범위를 통해 색인화하여 ) 생성 된 char-array에 작용 "0."한 단항 -join연산자 의 결과와 연결하여 이것을 구성합니다 ."$a""$a".length..0

시운전

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

배쉬, 36 바이트

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

숫자를 명령 행 인수로 취하여 각 항을 별도의 행에 출력합니다. 예를 들면 다음과 같습니다.

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

apt, 12 바이트

Uò1 ®+".0" w

온라인으로 테스트하십시오!

작동 원리

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

밀랍 ,57 53 바이트

rosettacode의 이진 숫자 출력 문제에 대해 작업하면서 van der Corput 시퀀스에 대해 동일한 짧은 나누기 알고리즘을 사용할 수 있음을 알았습니다. 단 2 대신 10으로 나누기와 모듈로를 사용했습니다. 두 경우 모두 출력이 반전됩니다.

코드를 미러링하여 4 바이트 씩 줄였습니다.

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

보다 쉬운 오리엔테이션을위한 6 각형 지문

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

원래 코드를 사용하여 프로그램을 통한 한주기의 설명 :

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

예:

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 바이트

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

설명

example(strsplit)함수를 생성합니다 strReverse(그러면 분명해야합니다)

를 사용하면 IRanges::reverse47 바이트로 골프를 칠 수 있습니다.

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

파이썬 3, 47 바이트

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

Python 2를 사용한 더 짧은 솔루션

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

테스트 사례

>>> 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 자 / 15 바이트

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

Try it here (Firefox only).

괜찮아.

설명

⩤⁽1ï⒨범위 생성 [1,ï]을 통해 매핑이 ß)변환은 문자열 (수) mapitem Ė⍞.0concats .0끝, 그리고 ᴙ전체 문자열을 반전시킵니다.

파이썬 2, 54 바이트

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

설명:

집합을 반복 [1,input)하고에 반전 i을 추가합니다 ..

아직도 더 골프를 치십시오.

PHP, 45 41 바이트

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

CLI에서 입력 인수를 가져옵니다. 다음과 같이 실행하십시오.

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

• 반전하기 전에 문자열을 연결하여 3 바이트 절약

망막, 39 바이트

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

단항으로 입력합니다.

여기에서 온라인으로 사용해보십시오.

Gema, 45 자

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

샘플 실행 :

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 

줄리아 ,50 38 33 31 바이트

코드를 12 바이트 단축하기 위해 다른 출력 형식을 사용했습니다. 이 함수는 이제 문자열 배열을 반환합니다. 5 바이트 더 줄였습니다. 문자열 보간을 상기시키고 익명 함수를 사용하는 Alex A. 에게 감사 합니다 (2 바이트 더 제거).

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

또는 대안 적으로

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

테스트

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"

파이썬 2, 40 바이트

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

예:

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

대수 해결 :

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

jq 1.5, 40 35 자

(34 자 코드 + 1 자 명령 행 옵션)

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

샘플 실행 :

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

온라인 테스트 ( -rURL을 통한 전달 은 지원되지 않습니다-직접 출력을 확인하십시오.)

문서 링크와 동일합니다.

범위 ( . ) | " \ ( . + 1 ) .0" / ""| 역전 | 더하다

더 읽기 쉬운 대안으로 위의 내용을 다음과 같이 작성할 수도 있습니다 ( 온라인 ).

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

BBC 기본, 89 88 87 바이트

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

약어를 사용하여 가능한 한 많이 줄였습니다. 원래 머신에서 Brandy Basic 및 BASIC 2와 호환됩니다.

현대 BBC BASIC의 경우 줄 번호를 두어 바이트를 더 절약 할 수도 있습니다.

Dyalog APL , 12 바이트

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

온라인으로 사용해보십시오!

직선적 : 함수 {문자열 '0.'전에 ,반전 된 ⌽스트링 표현 ⍕인자의 ⍵함수에 }각각 ¨관통 번호 1 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

출력은 "o"라는 배열입니다

그루비, 36 자

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

샘플 실행 :

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]