Выведите последовательность Ван дер Корпута

27

Последовательность Ван дер Корпута является одним из простейших примеров последовательности с низким расхождением . Его 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члены последовательности Ван-дер-Корпута. Выходной формат может быть списком чисел с плавающей запятой, списком строк формы 0.digitsили уникальной строкой, в которой термины разделены запятыми и / или пробелами, символами новой строки.

Стандартные лазейки запрещены. Самый короткий исходный код выигрывает.

code-golf  sequence 
— боб
источник

Ответы:

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.

— Аднан
источник
Вы имеете в виду Windows-1252?
— Исмаэль Мигель
@IsmaelMiguel То же самое
— Аднан,
Я знаю, но это обычно не распознается по имени CP-1252
— Исмаэль Мигель
Вам нужно было изменить свой язык для этой задачи?
— Андрей Савиных
@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;

Конкатенация '' к числу приводит к его преобразованию в строку. Это на 2 байта короче, чем при использовании TRIM (), что короче, чем TO_CHAR ().

Поскольку конкатенация строки с NUMBER приводит к строке, можно использовать эту строку для управления «0». часть результата.

— школа для водителей
источник
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.
}/
— Мартин Эндер
источник
7

Perl 6, 24 22 20 байт

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

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

старая версия

{("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)
— Клавиатурный
источник
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} *)
— njpipeorgan
источник
4

Pyth, 11 байт

m+"0."_`dSQ

Попробуй это здесь!

объяснение

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

m SQ # Сопоставить диапазон (1, Q) с ...
 + # ... объединение:
  "0." _ `D #" 0. " и обратный элемент
— Denker
источник
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
источник
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
— Луис Мендо
источник
3

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

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

Он принимает число в качестве ввода и выводит результат в STDOUT, разделенный пробелами.

Довольно просто. К сожалению, мы должны объединить число с пустой строкой, чтобы преобразовать это число в строку ( :""rc), потому что встроенного предиката преобразования пока нет.

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

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

Каждый раз в цикле мы просто создаем строковый литерал, который остается в конвейере и выводится соответствующим образом. Мы строим это из "0."конкатенации с результатом унарного -joinоператора, который воздействовал на массив символов, созданный из взятия строки "$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
— AdmBorkBork
источник
3

Баш, 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
— брезгливый оссифраж
источник
2
Если не чистый Bash в любом случае seq -f%g.0 $1|rev.
— manatwork
@ Manatwork Круто. Я не знал, seqможет сделать форматированный вывод.
— брезгливое оссифраж
3

пчелиный воск ,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!
— ML
источник
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())))
— mnel
источник
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']
— Эрвана
источник
Мое решение на Python было таким же, но я думаю, что f=это не обязательно, поэтому его длина составляет 47 байт.
— Боб
@Bob хорошо, я удалил это
— Эрван
Это выводит первые n-1термины.
— Seequ
@ Смотри, ты прав, я меняю решение, оно не меняет количество байтов
— Эрван
lambda n:['0.'+`i+1`[::-1]for i in range(n)]короче, если вы используете Python 2. Кроме того, вы не должны говорить «Python 3.5», если для него не требуется 3.5, а это не так. Эта версия требует Python 2.
— mbomb007
1

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

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

Try it here (Firefox only).

Все нормально.

объяснение

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

— Mama Fun Roll
источник
1

Python 2, 54 байта

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

Объяснение:

Итерация по набору [1,input)и добавление обратного iк. .

Еще можно играть в гольф больше.

— intboolstring
источник
Используйте `i`вместо str(i). Кроме того, я думаю, что вам нужно напечатать ведущий ноль.
— mbomb007
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 байта путем объединения строки перед обращением
— aross
источник
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
— manatwork
источник
1

Юлия ,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"
— ML
источник
1
31 байт:n->["0."reverse("$i")for i=1:n]
— Алекс А.
1
Кстати, вы можете запросить объединение вашего профиля со старым здесь .
— Алекс А.
Очень круто, не знал этого. Благодарность!
— ML
@AlexA. сама анонимная функция ничего не выводит. Разве более длинная версия, подобная map(n->["0."reverse("$i")for i=1:n],3)(для n = 3), не будет необходима для получения какого-либо вывода? Это сделало бы это (по крайней мере) так долго, как мое решение.
— ML
1
Для анонимной функции вы просто добавляете условие, что для ее вызова необходимо присвоить ее переменной. Сохраняет два байта над именованной функцией и соответствует нашим правилам.
— Алекс А.
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
источник
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("")
— manatwork
источник
JQ действительно круто. Ум объяснил, как "\(.+1).0"/""работает?
— Seequ
Здесь нет ничего особенного, только интерполяция строк \(…) и деление / , которое в случае строк разделяется.
— Манатворк
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 вы также можете не указывать номера строк, чтобы сохранить еще два байта.

— Darzzr
источник
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
источник
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]
— manatwork
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.