Введение

Это может звучать странно, но у нас нет ОДНОЙ задачи для подсчета от 1до n, включительно.

Это не одно и то же. Это один (закрытый) плохо объясненный вызов.
Это не одно и то же. Это о подсчете до бесконечности.

Вызов

Написать программу или функцию , которая печатает каждое целое число от 1до nвключительно.

правила

• Вы можете получить nлюбым способом.
• Вы можете предположить, что nэто всегда будет положительное целое число.
• Вы можете получить nв любой базе, но вы должны всегда выводить в десятичном виде.
• Вывод должен быть отделен любым символом (или шаблоном), не входящим в 0123456789. Допускаются недесятичные начальные или конечные символы (например, при использовании таких массивов, как [1, 2, 3, 4, 5, 6]).
• Стандартные лазейки запрещены.
• Мы хотим найти кратчайший подход к каждому языку, а не самый короткий, поэтому я не приму ответа.
• Вы должны обновить свой ответ (ы) после этого редактирования, ответы, опубликованные до последнего редактирования, должны соответствовать правилу изменения стандартных лазеек (я не хотел их отрицать, но я не хотел, чтобы сообщество ревело, поэтому Я их отрицал).
• Вы можете использовать любую версию языка пост-знакомства (или язык). Вы не можете использовать какой-либо язык или языковую версию, созданную только для этого вызова.

Бонусы

20%

• Ваша программа должна иметь возможность рассчитывать как минимум до 18446744073709551615( 2^64-1). Например, если новый тип данных является единственным способом поддержки больших целых чисел, вы должны создать его. Если ваш язык не имеет возможности поддерживать огромные целые числа до 2 ^ 64-1, вместо этого должен поддерживаться верхний предел этого конкретного языка.

EDIT : Я изменил предел от 2^64до , 2^64-1чтобы больше ответов.

РЕДАКТИРОВАТЬ : я сделал правило 2 ^ 64-1 бонус, так как не было большого интереса к этому испытанию. Если ваш ответ поддерживает 2 ^ 64-1, вы можете отредактировать его, чтобы включить бонус. Также вы можете опубликовать ответ, не поддерживающий его, если он короче.

MarioLANG , 29 байт

;
)    <
+===="
>:(-[!
=====#

Попробуйте онлайн!

Я знаю, что мой код, к сожалению, супер-грустный или злой:

> :(

Happy MarioLANG, 46 байтов

;
)       <
+======="
>  >((-[!
=:)^====#
 ===

Попробуйте онлайн!

Более счастливый подход:

 :)

Неэмоциональный MarioLANG, 41 байт

;
)     <
+====="
> >(-[!
= "===#
 :!
 =#

Попробуйте онлайн!

Pyth, 1 байт

S

_{Тело должно быть не менее 30 символов; Вы вошли 14.}

Cjam, 5 байтов

{,:)}

Попробуйте онлайн!

Это неназванный блок, который ожидает nв стеке и оставляет список с диапазоном [1...n]в нем.
Работает, просто создав диапазон с помощью, ,а затем увеличивая каждый элемент диапазона, :)чтобы сделать диапазон единым.

Mathematica, 5 байтов

Range

Достаточно просто.

Гексагония, 19

$@?!{M8.</(=/>').$;

Или в расширенном формате шестиугольника:

  $ @ ?
 ! { M 8
. < / ( =
 / > ' ) 
  . $ ;

Огромное спасибо Мартину за то, что он в основном придумал эту программу, я просто сыграл ее в гольф, чтобы уместить его в шестиугольнике с длиной стороны 3.

Попробуйте онлайн!

У меня нет фантастических программ Тимви, связанных с Hexagony, поэтому это объяснение не будет очень ярким. Вместо этого вы можете прочитать огромный текстовый блок. Разве это не мило?

В любом случае, IP начинается в верхнем левом углу, на $востоке, если вы представляете, что эта программа была размещена севером вверх на карте. $Заставляет нас пропустить следующую команду, которая была бы @, что бы закончить программу. Вместо этого мы выполняем, ?который устанавливает текущий край памяти в качестве входного числа. Теперь мы достигаем конца ряда, который ведет нас к среднему ряду шестиугольника, все еще двигаясь на восток.

Большая часть остальной части программы представляет собой цикл. Начнем с того, .что это неоперация. Затем мы сталкиваемся с разветвлением в ... э-э ... шестиугольнике ... <инструкция заставляет IP поворачиваться на 60 градусов вправо, если текущий край памяти положительный, в противном случае мы поворачиваем на 60 градусов влево. Поскольку мы движемся на восток, мы в конечном итоге либо идем на юг, либо на северо-восток. Поскольку входное значение больше нуля (и, следовательно, положительное), мы всегда начинаем с юго-востока.

Затем мы ударяем о, >который перенаправляет нас на восток; эти операторы только разветвляются, если вы нажмете часть разветвления. Затем мы нажимаем, 'что меняет то, на какой край памяти мы смотрим. Затем мы нажимаем, )что увеличивает значение текущего края памяти. Так как все края памяти начинаются с 0, в первый раз, когда мы делаем это, мы получаем значение 1. Затем мы переходим к строке со второй на верхнюю и выполняем, !которая выводит наш номер. Затем мы переходим к другому ребру {и сохраняем значение M в ASCII, умноженное на 10 плюс 8 (778). Затем мы возвращаемся ко второй и последней строке шестиугольника и нажимаем /. Это приводит нас к перемещению на северо-запад. Мы проходим мимо в .среднем ряду, и выходим на;внизу справа. Это распечатывает текущий край памяти мод 256 как ASCII. Это происходит с новой строки. Мы нажимаем, 'что возвращает нас к первому краю, в котором есть значение, которое мы прочитали. Мы нажимаем, /что заставляет нас снова двигаться на восток. Затем мы нажимаем, (что уменьшает значение. =заставляет нас снова повернуть в правильном направлении для будущих прыжков по краям памяти.

Теперь, поскольку значение положительное (если оно не равно нулю), мы возвращаемся к нижней части шестиугольника. Здесь мы нажимаем, .затем перепрыгиваем, ;чтобы ничего не происходило, и мы возвращаемся к началу цикла. Когда значение равно нулю, мы возвращаемся к началу программы, где то же самое происходит снова, но ?не может найти другое число, и мы выбираем другой путь ветвления. Этот путь относительно прост: мы нажимаем, {который меняет край памяти, но нам уже все равно, тогда мы нажимаем, @который завершает программу.

MATL, 1 байт

:

Пример вывода:

15
1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Попробуйте онлайн здесь

GNU Coreutils, 6 байтов

seq $1

разделенный ответ на чистый bash, см. ниже ...

R 13 байт

cat(1:scan())

Тело должно быть не менее 30 символов.

Javascript 182 177 160 154 139 138 132 байт (действительный)

1 байт сохранен благодаря @ShaunH

n=>{c=[e=0];for(;c.join``!=n;){a=c.length-1;c[a]++;for(;a+1;a--){c[a]+=e;e=0;if(c[a]>9)c[a]=0,e++;}e&&c.unshift(1);alert(c.join``)}}

Арбитражная точность на помощь!

Поскольку javascript может рассчитывать только до 2 ^ 53-1 (спасибо @ MartinBüttner за указание на это), мне нужно было создать произвольную точность, чтобы сделать это. Он хранит данные в массиве, и каждый «тик» добавляет 1 к последнему элементу, затем проходит через массив, и если что-то превышает 9, он устанавливает этот элемент в 0 и добавляет 1 к элементу слева.

Попробуй это здесь! Примечание: нажмите F12, чтобы увидеть результат, так как я не хотел заставлять вас ждать текстовых полей.

Кстати: я был единственным, кто не знал, троичные операторы так полезны в Codegolf?

if(statement)executeSomething();

длиннее чем

statement?executeSomething():0;

на 1 байт.

Javascript, 28 байт (неверно - не может сосчитать до 2 ⁶⁴ )

n=>{for(i=0;i++<n;)alert(i)}

Java 8, 43/69/94 байта

^{_{Вычеркнутый 44 - все еще обычный 44 - подождите, я не вычеркнул это, я только заменил это :(}}

Если я могу вернуть LongStream: ( 43 bytes)

n->java.util.stream.LongStream.range(1,n+1)

Это лямбда для Function<Long,LongStream>. Технически, я должен использовать rangeClosedвместо range, так как я отсекаю один из моего максимального ввода таким образом, но rangeClosedдольше, чем range.

Если я должен напечатать в функции: ( 69 bytes)

n->java.util.stream.LongStream.range(1,n+1).peek(System.out::println)

Это лямбда для Consumer<Long>. Технически я злоупотребляю peek, поскольку это промежуточная операция , означающая, что эта лямбда технически возвращает LongStreamаналогично первому примеру; Я должен использовать forEachвместо этого. Опять же, гольф не хороший код.

К сожалению, так как longдиапазон «S является подписанным 64-разрядным целым числом, не доходит до запрашиваемого 2^64-1, а просто 2^63-1.

Однако Java SE 8 предоставляет функциональные возможности для обработки longs, как если бы они были без знака, путем Longявного вызова определенных методов класса. К сожалению, поскольку Java по-прежнему является Java, она довольно многословна, хотя и короче, чем версия BigInteger, которую она заменяет. ( 94 bytes)

n->{for(long i=0;Long.compareUnsigned(i,n)<0;)System.out.println(Long.toUnsignedString(++i));}

Это Consumer<Long>, как и предыдущий.

^{_{И слишком долго, чтобы избежать прокрутки.}}

05AB1E , 1 байт

Код:

L

Попробуйте онлайн! ,

Более интересный подход:

FN>,

Объяснение:

F     # For N in range(0, input):
 N>   #   Push N + 1
   ,  #   Pop and print with a newline

Попробуйте онлайн! ,

MATLAB, 7 байтов

Безымянная анонимная функция:

@(n)1:n

Беги как:

ans(10)
ans =
     1     2     3     4     5     6     7     8     9    10

Проверьте это здесь!

Если требуется полная программа, 17 байт:

disp(1:input(''))
10
     1     2     3     4     5     6     7     8     9    10

Проверьте это здесь!

Haskell, 10 байт

f n=[1..n]

Пример использования: f 4-> [1,2,3,4].

MarioLANG , 19 байтов

;
)<
+"
:[
(-
>!
=#

Попробуйте онлайн!

Вертикальные программы, как правило, более удобны для игры в простые петли в MarioLANG. Я не уверен что интерпретатор делает, когда встречается [внутри лифта, но он, кажется, завершает программу, когда текущая ячейка равна 0. Это, вероятно, полезный трюк в целом.

объяснение

MarioLANG - это язык, похожий на Brainfuck (с бесконечной лентой памяти целых чисел произвольной точности), где указатель инструкций напоминает ходьбу и прыжок Марио.

Марио начинается в левом верхнем углу и падает вниз. ;читает целое число из STDIN и помещает его в текущую ячейку памяти. Теперь обратите внимание , что =является основанием для сотового Марио ходить дальше, "и #сформировать лифт (с #являющийся началом) и !делает Марио остановку на лифте , так что он не ходит покинуть сразу. >И <установить его направление движения. Мы видим, что это дает простой цикл, содержащий следующий код:

)   Move memory pointer one cell right.
+   Increment (initially zero).
:   Print as integer, followed by a space.
(   Move memory pointer one cell left.
-   Decrement.
[   Conditional, see below.

Теперь обычно [Марио условно пропускает следующее в зависимости от того, равна ли текущая ячейка нулю или нет. То есть, пока счетчик ненулевой, это ничего не делает. Тем не менее, кажется, что, когда Марио встречается во [время поездки на лифте, а текущая ячейка есть 0, программа просто немедленно завершает работу с ошибкой, что означает, что нам даже не нужно искать способ его перенаправить правильно.

Джо - 2 или 6

Пока вы можете использовать инклюзивный вариант функции диапазона.

1R

..это скучно! Давайте вместо этого возьмем кумулятивную сумму ( \/+) таблицы форм n ( 1~T).

\/+1~T

Pyth - 3 2 байта

1 байт сохранен благодаря @DenkerAffe.

Без использования встроенного.

hM

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

Пайк, 1 байт

S

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

Или 2 байта без встроенного

mh

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

#h

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

Lh

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

дк, 15

?[d1-d1<m]dsmxf

Ввод читать из стандартного ввода. Это отсчитывает от n, толкая копию каждого числа в стек. Стек выводится как единое целое сf команды, поэтому числа печатаются в правильном порядке возрастания.

Поскольку все числа помещаются в стек, весьма вероятно, что в памяти не хватит памяти, прежде чем приблизиться к 2 ^ 64. Если это проблема, то мы можем сделать это вместо этого:

дк, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 байт

IT'S SHOWTIME
HEY CHRISTMAS TREE n
YOU SET US UP 0
GET YOUR ASS TO MARS n
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE x
YOU SET US UP n
STICK AROUND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
GET UP 1
ENOUGH TALK
TALK TO THE HAND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

Единственное, что нас интересует, - это использовать nx (где n - это цель, а x - увеличенную переменную), чтобы проверить конец цикла while, вместо того, чтобы иметь выделенную переменную, поэтому я в итоге получаю nx и n- (nx) = x в каждом цикле

Примечание : я могу рассчитывать только до 2 ^ 31-1. Ну, я думаю, что терминаторы не представляют реальной опасности в конце концов.

Пит, 64 Кодекса

С размером кода 20:

Npiet след изображения

Первый цикл:

Оставшийся след для n=2:

Заметки

• Пита нет ответа? Позвольте мне исправить это с моей первой в мире программой Пиет! Это может быть короче с лучшими бросками и меньшими манипуляциями с указателями ...

• Верхний поддерживаемый предел зависит от реализации интерпретатора. Теоретически было бы возможно поддержать произвольно большие числа с правильным интерпретатором.

• Делиметр ETX(Ascii 3), однако это не может быть правильно отображено в этом ответе, поэтому я просто опущу их. Работает в консоли:

Выход

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet след для n=2

trace: step 0  (0,0/r,l nR -> 1,0/r,l lB):
action: in(number)
? 2
trace: stack (1 values): 2

trace: step 1  (1,0/r,l lB -> 2,0/r,l nB):
action: push, value 1
trace: stack (2 values): 1 2

trace: step 2  (2,0/r,l nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 1 1 2

trace: step 3  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
1
trace: stack (2 values): 1 2

trace: step 4  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 1 2

trace: step 5  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 2 2

trace: step 6  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 7  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 2 2 2

trace: step 8  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 2 2 2

trace: step 9  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 2 2

trace: step 10  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 2 2

trace: step 11  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 2 2

trace: step 12  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 2 2

trace: step 13  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 2 2 2

trace: step 14  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 0 2 2

trace: step 15  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 0 2 2

trace: step 16  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 0 2 2

trace: step 17  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 2

trace: step 18  (9,1/l,r nY -> 7,1/l,r dY):
action: push, value 2
trace: stack (3 values): 2 2 2

trace: step 19  (7,1/l,r dY -> 6,1/l,r lY):
action: push, value 1
trace: stack (4 values): 1 2 2 2

trace: step 20  (6,1/l,r lY -> 5,1/l,r nM):
action: roll
trace: stack (2 values): 2 2

trace: step 21  (5,1/l,r nM -> 4,1/l,r dM):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 22  (4,1/l,r dM -> 3,1/l,r lG):
action: pointer
trace: stack (2 values): 2 2

trace: step 23  (3,1/d,r lG -> 2,3/l,l nG):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 24  (2,3/l,l nG -> 2,2/u,r lY):
action: out(char)

trace: stack (2 values): 2 2
trace: white cell(s) crossed - continuing with no command at 2,0...

trace: step 25  (2,2/u,r lY -> 2,0/u,r nB):

trace: step 26  (2,0/u,r nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 27  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
2
trace: stack (2 values): 2 2

trace: step 28  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 2 2

trace: step 29  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 3 2

trace: step 30  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 3 3 2

trace: step 31  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 3 3 2

trace: step 32  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 3 3 2

trace: step 33  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 3 3

trace: step 34  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 3 3

trace: step 35  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 3 3

trace: step 36  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 3 3

trace: step 37  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 3 2 3

trace: step 38  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 1 2 3

trace: step 39  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 1 2 3

trace: step 40  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 3 2 3

trace: step 41  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 3
trace: white cell(s) crossed - continuing with no command at 9,3...

trace: step 42  (9,1/d,r nY -> 9,3/d,l nR):

JavaScript (ES6), 77 76 63 59 58 байт

n=>{for(s=a=b=0;s!=n;console.log(s=[a]+b))a+=!(b=++b%1e9)}

Принимает ввод nв виде строки, должен поддерживать до 9007199254740991999999999

Разъяснение:

n=>{ //create function, takes n as input
    for( //setup for loop
        s=a=b=0; //init s, a, and b to 0
        s!=n; //before each cycle check if s!=n
        console.log(s=[a]+b) //after each cycle concat a and b into to s and print
    )
        a+=!(b=++b%1e9) //During each cycle set b to (b+1)mod 1e9, if b == 0 and increment a
} //Wrap it all up

GNU bc, 23

n=read()
for(;i++<n;)i

Ввод читать из стандартного ввода. bcпо умолчанию обрабатывает числа произвольной точности, так что максимум 2 ^ 64 не проблема.

На самом деле, 1 байт

R

Скучно встроено скучно. Требуется 64-битная версия Python 3, чтобы получить все до 2**64.

Попробуйте онлайн!(из-за ограничений по памяти и длине вывода, онлайн-переводчик не может идти очень высоко).

Вот 5-байтовая версия, которая не требует 64-битного Python 3 и немного лучше использует память:

W;DWX

Попробуйте онлайн! (см. выше предостережения)

Fuzzy-Octo-Guacamole, 7 байтов

^!_[+X]

Объяснение:

^ get input to ToS
! set for loop to ToS
_ pop
[ start for loop
+ increment ToS (which aparently happens to be 0)
X print ToS
] end for loop

Oration, 31 байт (не конкурирует)

literally, print range(input())

QBASIC, 43 байта

1 INPUT a
2 FOR b=1 TO a
3 PRINT b
4 NEXT b

Cubix , 17 байтов

..U;I0-!@;)wONow!

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

Cubix - это двумерный язык, созданный @ETHProductions, где команды помещаются в куб. Эта программа переносится на куб с длиной ребра 2 следующим образом.

    . .
    U ;
I 0 - ! @ ; ) w
O N o w ! . . .
    . .
    . .

• I получает целочисленный ввод
• 0 положить 0 в стек
• - вычесть верхние элементы стека
• !если верный прыжок, следующая команда @завершится
• ; вытолкнуть результат вычитания из стека
• ) увеличение вершины стека
• wпереместите IP вправо и продолжайте. Это вызывает его падение на следующую строку
• O вывести вершину стека в виде числа
• N вставьте перевод строки (10) в стек
• o вывести перевод строки
• wпереместите IP вправо и продолжайте. Это заставляет это падать к следующему лицу
• ! потому что правдиво прыгать @ прекратить
• ; вытолкнуть перевод строки из стека
• Uповернуть налево на -вычитание и продолжить оттуда

Python 2, 37 33 32 33 байта

for i in xrange(input()):print-~i

Предположительно работает до 2**64и за пределами.

Сбросил четыре байта благодаря @dieter , и еще один благодаря @orlp . Но, очевидно, как выяснил @ Sp3000, range()могут быть проблемы с более высокими значениями, поэтому функция была изменена наxrange() . Примечание: даже xrange()могут возникнуть проблемы, по крайней мере, в 2.7.10 .

Зш, 12 байт

echo {1..$1}

Это работает, потому что переменные раскрываются перед фигурными скобками.

V 11 байт

é1@añYpñdd

Так как он содержит неприятный UTF-8 и непечатаемые, вот обратимый hexdump:

00000000: e931 4061 f159 7001 f164 64              .1@a.Yp..dd

V - незаконченный язык, который я написал, но он работает с коммита 19 . Этот ответ был немного более подробным, чем мне хотелось бы, но в основном потому, что V не знает целых чисел, только строки. Так что это достойный ответ! Это будет работать до 2 ^ 64, но это, вероятно, займет очень много времени.

Чтобы облегчить чтение / запись моего объяснения, я поработаю с этой «удобочитаемой для человека формой», которая, собственно, и будет введена в vim.

<A-i>1@a<A-q>Yp<C-a><A-q>dd

Объяснение:

'Implicit: register "a" == arg 1, and any generated text is printed. 

<A-i>1                       'Insert a single character: "1"
      @a                     ' "a" times, 
        <A-q>       <A-q>    'Repeat the following:
             Yp<C-a>         'Duplicate the line, and increment it
                         dd  'Delete the last line, since we have one too many.

Если разрешены лазейки, вот более короткая версия, которая печатает от 1 до n, но также печатает 0 (8 байт):

é0@añYp

И в читабельном виде:

<A-i>1@a<A-q>Yp<C-a>

Это короче, потому что <A-q>в конце неявно, поэтому нам это не нужно, если нам не нужно удалять последнюю строку.