Salida de la secuencia de van der Corput

27

La secuencia de van der Corput es uno de los ejemplos más simples de secuencia de baja discrepancia . Su nenésimo término es justo 0.(n written in base 10 and mirrored), por lo que sus primeros términos son:

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

El reto

Escriba un programa o una función en cualquier lenguaje de programación que tome como entrada un entero positivo nmenor que 10^6y devuelva o imprima los primeros ntérminos de la secuencia de van der Corput. El formato de salida puede ser una lista de números de coma flotante, una lista de cadenas del formulario 0.digitso una cadena única donde los términos están separados por comas y / o espacios en blanco, líneas nuevas.

Las lagunas estándar están prohibidas. El código fuente más corto gana.

code-golf sequence Mover
fuente

Respuestas:

16

05AB1E , 6 bytes

Código:

>GNÞR,

Pruébalo en línea!

Explicación:

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

Utiliza la codificación CP-1252.

Adnan
fuente
¿Quieres decir, windows-1252?
Ismael Miguel
@IsmaelMiguel Eso es lo mismo
Adnan
Lo sé, pero generalmente no se reconoce por el nombre CP-1252
Ismael Miguel
¿Tuviste que modificar tu idioma para este desafío?
Andrew Savinykh
@AndrewSavinykh No, eso se considera trampa y no está permitido en este sitio. Funciona con la versión 7.3 , que se lanzó antes de que se publicara este desafío.
Adnan
8

Oracle SQL 11.2, 64 62 58 bytes

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

Versión antigua 

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

Concatenar '' a un número lo convierte en una cadena. Es 2 bytes más corto que usar TRIM (), que es más corto que TO_CHAR ().

Dado que concatenar una cadena a un NÚMERO da como resultado una cadena, es posible usar esa cadena para administrar el '0'. parte del resultado.

Jeto
fuente
7

CJam, 14 11 bytes

Gracias a Sp3000 por guardar 3 bytes.

ri{)d`W%S}/

Pruébalo aquí.

Explicación

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

Perl 6, 24 22 20 bytes

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

Gracias Aleks-Daniel Jakimenko-A. para otros dos bytes más

versión antigua

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

EDITAR: Gracias raiph por 2 bytes adicionales

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 acceso rápido
fuente
1
{("0."~.flip for ^$_)}ahorra 2 bytes
raiph
6

Mathematica, 40 bytes

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

Caso de prueba

%[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
fuente
5

Pyth, 8 bytes

m_`cd1SQ

Pruébalo en línea.

Esto es realmente solo una combinación de esto y esta respuesta. Por lo tanto, lo estoy haciendo un wiki comunitario

revs Pietu1998
fuente
4

Pyth, 11 bytes

m+"0."_`dSQ

Pruébalo aquí!

Explicación

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

m SQ # Asigna el rango (1, Q) a ...
 + # ... la concatenación de:
  "0". _ `D #" 0. " y el elemento invertido
Denker
fuente
4

JavaScript (ES6), 58

Una función anónima que devuelve una cadena con valores separados por comas

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

PRUEBA

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>
Expandir fragmento

edc65
fuente
4

MATL , 10 bytes

:"'0.'@VPh

Pruébalo en línea!

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

Haskell, 36 , 27 bytes

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

Dos bytes guardados por nimi y 7 adicionales por Lynn.

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

Brachylog , 23 bytes

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

Esto toma un número como entrada y envía el resultado a STDOUT, separado por espacios.

Bastante sencillo. Desafortunadamente, tenemos que concatenar el número con una cadena vacía para convertir este número en una cadena ( :""rc), porque todavía no hay un predicado de conversión incorporado.

La conversión a cadena es necesaria, porque si invertimos los dígitos del número, los ceros iniciales (por ejemplo, se 10convierten 01) se perderían.

Fatalizar
fuente
3

PowerShell, 52 bytes

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

Un poco más de lo que me gustaría, pero usa un par de trucos geniales.

El whilebucle es obvio, pero el condicional es un poco complicado: tenemos $a(que comienza como $nullcuando se hace referencia por primera vez) y luego restamos nuestro número de entrada $args[0]. En PowerShell, las operaciones matemáticas en $nulltratarlo como cero, por lo que para la entrada, 20por ejemplo, esto dará como resultado -20. Como cualquier número distinto de cero es $true, el bucle condicional estará $truejusto hasta que sea $aigual a nuestro número de entrada (en ese punto, la resta será igual 0o $false). El truco proviene del incremento posterior ++, que no se ejecuta hasta después de que se calcula la resta, por lo que el manejo de la entrada de 1saldrá correctamente 0.1y luego detendrá el ciclo en la próxima iteración.

Cada vez en el bucle, solo creamos un literal de cadena que se deja en la tubería y se genera en consecuencia. Construimos esto a partir de "0."concatenados con el resultado del -joinoperador unario que ha actuado en la matriz de caracteres creada al llevar la cadena "$a"hacia atrás (indexando a través del rango "$a".length..0).

Ejecuciones de prueba

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
fuente
3

Bash, 36 bytes

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

Toma un número como argumento de línea de comando y genera cada término en una línea separada. Por ejemplo:

$ ./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 aprensivo
fuente
2
Si no es pura Bash todos modos: seq -f%g.0 $1|rev.
manatwork
@manatwork Cool. No sabía que seqpodía hacer una salida formateada.
aprensivo ossifrage
3

Japt, 12 bytes

Uò1 ®+".0" w

¡Pruébalo en línea!

Cómo 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
ETHproducciones
fuente
3

cera de abejas ,57 53 bytes

Al trabajar en el problema de salida de dígitos binarios para rosettacode, noté que podía usar el mismo algoritmo de división corta para la secuencia de van der Corput, solo usando la división y el módulo por 10 en lugar de 2. La salida se invierte en ambos casos.

Golfed por 4 bytes, reflejando el código:

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

Impresión bonita hexagonal, para una orientación más fácil:

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

Explicación de un ciclo a través del programa, utilizando el 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)

Ejemplo:

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
fuente
2

R, 59 bytes

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

explicación

example(strsplit)crea la función strReverse(entonces debería ser obvio)

Usando IRanges::reverse, esto podría ser golfizado a 47 bytes

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

Python 3, 47 bytes

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

una solución más corta con Python 2

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

Caso de prueba

>>> 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
fuente
Mi solución de Python era la misma, pero creo que f=no es necesaria, por lo que tiene una longitud de 47 bytes.
Bob
@Bob ok, lo eliminé
Erwan
Esto genera los primeros n-1términos.
seequ
@Seeq tienes razón, cambio la solución, no cambia el recuento de bytes
Erwan
lambda n:['0.'+`i+1`[::-1]for i in range(n)]es más corto si usa Python 2. Además, no debe decir "Python 3.5" a menos que requiera 3.5, lo cual no es así. Esta versión requiere Python 2.
mbomb007
1

𝔼𝕊𝕄𝕚𝕟, 12 caracteres / 15 bytes

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

Try it here (Firefox only).

Está bien.

Explicación

⩤⁽1ï⒨crea un rango [1,ï]para mapear, ß)convierte el elemento de mapa (número) en una cadena, Ė⍞.0concatena .0hasta el final e ᴙinvierte toda la cadena.

Mama Fun Roll
fuente
1

Python 2, 54 bytes

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

Explicación:

Iterar a través del conjunto [1,input)y añade el revirtió ia ..

Todavía se puede jugar más al golf.

intboolstring
fuente
Usar en `i`lugar de str(i). Además, creo que necesita imprimir el cero inicial.
mbomb007
1

PHP, 45 41 bytes

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

Toma el argumento de entrada de CLI. Corre así:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100
  • Guardado 3 bytes concatenando la cadena antes de invertir
aross
fuente
1

Gema, 45 personajes

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

Ejecución de muestra:

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
hombre trabajando
fuente
1

Julia ,50 38 33 31 bytes

Fui por un formato de salida diferente para acortar el código en 12 bytes. La función devuelve una matriz de cadenas ahora. Acortado por 5 bytes más. Gracias a Alex A. por recordarme la interpolación de cadenas y usar una función anónima (deshacerse de 2 bytes más).

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

o alternativamente

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

Prueba

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
fuente
1
31 bytes:n->["0."reverse("$i")for i=1:n]
Alex A.
1
Por cierto, puedes solicitar que tu perfil se fusione con el anterior aquí .
Alex A.
Muy bien, no lo sabía. ¡Gracias!
ML
@AlexA. la función anónima en sí misma no genera nada. ¿No sería necesaria una versión más larga como map(n->["0."reverse("$i")for i=1:n],3)(para n = 3) para producir cualquier salida? Eso lo haría (al menos) tan largo como mi solución.
ML
1
Para una función anónima, simplemente agrega la estipulación de que para llamarla, se debe asignar a una variable. Guarda dos bytes sobre una función con nombre y cumple con nuestras reglas.
Alex A.
1

Python 2, 40 bytes

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

Ejemplo:

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

Resolución algebraica:

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

jq 1.5, 40 35 caracteres

(Código de 34 caracteres + opción de línea de comando de 1 carácter).

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

Ejecución de muestra:

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

Prueba en línea ( -rno se admite el paso por la URL; compruebe usted mismo la salida sin formato).

Lo mismo con enlaces a la documentación:

rango ( . ) | " \ ( . + 1 ) .0" / "" | reverso |añadir

Como una alternativa más legible, lo anterior también podría escribirse así ( en línea ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")
hombre trabajando
fuente
jq es realmente genial. ¿Te importaría explicar cómo "\(.+1).0"/""funciona?
seequ
No hay nada especial, solo una interpolación de cadenas \(…) y una división / , que en caso de cadenas se divide.
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)

Abreviaturas utilizadas para acortar las cosas tanto como sea posible. Compatible con Brandy Basic y BASIC 2 en la máquina original.

Para los BBC BASIC modernos, también puede dejar fuera de los números de línea para guardar dos bytes más.

Darzzr
fuente
1

Dyalog APL , 12 bytes

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

Pruébalo en línea!

Directo: la {cadena de función '0.'antes de ,la ⌽representación ⍕de cadena invertida del argumento ⍵a la función }para cada uno ¨de los números del 1 al n ⍳ .

Adán
fuente
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

La salida es la matriz llamada "o"

xem
fuente
0

Groovy, 36 personajes

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

Ejecución de muestra:

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]
hombre trabajando
fuente