Sortie de la séquence van der Corput

27

La séquence de van der Corput est l'un des exemples les plus simples de séquence à faible écart . Son n-ième terme est juste 0.(n written in base 10 and mirrored), donc ses premiers termes sont:

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

Le défi

Écrivez un programme ou une fonction dans n'importe quel langage de programmation qui prend en entrée un entier positif ninférieur à 10^6et renvoie ou imprime les premiers ntermes de la séquence van der Corput. Le format de sortie peut être une liste de nombres à virgule flottante, une liste de chaînes du formulaire 0.digitsou une chaîne unique où les termes sont séparés par des virgules et / ou des espaces, des retours à la ligne.

Les failles standard sont interdites. Le code source le plus court gagne.

code-golf  sequence 
— Bob
source

Réponses:

16

05AB1E , 6 octets

Code:

>GNÞR,

Essayez-le en ligne!

Explication:

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

Utilise l'encodage CP-1252.

— Adnan
source
Vous voulez dire, windows-1252?
— Ismael Miguel
@IsmaelMiguel C'est la même chose
— Adnan
Je sais, mais il n'est généralement pas reconnu par le nom CP-1252
— Ismael Miguel
Avez-vous dû modifier votre langue dans le cadre de ce défi?
— Andrew Savinykh
@AndrewSavinykh Non, cela est considéré comme de la triche et n'est pas autorisé sur ce site. Il fonctionne avec la version 7.3 , qui a été publiée avant la publication de ce défi.
— Adnan
8

Oracle SQL 11.2, 64 62 58 octets

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

Ancienne version 

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

Concaténer '' à un nombre le transforme en chaîne. Il est 2 octets plus court que l'utilisation de TRIM (), qui est plus court que TO_CHAR ().

Étant donné que la concaténation d'une chaîne en un nombre donne une chaîne, il est possible d'utiliser cette chaîne pour gérer le «0». une partie du résultat.

— Jeto
source
7

CJam, 14 11 octets

Merci à Sp3000 pour avoir économisé 3 octets.

ri{)d`W%S}/

Testez-le ici.

Explication

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

Perl 6, 24 22 20 octets

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

Merci Aleks-Daniel Jakimenko-A. pour encore deux octets

ancienne version

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

EDIT: Merci raiph pour 2 octets supplémentaires

usage

> 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)
— Raccourcis clavier
source
1
{("0."~.flip for ^$_)}enregistre 2 octets
— raiph
6

Mathematica, 40 octets

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

Cas de test

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

Pyth, 11 octets

m+"0."_`dSQ

Essayez-le ici!

Explication

m + "0". _ `dSQ # Q = entrée

m SQ # Mappez la plage (1, Q) à ...
 + # ... la concaténation de:
  "0." _ `D #" 0. " et l'élément inversé
— Denker
source
4

JavaScript (ES6), 58

Une fonction anonyme renvoyant une chaîne avec des valeurs séparées par des virgules

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

TESTER

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>
Développer l'extrait

— edc65
source
4

MATL , 10 octets

:"'0.'@VPh

Essayez-le en ligne!

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

Haskell, 36 , 27 octets

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

Deux octets enregistrés par nimi et 7 autres par Lynn.

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

Brachylog , 23 octets

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

Cela prend un nombre en entrée et renvoie le résultat à STDOUT, séparé par des espaces.

Assez simple. Malheureusement, nous devons concaténer le nombre avec une chaîne vide pour convertir ce nombre en chaîne ( :""rc), car il n'y a pas encore de prédicat de conversion intégré.

La conversion en chaîne est nécessaire, car si nous inversons les chiffres du nombre, les zéros en tête (par exemple, 10devient 01) seraient perdus.

— Fatalize
source
3

PowerShell, 52 octets

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

Un peu plus longtemps que je ne le souhaiterais, mais utilise quelques astuces intéressantes.

La whileboucle est évidente, mais le conditionnel est un peu délicat - nous avons $a(qui commence comme $nulllors du premier référencement) puis soustrayons notre numéro d'entrée $args[0]. Dans PowerShell, les opérations mathématiques sur le $nulltraitent comme zéro, donc pour l'entrée 20par exemple, cela se traduira par -20. Étant donné que tout nombre non nul est $true, la boucle conditionnelle sera $truejusqu'à ce qu'elle $asoit égale à notre nombre d'entrée (auquel point la soustraction sera égale 0ou $false). L'astuce vient du post-incrément ++, qui ne s'exécute qu'après le calcul de la soustraction, donc la gestion de l'entrée de 1sera correctement sortie 0.1, puis arrêtera la boucle à l'itération suivante.

Chaque fois dans la boucle, nous créons simplement un littéral de chaîne qui est laissé sur le pipeline et produit en conséquence. Nous construisons cela à partir de la "0."concaténation avec le résultat de l' -joinopérateur unaire qui a agi sur le tableau de caractères créé à partir de la prise de la chaîne en "$a"arrière (en l'indexant via la plage "$a".length..0).

Exécutions de 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
source
3

Bash, 36 octets

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

Prend un nombre comme argument de ligne de commande et génère chaque terme sur une ligne distincte. Par exemple:

$ ./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 délicat
source
2
Sinon pur Bash de toute façon: seq -f%g.0 $1|rev.
— manatwork
@manatwork Cool. Je ne savais pas qu'il seqpouvait faire une sortie formatée.
— squeamish ossifrage
3

Japt, 12 octets

Uò1 ®+".0" w

Testez-le en ligne!

Comment ça marche

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

cire d'abeille ,57 53 octets

En travaillant sur le problème de sortie des chiffres binaires pour le rosettacode, j'ai remarqué que je pouvais utiliser le même algorithme de division courte pour la séquence de van der Corput, en utilisant simplement la division et le modulo par 10 au lieu de 2. La sortie est inversée dans les deux cas.

Golfé par 4 octets, en reflétant le code:

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

Jolie empreinte hexagonale, pour une orientation plus facile:

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

Explication d'un cycle à travers le programme, en utilisant le code d'origine:

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

Exemple:

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

R, 59 octets

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

explication

example(strsplit)crée la fonction strReverse(alors ça devrait être évident)

À l'aide IRanges::reverse, cela pourrait être joué à 47 octets

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

Python 3, 47 octets

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

une solution plus courte avec Python 2

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

Cas de test

>>> 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
source
Ma solution Python était la même, mais je pense que ce f=n'est pas nécessaire, elle fait donc 47 octets de long.
— Bob
@Bob ok je l'ai supprimé
— Erwan
Cela génère les premiers n-1termes.
— seequ
@Seeq vous avez raison je change la solution, cela ne change pas le nombre d'octets
— Erwan
lambda n:['0.'+`i+1`[::-1]for i in range(n)]est plus court si vous utilisez Python 2. En outre, vous ne devez pas dire "Python 3.5" à moins qu'il ne nécessite la version 3.5, ce qui n'est pas le cas. Cette version nécessite Python 2.
— mbomb007
1

𝔼𝕊𝕄𝕚𝕟, 12 caractères / 15 octets

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

Try it here (Firefox only).

Ça va.

Explication

⩤⁽1ï⒨crée une plage [1,ï]sur laquelle mapper, ß)convertit mapitem (nombre) en chaîne, Ė⍞.0concatène .0jusqu'à la fin et ᴙinverse la chaîne entière.

— Mama Fun Roll
source
1

Python 2, 54 octets

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

Explication:

Parcourez l'ensemble [1,input)et ajoutez l'inverse ià ..

Encore un golf plus.

— intboolstring
source
Utilisez `i`au lieu de str(i). De plus, je pense que vous devez imprimer le zéro de tête.
— mbomb007
1

PHP, 45 41 octets

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

Prend l'argument d'entrée de CLI. Courez comme ceci:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100
  • Enregistré 3 octets en concaténant la chaîne avant l'inversion
— aross
source
1

Gema, 45 caractères

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

Exemple d'exécution:

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
— homme au travail
source
1

Julia ,50 38 33 31 octets

J'ai opté pour un format de sortie différent pour raccourcir le code de 12 octets. La fonction renvoie maintenant un tableau de chaînes. Raccourci de 5 octets supplémentaires. Merci à Alex A. de m'avoir rappelé l'interpolation de chaînes et d'utiliser une fonction anonyme (se débarrasser de 2 octets de plus).

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

Ou bien

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

Tester

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
source
1
31 octets:n->["0."reverse("$i")for i=1:n]
— Alex A.
1
À propos, vous pouvez demander que votre profil soit fusionné avec l'ancien ici .
— Alex A.
Très cool, je ne savais pas ça. Merci!
— ML
@AlexA. la fonction anonyme elle-même ne produit rien. Une version plus longue comme map(n->["0."reverse("$i")for i=1:n],3)(pour n = 3) ne serait-elle pas nécessaire pour produire une sortie? Cela ferait (au moins) aussi longtemps que ma solution.
— ML
1
Pour une fonction anonyme, il suffit d'ajouter la stipulation que pour l'appeler, il faut l'assigner à une variable. Enregistre deux octets sur une fonction nommée et est conforme à nos règles.
— Alex A.
1

Python 2, 40 octets

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

Exemple:

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

Résolution algébrique:

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

jq 1.5, 40 35 caractères

(Code de 34 caractères + option de ligne de commande de 1 caractère.)

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

Exemple d'exécution:

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 en ligne (le passage -rpar l'URL n'est pas pris en charge - vérifiez vous-même la sortie brute.)

La même chose avec les liens vers la documentation:

gamme ( . ) | " \ ( . + 1 ) .0" / "" | inverser | ajouter

Comme alternative plus lisible, ce qui précède pourrait également être écrit comme ceci ( en ligne ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")
— homme au travail
source
jq est vraiment cool. Envie d'expliquer comment ça "\(.+1).0"/""marche?
— seequ
Il n'y a rien de spécial, juste une interpolation de chaîne \(…) et une division / qui, en cas de chaîne , est divisée.
— manatwork
1

BBC BASIC, 89 88 87 octets

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

Utilisé des abréviations pour raccourcir autant que possible les choses. Compatible avec Brandy Basic et BASIC 2 sur la machine d'origine.

Pour les BBC BASIC modernes, vous pouvez également laisser de côté les numéros de ligne pour économiser deux octets supplémentaires.

— Darzzr
source
1

Dyalog APL , 12 octets

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

Essayez-le en ligne!

Simple: la {chaîne de fonctions '0.'avant ,la ⌽représentation ⍕de chaîne inversée de l'argument ⍵de la fonction }pour chacun ¨des nombres 1 à n ⍳ .

— Adam
source
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 sortie est le tableau appelé "o"

— xem
source
0

Groovy, 36 caractères

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

Exemple d'exécution:

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]
— homme au travail
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.