输出范德Corput序列

27

的DER Corput序列面包车是最简单的实例中的一个低差异序列。它的n-th项是just 0.(n written in base 10 and mirrored)，所以它的第一个项是：

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

挑战

用任何编程语言编写一个程序或函数，该程序或函数将n小于的正整数作为输入10^6并返回或打印nvan der Corput序列的第一项。输出格式可以是浮点数列表，形式的字符串列表0.digits或唯一的字符串，其中的术语用逗号和/或空格，换行符分隔。

禁止出现标准漏洞。最短的源代码获胜。

code-golf  sequence 
— 鲍勃
source

Answers:

16

05AB1E，6个字节

码：

>GNÞR,

在线尝试！

说明：

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

使用CP-1252编码。

— 阿德南
source
您是说Windows-1252？
— Ismael Miguel
@IsmaelMiguel 一样
— Adnan
我知道，但是通常不会以CP-1252这个名字来识别
— Ismael Miguel
您是否需要为此挑战修改语言？
— Andrew Savinykh'2
@AndrewSavinykh不，这被认为是作弊行为，不允许在此站点上使用。它与7.3版一起使用，该版本在发布此挑战之前已发布。
— 阿德南
8

的Oracle SQL 11.2 64个 62 58字节

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

旧版 

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

将''与数字连接将其转换为字符串。它比使用TRIM（）短2个字节，而使用TRIM（）短于TO_CHAR（）。

由于将字符串连接到NUMBER会得到一个字符串，因此可以使用该字符串来管理“ 0”。结果的一部分。

— 杰托
source
7

CJam，14 11个字节

感谢Sp3000节省了3个字节。

ri{)d`W%S}/

在这里测试。

说明

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.
}/
— 马丁·恩德
source
7

Perl 6中，24个 22 20字节

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

感谢Aleks-Daniel Jakimenko-A。再再两个字节

旧版

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

编辑：感谢raiph额外的2个字节

用法

> 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)
— 热键
source
1
{("0."~.flip for ^$_)}保存2个字节
— raiph
6

Mathematica，40个字节

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

测试用例

%[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} *)
— 新泽西州
source
4

Pyth，11个字节

m+"0."_`dSQ

在这里尝试！

说明

m +“ 0。” _`dSQ＃Q =输入

m SQ＃将范围（1，Q）映射到...
 +＃...的串联：
  “ 0。” _`d＃“ 0.” 和反向元素
— 登克
source
4

JavaScript（ES6），58

匿名函数返回带有逗号分隔值的字符串

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

测试

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

MATL，10字节

:"'0.'@VPh

在线尝试！

:          % 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
— 路易斯·门多
source
4

Haskell，36个，27个字节

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

nimi保存了两个字节，Lynn另外保存了7个字节。

— 迈克尔·克莱因
source
f n=reverse.show<$>[1.0..n]
— 林恩
3

Brachylog，23个字节

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

它以数字作为输入，并将结果输出到STDOUT，以空格分隔。

非常坦率的。不幸的是:""rc，由于没有内置的转换谓词，我们必须将数字与空字符串连接起来才能将该数字转换为字符串（）。

转换为字符串是必要的，因为如果我们反转数字的位数，那么前导零（例如10变为01）将丢失。

— 致命
source
3

PowerShell，52个字节

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

比我想要的时间长一点，但是使用了一些巧妙的技巧。

该while循环是显而易见的，但条件是有点棘手-我们有$a（该程序可以$null在第一次引用），然后减去我们的输入数量$args[0]。在PowerShell中，$null对它的数学运算将其视为零，因此对于输入20，例如，结果为-20。由于任何非零数字都是$true，所以循环条件将一直$true向上直到$a等于我们的输入数字（此时减法将等于0或$false）。诀窍来自于post-increment ++，直到计算出减法后才执行，因此处理的输入1将正确输出0.1，然后在下一次迭代中停止循环。

每次循环时，我们只创建一个字符串常量，该常量将保留在管道中并相应地输出。我们"0."将其与一元运算-join符的结果连接起来构造，该运算符作用于将字符串"$a"倒退（通过range进行索引"$a".length..0）而创建的char数组。

测试运行

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个字节

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

以数字作为命令行参数，并在单独的行上输出每个术语。例如：

$ ./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
— 吱吱作响的骨
source
2
如果不是纯Bash ：seq -f%g.0 $1|rev。
— manatwork '16
@manatwork很酷。我不知道seq可以做格式化输出。
— 吱吱作响的ossifrage
3

Japt，12个字节

Uò1 ®+".0" w

在线测试！

怎么运行的

           // 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
— ETH生产
source
3

蜂蜡，57 53个字节

在处理Rosettacode的二进制数字输出问题时，我注意到我可以对van der Corput序列使用相同的短除法算法，仅对10除以2即可得到除法和取模。在两种情况下，输出都是相反的。

通过镜像代码减少4个字节：

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

六边形漂亮打印图，便于定位：

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

使用原始代码解释程序的一个循环：

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

例：

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字节

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

说明

example(strsplit)创建函数strReverse（然后应该很明显）

使用IRanges::reverse，这可以达到47个字节

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

Python 3，47个字节

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

Python 2更短的解决方案

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

测试用例

>>> 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']
— 二湾
source
我的Python解决方案是相同的，但我认为这f=不是必需的，因此它的长度为47个字节。
— 鲍勃，
@Bob确定我删除它
— 二万
这将输出第一n-1项。
— seequ 2016年
@Seeq你是对的，我改变了解决方案，它没有改变字节数
— Erwan
lambda n:['0.'+`i+1`[::-1]for i in range(n)]如果使用Python 2，它会更短一些。此外，除非“ Python 3.5”需要3.5，否则就不要说“ Python 3.5”。这个版本需要Python 2
— mbomb007
1

𝔼𝕊𝕄𝕚𝕟，12个字符/ 15个字节

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

Try it here (Firefox only).

没关系。

说明

⩤⁽1ï⒨创建[1,ï]要映射的范围，ß)将mapitem（数字）转换为字符串，并Ė⍞.0连接.0到末尾，然后ᴙ反转整个字符串。

— 妈妈趣味卷
source
1

Python 2，54字节

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

说明：

遍历集合[1,input)，并将反向添加i到.。

还有更多的打高尔夫球。

— 内弦
source
使用`i`代替str(i)。另外，我认为您需要打印前导零。
— mbomb007 '16
1

PHP，45 41字节

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

从CLI获取输入参数。像这样运行：

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100
  • 通过在反转之前串联字符串节省了3个字节
— ros
source
1

Gema，45个字符

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

样品运行：

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
— 工作的人
source
1

朱莉娅，50 38 33 31个字节

我选择了一种不同的输出格式，以将代码缩短12个字节。该函数现在返回一个字符串数组。再缩短5个字节。感谢Alex A.使我想起了字符串插值并使用了匿名函数（摆脱了另外2个字节）。

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

或者

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

测试

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个字节：n->["0."reverse("$i")for i=1:n]
— Alex A.
1
顺便说一句，您可以在此处请求将您的个人资料与旧个人资料合并。
— Alex A.
很酷，不知道。谢谢！
— ML
@AlexA。匿名函数本身不输出任何内容。要map(n->["0."reverse("$i")for i=1:n],3)生成任何输出，是否不需要更长的版本（对于n = 3）？这将使其（至少）与我的解决方案一样长。
— ML
1
对于匿名函数，只需添加规定即可调用它，必须将其分配给变量。在命名函数上保存两个字节，并且符合我们的规则。
— Alex A.
1

Python 2，40个字节

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

例：

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

代数求解：

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个字符

（34个字符的代码+ 1个字符的命令行选项。）

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

样品运行：

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

在线测试（-r不支持通过URL 传递-自己检查Raw Output。）

与文档链接相同：

范围（。）| “ \（。+ 1 ） .0” / “” | 反向 | 加

作为一种更具可读性的选择，上面的代码也可以这样写（在线）：

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")
— 工作的人
source
jq真的很酷。介意解释如何"\(.+1).0"/""运作？
— seequ '16
没什么特别的，只是一个字符串插值 \(…)和一个除法 /（在字符串的情况下会被分割）。
— manatwork '16
1

BBC BASIC，89 88 87字节

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

使用缩写来尽可能缩短内容。与原始计算机上的Brandy Basic和BASIC 2兼容。

对于现代BBC BASIC，您也可以省略行号以节省更多的两个字节。

— 达兹
source
1

Dyalog APL，12个字节

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

在线尝试！

直截了当：对于数字1到n，每个函数的参数的反向字符串表示形式之前的函数{字符串。'0.',⌽⍕⍵}¨ ⍳

— 亚当
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

输出是称为“ o”的数组

— Xem
source
0

Groovy，36个字符

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

样品运行：

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]
— 工作的人
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.