A sequência de van der Corput é um dos exemplos mais simples de sequência de baixa discrepância . Seu n-ésimo termo é justo 0.(n written in base 10 and mirrored), portanto, seus primeiros termos são:

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

O desafio

Escreva um programa ou uma função em qualquer linguagem de programação que tome como entrada um número inteiro positivo nmenor que 10^6e retorne ou imprima os primeiros ntermos da sequência de van der Corput. O formato de saída pode ser uma lista de números de ponto flutuante, uma lista de cadeias de caracteres do formulário 0.digitsou uma cadeia exclusiva em que os termos são separados por vírgulas e / ou espaços em branco, novas linhas.

As brechas padrão são proibidas. O menor código fonte vence.

05AB1E , 6 bytes

Código:

>GNÞR,

Experimente online!

Explicação:

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

Usa a codificação CP-1252.

Oracle SQL 11.2, 64 62 58 bytes

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

Versão antiga

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

Concatenar '' para um número o converte em uma sequência. É 2 bytes menor que o uso de TRIM (), menor que TO_CHAR ().

Como concatenar uma string para um NUMBER resulta em uma string, é possível usá-la para gerenciar o '0'. parte do resultado.

CJam, 14 11 bytes

Agradecimentos ao Sp3000 por salvar 3 bytes.

ri{)d`W%S}/

Teste aqui.

Explicação

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}

Obrigado Aleks-Daniel Jakimenko-A. por mais dois bytes

versão antiga

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

EDIT: Obrigado raiph por 2 bytes extras

uso

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

Caso de teste

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

Pitão, 8 bytes

m_`cd1SQ

Experimente online.

Esta é realmente apenas uma combinação disso e desta resposta. Portanto, estou transformando-o em um wiki da comunidade.

Pitão, 11 bytes

m+"0."_`dSQ

Experimente aqui!

Explicação

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

m SQ # Mapeie o intervalo (1, Q) para ...
 + # ... a concatenação de:
  "0." _ `D #" 0 " e o elemento invertido

Pitão - 10 bytes

_M+R".0"SQ

Experimente online aqui .

JavaScript (ES6), 58

Uma função anônima que retorna uma sequência com valores separados por vírgula

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

TESTE

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

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

Dois bytes salvos por nimi e outros 7 por Lynn.

Braquilog , 23 bytes

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

Isso recebe um número como entrada e gera o resultado para STDOUT, separado por espaços.

Bastante direto. Infelizmente, precisamos concatenar o número com uma string vazia para converter esse número em string ( :""rc), porque ainda não há predicado de conversão interno.

A conversão para string é necessária, porque se invertermos os dígitos do número, os zeros à esquerda (por exemplo, 10torna-se 01) serão perdidos.

PowerShell, 52 bytes

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

Um pouco mais do que eu gostaria, mas usa alguns truques legais.

O whileloop é óbvio, mas o condicional é um pouco complicado - nós temos $a(que começa como $nullquando foi mencionado pela primeira vez) e subtraímos nosso número de entrada $args[0]. No PowerShell, as operações matemáticas $nulltratam como zero, portanto, para entrada, 20por exemplo, isso resultará em -20. Como qualquer número diferente de zero é $true, a condicional do loop será $trueaté $aigual ao nosso número de entrada (nesse ponto a subtração será igual 0ou $false). O truque vem do pós-incremento ++, que não é executado até depois que a subtração é calculada; portanto, manipular a entrada de 1será gerado corretamente 0.1e, em seguida, interromperá o loop na próxima iteração.

Cada vez que criamos um loop, criamos apenas um literal de string que é deixado no pipeline e produzido de acordo. Construímos isso de "0."concatenado com o resultado do -joinoperador unário que atuou no array de char criado ao retirar a string de "$a"trás para frente (indexando através do intervalo "$a".length..0).

Execuções de teste

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

Pega um número como argumento da linha de comando e gera cada termo em uma linha separada. Por exemplo:

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

Japonês, 12 bytes

Uò1 ®+".0" w

Teste online!

Como funciona

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

cera de abelha ,57 53 bytes

Trabalhando no problema de saída de dígitos binários do código de barras, notei que podia usar o mesmo algoritmo de divisão curta para a sequência de van der Corput, apenas usando divisão e módulo por 10 em vez de 2. A saída é revertida nos dois casos.

Golpeou por 4 bytes, espelhando o código:

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

Prettyprint hexagonal, para uma orientação mais fácil:

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

Explicação de um ciclo no programa, usando o código original:

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

Exemplo:

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

explicação

example(strsplit)cria a função strReverse(então deve ser óbvio)

Usando IRanges::reverse, isso pode ter um golfe de 47 bytes

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

Python 3, 47 bytes

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

uma solução mais curta com Python 2

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

Caso de teste

>>> 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 caracteres / 15 bytes

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

Try it here (Firefox only).

Está bem.

Explicação

⩤⁽1ï⒨cria um intervalo [1,ï]para mapear, ß)converte mapitem (número) em sequência, Ė⍞.0concata .0até o final e ᴙreverte toda a sequência.

Python 2, 54 bytes

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

Explicação:

Iterar através do conjunto [1,input) e anexa o invertido ipara ..

Ainda pode ser jogado mais.

PHP, 45 41 bytes

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

Pega o argumento de entrada da CLI. Execute assim:

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

• Salva 3 bytes concatenando a string antes de reverter

Retina, 39 bytes

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

Recebe entrada em unário.

Experimente online aqui.

Gema, 45 caracteres

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

Exemplo de execução:

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

Eu optei por um formato de saída diferente para reduzir o código em 12 bytes. A função retorna uma matriz de seqüências de caracteres agora. Encurtado por mais 5 bytes. Agradeço a Alex A. por me lembrar da interpolação de cadeias e usar uma função anônima (eliminando mais 2 bytes).

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

ou alternativamente

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

Teste

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

Exemplo:

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

Resolução algébrica:

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

jq 1.5, 40 35 caracteres

(Código de 34 caracteres + opção de linha de comando de 1 caractere.)

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

Exemplo de execução:

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

Teste on-line (a passagem do -rURL não é suportada - verifique você mesmo Raw Output.)

O mesmo com os links para a documentação:

intervalo ( . ) | " \ ( . + 1 ) .0" / "" | reverter | adicionar

Como uma alternativa mais legível, o acima também poderia ser escrito assim ( 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)

Abreviações usadas para reduzir o máximo possível as coisas. Compatível com o Brandy Basic e o BASIC 2 na máquina original.

Para os modernos BASIC da BBC, você também pode deixar de fora os números de linha para economizar mais dois bytes.

Dyalog APL , 12 bytes

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

Experimente online!

Direto: a {sequência de funções '0.'antes ,da ⌽representação ⍕de sequência invertida do argumento ⍵para a função }para cada um ¨dos números de 1 a 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

Saída é a matriz chamada "o"

Groovy, 36 caracteres

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

Exemplo de execução:

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]