Saída da sequência van der Corput

27

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.

Prumo
fonte

Respostas:

16

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.

Adnan
fonte
Você quer dizer, windows-1252?
Ismael Miguel
@IsmaelMiguel Isso é o mesmo #
Adnan
Eu sei, mas geralmente não é reconhecido pela CP-1252 Nome
Ismael Miguel
Você teve que modificar seu idioma para o objetivo deste desafio?
Andrew Savinykh
@AndrewSavinykh Não, isso é considerado trapaça e não é permitido neste site. Ele funciona com a versão 7.3 , lançada antes do lançamento deste desafio.
Adnan
8

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.

Jeto
fonte
7

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.
}/
Martin Ender
fonte
7

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)
Teclas de atalho
fonte
1
{("0."~.flip for ^$_)}salva 2 bytes
raiph
6

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} *)
njpipeorgan
fonte
5

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.

Pietu1998
fonte
4

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
Denker
fonte
4

Pitão - 10 bytes

_M+R".0"SQ

Experimente online aqui .

Maltysen
fonte
Um byte menor, se você fizer o mesmoVSQ...
Jakube
4

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>

edc65
fonte
4

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
Luis Mendo
fonte
4

Haskell, 36 , 27 bytes

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

Dois bytes salvos por nimi e outros 7 por Lynn.

Michael Klein
fonte
f n=reverse.show<$>[1.0..n]
11116 Lynn
3

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.

Fatalizar
fonte
3

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
AdmBorkBork
fonte
3

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
ossifrage melindroso
fonte
2
Se não for pura Bash de qualquer maneira: seq -f%g.0 $1|rev.
manatwork
@manatwork Cool. Eu não sabia que seqpoderia fazer saída formatada.
Ossifrage melindroso 25/02
3

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
ETHproductions
fonte
3

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!
ML
fonte
2

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())))
mnel
fonte
2

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']
Erwan
fonte
Minha solução Python era a mesma, mas acho que isso f=não é necessário, por isso tem 47 bytes de comprimento.
Bob
@Bob ok i removeu
Erwan
Isso gera os primeiros n-1termos.
seequ
@Seeq você está certo, eu mudar a solução, isso não muda os bytes contar
Erwan
lambda n:['0.'+`i+1`[::-1]for i in range(n)]é mais curto se você usa o Python 2. Além disso, você não deve dizer "Python 3.5" a menos que exija 3.5, o que não é necessário. Esta versão requer Python 2.
mbomb007
1

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

Mama Fun Roll
fonte
1

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.

intboolstring
fonte
Use em `i`vez de str(i). Além disso, acho que você precisa imprimir o zero inicial.
Mbomb007
1

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
aross
fonte
1

Retina, 39 bytes

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

Recebe entrada em unário.

Experimente online aqui.

randomra
fonte
1

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 
homem a trabalhar
fonte
1

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"
ML
fonte
1
31 bytes:n->["0."reverse("$i")for i=1:n]
Alex A.
1
A propósito, você pode solicitar que seu perfil seja mesclado com o antigo aqui .
Alex A.
Muito legal, não sabia disso. Obrigado!
ML
@AlexA. a própria função anônima não produz nada. Uma versão mais longa como map(n->["0."reverse("$i")for i=1:n],3)(para n = 3) não seria necessária para produzir qualquer saída? Isso tornaria (pelo menos) o tempo que minha solução.
ML
1
Para uma função anônima, basta adicionar a estipulação de que para chamá-la, é necessário atribuí-la a uma variável. Salva dois bytes em uma função nomeada e está em conformidade com nossas regras.
11286 Alex A.
1

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]
seequ
fonte
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("")
homem a trabalhar
fonte
jq é muito legal. Mente explicando como "\(.+1).0"/""funciona?
seequ
Não há nada de especial, apenas uma interpolação de cordas \(…) e uma divisão / que, no caso de cordas, é dividida.
26616 manatwork
1

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.

Darzzr
fonte
1

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 .

Adão
fonte
0

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"

xem
fonte
0

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]
homem a trabalhar
fonte