Послідовність van der Corput - один з найпростіших прикладів послідовності з низькою невідповідністю . Його nтермін є справедливим 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і повертає або друкує перші nумови послідовності van der Corput. Формат виводу може бути списком чисел з плаваючою комою, списком рядків форми 0.digitsабо унікальним рядком, де умови розділені комами та / або пробілами, новими рядками.

Стандартні лазівки заборонені. Виграє найкоротший вихідний код.

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.

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;

Об'єднання "" в число перетворює його на рядок. Це на 2 байти коротше, ніж використання TRIM (), що коротше, ніж TO_CHAR ().

Оскільки об'єднання рядка з NUMBER призводить до рядка, можна використовувати цей рядок для управління знаком "0." частина результату.

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.
}/

Perl 6, 24 22 20 байт

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

Спасибі Алекс-Даніель Якименко-А. ще два байти

стара версія

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

EDIT: Дякую 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)

Математика, 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} *)

Pyth, 8 байт

m_`cd1SQ

Спробуйте в Інтернеті.

Це дійсно просто поєднання цього та цієї відповіді. Тому я роблю це вікі спільноти.

Pyth, 11 байт

m+"0."_`dSQ

Спробуйте тут!

Пояснення

m + "0." _ `dSQ # Q = вхід

м SQ # Зобразіть діапазон (1, Q) до ...
 + # ... з'єднання:
  "0." _ `D #" 0. " і зворотний елемент

Pyth - 10 байт

_M+R".0"SQ

Спробуйте його онлайн тут .

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>

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

Haskell, 36 , 27 байт

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

Два байти, збережені німі, а ще 7 - Лінн.

Брахілог , 23 байти

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

Це приймає число як вхід і виводить результат в STDOUT, розділене пробілами.

Досить прямолінійний. На жаль, нам доведеться поєднати число з порожнім рядком, щоб перетворити це число в рядок ( :""rc), оскільки ще немає вбудованого предиката перетворення.

Перетворення в рядок є необхідним, оскільки якщо ми перевернемо цифри числа, то провідні нулі (наприклад, 10стає 01) будуть втрачені.

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). Хитрість походить від постинкрементом ++, яка не буде виконуватися до тих пір , після вирахування обчислюється, тому обробка введення 1правильно виведення , 0.1а потім зупинити петлю на наступній ітерації.

Кожен раз у циклі ми просто створюємо літеральний рядок, який залишається на конвеєрі та виводиться відповідно. Ми будуємо це з "0."об'єднаного з результатом одинарного -joinоператора, який діяв на масив char, створений з прийняття рядка "$a"назад (шляхом індексації через діапазон "$a".length..0).

Виконання тестів

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

Баш, 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

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

бджолиний віск ,57 53 байти

Працюючи над проблемою виводу двійкового розряду для розеткода, я помітив, що я можу використовувати один і той же алгоритм короткого поділу для послідовності ван дер Корпута, просто використовуючи поділ і модуль на 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!

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())))

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

𝔼𝕊𝕄𝕚𝕟, 12 символів / 15 байт

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

Try it here (Firefox only).

Все добре.

Пояснення

⩤⁽1ï⒨створює діапазон [1,ï]для відображення, ß)перетворює mapitem (число) у рядок, Ė⍞.0стискається .0до кінця і ᴙперевертає весь рядок.

Пітон 2, 54 байти

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

Пояснення:

Ітерація через набір [1,input)і додає зворотну сторону iдо ..

Все-таки гольф більше.

PHP, 45 41 байт

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

Бере вхідний аргумент від CLI. Бігайте так:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100

• Збережено 3 байти шляхом об'єднання рядка перед тим, як повернути його назад

Сітківка, 39 байт

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

Здійснює введення в одинаковому режимі.

Спробуйте його онлайн тут.

Гема, 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 

Юлія ,50 38 33 31 байт

Я пішов на інший вихідний формат, щоб скоротити код на 12 байт. Функція повертає масив рядків зараз. Скорочено на ще 5 байт. Дякую Алексу А. за те, що він нагадав мені про інтерполяцію рядків та використання анонімної функції (позбувшись ще 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"

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]

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

On-line тест (Введення -rURL-адреси не підтримується - перевірте Raw Output.)

Те саме з посиланнями на документацію:

дальність ( . ) | " \ ( . + 1 ) .0" / "" | зворотний | додати

Як більш читану альтернативу, вищезазначене також може бути написане так ( он-лайн ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")

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 можна також залишити номер рядків, щоб зберегти ще два байти.

Діалог APL , 12 байт

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

Спробуйте в Інтернеті!

Прямо вперед: функціональний {рядок '0.'перед ,зворотним ⌽рядком-представлення ⍕аргументу ⍵функції }для кожного ¨з чисел 1 по n ⍳ .

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"

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]