Emette la sequenza di Van der Corput

27

La sequenza di van der Corput è uno dei più semplici esempi di sequenza a bassa discrepanza . Il suo nterzo termine è giusto 0.(n written in base 10 and mirrored), quindi i suoi primi termini sono:

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

La sfida

Scrivi un programma o una funzione in qualsiasi linguaggio di programmazione che accetta come input un numero intero positivo ninferiore 10^6e restituisce o stampa i primi ntermini della sequenza van der Corput. Il formato di output può essere un elenco di numeri in virgola mobile, un elenco di stringhe del modulo 0.digitso una stringa univoca in cui i termini sono separati da virgole e / o spazi bianchi, nuove righe.

Sono vietate le scappatoie standard . Vince il codice sorgente più breve.

code-golf  sequence 
— peso
fonte

Risposte:

16

05AB1E , 6 byte

Codice:

>GNÞR,

Provalo online!

Spiegazione:

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

Utilizza la codifica CP-1252.

— Adnan
fonte
Vuoi dire, windows-1252?
— Ismael Miguel,
@IsmaelMiguel È lo stesso
— Adnan,
Lo so, ma di solito non è riconosciuto con il nome CP-1252
— Ismael Miguel,
Hai dovuto modificare la tua lingua ai fini di questa sfida?
— Andrew Savinykh,
@AndrewSavinykh No, questo è considerato un imbroglio e non è consentito su questo sito. Funziona con la versione 7.3 , che è stata rilasciata prima che questa sfida fosse pubblicata.
— Adnan,
8

Oracle SQL 11.2, 64 62 58 byte

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

Vecchia versione 

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

Concatenare "" un numero lo lancia in una stringa. È più corto di 2 byte rispetto all'uso di TRIM (), che è più corto di TO_CHAR ().

Poiché la concatenazione di una stringa a un NUMERO risulta in una stringa, è possibile utilizzare quella stringa per gestire lo "0". parte del risultato.

— Jeto
fonte
7

CJam, 14 11 byte

Grazie a Sp3000 per aver salvato 3 byte.

ri{)d`W%S}/

Provalo qui.

Spiegazione

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 byte

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

Grazie Aleks-Daniel Jakimenko-A. per ancora altri due byte

vecchia versione

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

EDIT: grazie a Raiph per 2 byte extra

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)
— Tasti di scelta rapida
fonte
1
{("0."~.flip for ^$_)}salva 2 byte
— raiph il
6

Mathematica, 40 byte

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

Caso di prova

%[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
4

Pyth, 11 byte

m+"0."_`dSQ

Provalo qui!

Spiegazione

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

m SQ # Mappa l'intervallo (1, Q) a ...
 + # ... la concatenazione di:
  "0." _ `D #" 0. " e l'elemento invertito
— Denker
fonte
4

JavaScript (ES6), 58

Una funzione anonima che restituisce una stringa con valori separati da virgola

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>
Espandi frammento

— edc65
fonte
4

MATL , 10 byte

:"'0.'@VPh

Provalo 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 byte

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

Due byte salvati da nimi e altri 7 da Lynn.

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

Brachylog , 23 byte

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

Questo prende un numero come input e invia il risultato a STDOUT, separato da spazi.

Abbastanza semplice. Sfortunatamente dobbiamo concatenare il numero con una stringa vuota per convertire questo numero in una stringa ( :""rc), perché non esiste ancora un predicato di conversione incorporato.

La conversione in stringa è necessaria, perché se invertiamo le cifre del numero, gli zeri iniziali (ad esempio 10diventano 01) andrebbero persi.

— Fatalize
fonte
3

PowerShell, 52 byte

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

Un po 'più lungo di quanto vorrei, ma usa un paio di trucchi accurati.

Il whileciclo è ovvio, ma il condizionale è un po 'complicato - abbiamo $a(che inizia come $nullquando si fa riferimento per la prima volta) e quindi sottraggiamo il nostro numero di input $args[0]. In PowerShell, le operazioni matematiche su lo $nulltrattano come zero, quindi per l'input, 20ad esempio, ciò comporterà -20. Poiché qualsiasi numero diverso da zero è $true, il condizionale del ciclo sarà $truefino a quando sarà $auguale al nostro numero di input (a quel punto la sottrazione sarà uguale 0o $false). Il trucco deriva dal post-incremento ++, che non viene eseguito fino a quando non viene calcolata la sottrazione, quindi la gestione dell'input di 1verrà emessa correttamente 0.1e quindi interromperà il ciclo alla successiva iterazione.

Ogni volta nel loop, creiamo semplicemente una stringa letterale che viene lasciata sulla pipeline e prodotta di conseguenza. Costruiamo questo da "0."concatenato con il risultato -joindell'operatore unario che ha agito sul char-array creato dal prendere la stringa "$a"all'indietro (indicizzando attraverso l'intervallo "$a".length..0).

Esecuzioni di test

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 byte

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

Prende un numero come argomento della riga di comando e genera ogni termine su una riga separata. Per esempio:

$ ./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 schizzinoso
fonte
2
Se non pura Bash in ogni caso: seq -f%g.0 $1|rev.
— arte
@manatwork Cool. Non sapevo che seqpotesse fare un output formattato.
— ossifrage schifoso
3

Japt, 12 byte

Uò1 ®+".0" w

Provalo online!

Come funziona

           // 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 d'api ,57 53 byte

Lavorando sul problema dell'output di cifre binarie per rosettacode ho notato che potevo usare lo stesso algoritmo di divisione breve per la sequenza di van der Corput, usando semplicemente divisione e modulo di 10 anziché 2. L'output è invertito in entrambi i casi.

Golfato di 4 byte, rispecchiando il codice:

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

Prettyprint esagonale, per un orientamento più semplice:

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

Spiegazione di un ciclo attraverso il programma, usando il codice originale:

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

Esempio:

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 byte

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

spiegazione

example(strsplit)crea la funzione strReverse(quindi dovrebbe essere ovvio)

Utilizzando IRanges::reverse, questo potrebbe essere golfato a 47 byte

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

Python 3, 47 byte

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

una soluzione più breve con Python 2

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

Caso di prova

>>> 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
La mia soluzione Python era la stessa, ma penso che f=non sia necessaria, quindi è lunga 47 byte.
— Bob,
@Bob ok l'ho rimosso
— Erwan,
Questo genera i primi n-1termini.
— Seequ,
@Seeq hai ragione, cambio la soluzione, non cambia il conteggio dei byte
— Erwan,
lambda n:['0.'+`i+1`[::-1]for i in range(n)]è più breve se si utilizza Python 2. Inoltre, non si dovrebbe dire "Python 3.5" a meno che non richieda 3.5, cosa che non accade. Questa versione richiede Python 2.
— mbomb007,
1

𝔼𝕊𝕄𝕚𝕟, 12 caratteri / 15 byte

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

Try it here (Firefox only).

Va bene.

Spiegazione

⩤⁽1ï⒨crea un intervallo [1,ï]da mappare, ß)converte mapitem (numero) in stringa, si Ė⍞.0concede .0alla fine e ᴙinverte l'intera stringa.

— Mama Fun Roll
fonte
1

Python 2, 54 byte

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

Spiegazione:

Scorrere il set [1,input)e aggiunge il invertito ia ..

Ancora un golf.

— intboolstring
fonte
Usa `i`invece di str(i). Inoltre, penso che sia necessario stampare lo zero iniziale.
— mbomb007,
1

PHP, 45 41 byte

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

Prende l'argomento di input dalla CLI. Esegui in questo modo:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100
  • Salvato 3 byte concatenando la stringa prima di invertire
— aross
fonte
1

Gema, 45 personaggi

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

Esecuzione di esempio:

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
— uomo al lavoro
fonte
1

Julia ,50 38 33 31 byte

Ho optato per un formato di output diverso per abbreviare il codice di 12 byte. La funzione restituisce ora una matrice di stringhe. Accorciato di altri 5 byte. Grazie ad Alex A. per avermi ricordato dell'interpolazione di stringhe e dell'uso di una funzione anonima (eliminando altri 2 byte).

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

o in alternativa

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"
— ML
fonte
1
31 byte:n->["0."reverse("$i")for i=1:n]
— Alex A.
1
A proposito, puoi richiedere che il tuo profilo sia unito a quello vecchio qui .
— Alex A.
Molto bello, non lo sapevo. Grazie!
— ML
@AlexA. la stessa funzione anonima non genera nulla. Non sarebbe necessaria una versione più lunga come map(n->["0."reverse("$i")for i=1:n],3)(per n = 3) per produrre un output? Ciò renderebbe (almeno) fintanto che la mia soluzione.
— ML
1
Per una funzione anonima, è sufficiente aggiungere la clausola che per chiamarlo, è necessario assegnarlo a una variabile. Salva due byte su una funzione denominata ed è conforme alle nostre regole.
— Alex A.
1

Python 2, 40 byte

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

Esempio:

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

Soluzione algebrica:

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 caratteri

(Codice di 34 caratteri + opzione della riga di comando di 1 carattere.)

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

Esecuzione di esempio:

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 online (il passaggio -rtramite URL non è supportato: controlla tu stesso l'output non elaborato).

Lo stesso con i collegamenti alla documentazione:

intervallo ( . ) | " \ ( . + 1 ) .0" / "" | retromarcia | Inserisci

Come alternativa più leggibile, quanto sopra potrebbe anche essere scritto in questo modo ( on-line ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")
— uomo al lavoro
fonte
jq è davvero bello. Ti dispiace spiegare come "\(.+1).0"/""funziona?
— Seequ,
Non c'è niente di speciale, solo un'interpolazione di stringhe \(…) e una divisione / , che in caso di stringhe è divisa.
— arte
1

BBC BASIC, 89 88 87 byte

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

Abbreviazioni usate per abbreviare il più possibile le cose. Compatibile con Brandy Basic e BASIC 2 sulla macchina originale.

Per i moderni BASIC della BBC puoi anche lasciare i numeri di riga per salvare altri due byte.

— Darzzr
fonte
1

Dyalog APL , 12 byte

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

Provalo online!

Semplice: la {stringa della funzione '0.'prima ,della ⌽rappresentazione invertita della stringa ⍕dell'argomento ⍵alla funzione }per ciascuno ¨dei numeri da 1 a n ⍳ .

— Adamo
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

L'output è l'array chiamato "o"

— XEM
fonte
0

Groovy, 36 personaggi

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

Esecuzione di esempio:

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]
— uomo al lavoro
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.