Вступ

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

EDIT : Я зробив бонус за правило 2 ^ 64-1, оскільки не було великого інтересу до цього виклику. Якщо ваша відповідь підтримує 2 ^ 64-1, тепер ви можете відредагувати її, щоб включити бонус. Також ви можете опублікувати відповідь, не підтримуючи її, якщо вона коротша.

MarioLANG , 29 байт

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

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

Я знаю, що мій код, на жаль, супер сумний або злий:

> :(

Щасливий MarioLANG, 46 байт

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

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

Щасливіший підхід:

 :)

Неемоційний MarioLANG, 41 байт

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

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

Піт, 1 байт

S

_{На корпусі повинно бути не менше 30 символів; ви ввели 14.}

Cjam, 5 байт

{,:)}

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

Це неназваний блок, який очікує nна стек і залишає список з діапазоном [1...n]на ньому.
Працює, просто будуючи діапазон з, ,а потім збільшуючи кожен елемент діапазону, :)щоб зробити діапазон одноосновним.

Математика, 5 байт

Range

Досить просто.

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

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

Або в розширеному форматі шестикутника:

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

Величезне спасибі Мартіну за те, що в основному придумав цю програму, я просто пограв у неї, щоб поміститися в боковій довжині 3 шестикутника.

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

У мене немає фантастичних програм, пов'язаних з шестикутниками Тімві, тому це пояснення не буде дуже яскравим. Натомість ви отримуєте для читання величезну частину тексту. Хіба це не приємно?

У будь-якому випадку, IP розпочинається у верхньому лівому куті, на $рухомому Сході, якщо ви уявляєте, що ця програма була розміщена на півночі вгору на карті. Це $змушує нас пропустити наступну інструкцію, яка б була @, яка закінчила б програму. Замість цього ми виконуємо, ?який встановлює поточний край пам'яті як вхідний номер. Тепер ми доходимо до кінця ряду, який веде нас до середнього ряду шестикутника, все ще рухаючись на схід.

Більшість решти програми - це цикл. Ми починаємо з того, .що є неоперативним. Далі ми стикаємося з виделкою в ... е ... шестикутник ... <інструкція змушує IP повертатися на 60 градусів вправо, якщо поточний край пам'яті позитивний, інакше ми повертаємо на 60 градусів ліворуч. Оскільки ми рухаємося на схід, ми або закінчуємо, щоб наш заголовок був Південь або Північний Схід. Оскільки вхідний показник більший за нуль (а отже, і позитивний), ми завжди починаємо з південного сходу.

Далі ми потрапляємо на a, >що перенаправляє нас на Схід; ці оператори розщелюються лише у випадку, якщо ви потрапили на частину вилки. Тоді ми натискаємо, 'яка змінює край пам'яті, який ми дивимось. Тоді ми потрапляємо на )який приріст значення поточного краю пам'яті. Оскільки всі краї пам’яті починаються з 0, перший раз, коли ми це робимо, ми отримуємо значення 1. Далі ми переходимо до другого верхнього рядка і виконуємо, !який виводить наше число. Потім переходимо до іншого краю з {і зберігаємо значення ASCII M, помножене на 10 плюс 8 (778). Потім ми стрибаємо назад до другої до останньої лінії шестикутника і натискаємо на /. Це призводить до того, що ми рухаємося на північний захід. Ми проходимо повз .середній ряд, і виходимо на;праворуч внизу. Це виводить поточний край пам'яті mod 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

роздільна відповідь на чистий баш, дивіться нижче ...

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, щоб побачити результат, оскільки я не хотів змусити вас чекати текстових полів.

До речі: Я був єдиним, хто не знав, що потрійні оператори настільки корисні в кодегольфі?

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

Введення зчитується зі stdin. Це відраховується від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 - ціль, а х - збільшена змінна) для тестування кінця циклу 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

Введення зчитується зі stdin. bcза замовчуванням обробляє довільні точні числа, тому 2 ^ 64 max не є проблемою.

Власне, 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

Орація, 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 до стека
• - відняти верхні елементи стека
• ! якщо truthy перейти до наступної команди @ припиняється
• ; вивести результат віднімання зі стека
• ) приріст верхньої частини стека
• wрухати ip вправо і продовжувати. Це призводить до переходу до наступного рядка
• O вивести верхню частину стека як число
• N підсунути подачу ліній (10) до стеку
• o вивести лінійку передач
• wрухати ip вправо і продовжувати. Це призводить до того, що він перепадає на наступне обличчя
• ! тому що TOS truthy, стрибайте @ термінал
• ; вискочити подачу ліній із стека
• Uповерніть ліворуч на -віднімання і продовжуйте звідти

Python 2, 37 33 32 33 bytes

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

Імовірно, працює 2**64і далі.

Збито чотири байти завдяки @dieter , а ще один завдяки @orlp . Але, мабуть, як з'ясувало @ Sp3000, range()можуть виникнути проблеми з більш високими значеннями, тому функцію було змінено наxrange() . Примітка: навіть xrange()можуть виникнути проблеми, принаймні в 2.7.10 .

Zsh, 12 байт

echo {1..$1}

Це працює, тому що змінні розширюються перед дужками.

V, 11 байт

é1@añYpñdd

Оскільки в ньому міститься неприємний UTF-8 та недруковані матеріали, ось такий оборотний шестигранник:

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

V - це незакінчена мова, про яку я писав, але це працює з початку 19 . Ця відповідь була трохи більш багатослівною, ніж я хотів би, але це здебільшого тому, що V не знає цілих чисел, лише рядки. Так що це гідна відповідь! Це буде працювати до 2 ^ 64, але, мабуть, це займе дуже багато багато часу.

Для того, щоб моє пояснення було легше читати / писати, я працюю з цією "читаною людиною формою", яка насправді є тим, як ви введете це in 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>кінець в кінці неявний, тому він нам не потрібен, якщо нам не доведеться видаляти останній рядок.