Giới thiệu

Nghe có vẻ lạ, nhưng chúng tôi đã không có ONE thách thức đối với tính từ 1để n, toàn diện.

Đây không phải là điều tương tự. Đó là một thách thức (đóng) không được giải thích rõ.
Đây không phải là điều tương tự. Đó là về việc đếm lên vô thời hạn.

Thử thách

Viết một chương trình hoặc chức năng in tất cả các số nguyên từ 1để ntoàn diện.

Quy tắc

• Bạn có thể nhận được nbất kỳ cách nào.
• Bạn có thể cho rằng đó nsẽ luôn là một số nguyên dương.
• Bạn có thể nhận được ntrong bất kỳ cơ sở nào, nhưng bạn phải luôn xuất ra số thập phân.
• Đầu ra phải được phân tách bằng bất kỳ ký tự (hoặc mẫu) không có trong 0123456789. Các ký tự hàng đầu hoặc dấu thập phân không được phép (ví dụ: khi sử dụng các mảng như [1, 2, 3, 4, 5, 6]).
• Sơ hở tiêu chuẩn bị từ chối.
• Chúng tôi muốn tìm cách tiếp cận ngắn nhất trong mỗi ngôn ngữ, không phải ngôn ngữ ngắn nhất, vì vậy tôi sẽ không chấp nhận bất kỳ câu trả lời nào.
• Bạn phải cập nhật (các) câu trả lời của mình sau lần chỉnh sửa này, các câu trả lời được đăng trước lần chỉnh sửa cuối cùng phải tuân thủ quy tắc thay đổi về các sơ hở tiêu chuẩn (tôi không muốn từ chối chúng, nhưng tôi không muốn làm cho cộng đồng gầm lên, vì vậy Tôi đã từ chối họ).
• Bạn có thể sử dụng bất kỳ phiên bản ngôn ngữ sau hẹn hò (hoặc ngôn ngữ). Bạn không thể sử dụng bất kỳ ngôn ngữ hoặc phiên bản ngôn ngữ nào được thực hiện chỉ cho thử thách này.

Tiền thưởng

20%

• Chương trình của bạn phải có khả năng đếm ít nhất lên tới 18446744073709551615( 2^64-1). Ví dụ: nếu một kiểu dữ liệu mới là cách duy nhất để hỗ trợ các số nguyên lớn, bạn phải xây dựng nó. Nếu ngôn ngữ của bạn không có cách nào để hỗ trợ các số nguyên lớn lên tới 2 ^ 64-1, thì giới hạn trên của ngôn ngữ cụ thể đó phải được hỗ trợ thay thế.

EDIT : Tôi đã thay đổi giới hạn từ 2^64thành2^64-1 cho phép nhiều câu trả lời.

EDIT : Tôi đã thực hiện quy tắc 2 ^ 64-1, vì không có nhiều hứng thú với thử thách này. Nếu câu trả lời của bạn hỗ trợ 2 ^ 64-1, bây giờ bạn có thể chỉnh sửa nó để bao gồm phần thưởng. Ngoài ra, bạn có thể đăng một câu trả lời không hỗ trợ nó, nếu nó ngắn hơn.

MarioLANG , 29 byte

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

Hãy thử trực tuyến!

Tôi biết mã của tôi là buồn siêu buồn hoặc tức giận:

> :(

Chúc mừng MarioLANG, 46 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận hạnh phúc hơn:

 :)

MarioLANG phi cảm xúc, 41 byte

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

Hãy thử trực tuyến!

Bình thường, 1 byte

S

_{Cơ thể phải có ít nhất 30 ký tự; bạn đã nhập 14.}

Cjam, 5 byte

{,:)}

Hãy thử trực tuyến!

Đây là một khối không tên được mong đợi ntrên ngăn xếp và để lại một danh sách với phạm vi [1...n]trên đó.
Hoạt động bằng cách chỉ xây dựng phạm vi với ,và sau đó tăng từng phần tử phạm vi :)để tạo phạm vi một dựa trên.

Toán học, 5 byte

Range

Đủ đơn giản.

Lục giác, 19

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

Hoặc ở định dạng hình lục giác mở rộng:

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

Cảm ơn rất nhiều vì Martin đã cơ bản đến với chương trình này, tôi chỉ đánh gôn để phù hợp với hình lục giác dài 3 cạnh.

Hãy thử trực tuyến!

Tôi không có các chương trình liên quan đến Hexagony tuyệt vời của Timwi, vì vậy lời giải thích này sẽ không có nhiều màu sắc. Thay vào đó, bạn có thể đọc một đốm văn bản khổng lồ. Điều đó không tốt sao?

Trong mọi trường hợp, IP bắt đầu ở góc trên cùng bên trái, trên hướng $di chuyển về phía Đông nếu bạn tưởng tượng chương trình này được đặt với hướng Bắc hướng lên trên bản đồ. Các $nguyên nhân khiến chúng ta bỏ qua hướng dẫn tiếp theo, sẽ là @kết thúc chương trình. Thay vào đó, chúng tôi thực thi ?mà đặt cạnh bộ nhớ hiện tại là số đầu vào. Bây giờ chúng ta đến cuối hàng, đưa chúng ta đến hàng giữa của hình lục giác, vẫn di chuyển về phía Đông.

Hầu hết phần còn lại của chương trình là một vòng lặp. Chúng tôi bắt đầu với .đó là một không-op. Tiếp theo, chúng ta bắt gặp một ngã ba trong ... uh ... hình lục giác ... <hướng dẫn làm cho IP xoay 60 độ sang phải nếu cạnh bộ nhớ hiện tại là dương, nếu không chúng ta xoay 60 độ trái. Vì chúng tôi đang di chuyển về phía Đông, chúng tôi hoặc kết thúc với mục tiêu là Nam hoặc Đông Bắc. Vì đầu vào lớn hơn 0 (và do đó là dương), chúng tôi luôn bắt đầu bằng cách đi về phía Đông Nam.

Tiếp theo, chúng tôi nhấn vào >đó chuyển hướng chúng tôi về phía Đông; các toán tử này chỉ rẽ nhánh nếu bạn nhấn vào phần ngã ba. Sau đó, chúng tôi nhấn 'mà thay đổi cạnh bộ nhớ mà chúng tôi đang xem xét. Sau đó, chúng tôi nhấn )mà tăng giá trị của cạnh bộ nhớ hiện tại. Vì tất cả các cạnh của bộ nhớ bắt đầu từ 0, nên lần đầu tiên chúng tôi thực hiện điều này, chúng tôi nhận được giá trị là 1. Tiếp theo, chúng tôi nhảy lên dòng thứ hai đến dòng trên cùng và thực hiện !in ra số của chúng tôi. Sau đó, chúng tôi chuyển sang một cạnh khác {và lưu trữ giá trị ASCII của M nhân với 10 cộng với 8 (778). Sau đó, chúng tôi nhảy trở lại dòng thứ hai đến dòng cuối cùng của hình lục giác, và nhấn /. Điều này dẫn đến việc chúng tôi di chuyển Tây Bắc. Chúng tôi đi qua. hàng giữa và đi ra;ở phía dưới bên phải. Điều này in ra mod 256 cạnh bộ nhớ hiện tại dưới dạng ASCII. Điều này xảy ra là một dòng mới. Chúng tôi nhấn 'sẽ đưa chúng tôi trở lại cạnh đầu tiên có giá trị mà chúng tôi đọc được. Chúng tôi nhấn vào /đó khiến chúng tôi di chuyển về phía Đông một lần nữa. Sau đó, chúng tôi nhấn (mà giảm giá trị. =khiến chúng ta phải đối mặt với hướng đúng một lần nữa cho bước nhảy cạnh bộ nhớ trong tương lai.

Bây giờ, vì giá trị là dương (trừ khi nó bằng 0), chúng tôi quay trở lại dưới cùng của hình lục giác. Ở đây chúng tôi nhấn .sau đó chúng tôi nhảy qua ;để không có gì xảy ra, và chúng tôi quay trở lại bắt đầu vòng lặp. Khi giá trị bằng 0, chúng ta quay trở lại phần đầu của chương trình, ở đó các công cụ tương tự lại xảy ra nhưng ?không tìm thấy số khác và chúng ta đi theo con đường phân nhánh khác. Đường dẫn đó tương đối đơn giản: chúng tôi nhấn vào {đó thay đổi cạnh bộ nhớ, nhưng chúng tôi không quan tâm nữa, sau đó chúng tôi nhấn vào @đó kết thúc chương trình.

MATL, 1 byte

:

Ví dụ đầu ra:

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

Dùng thử trực tuyến tại đây

GNU Coreutils, 6 bytes

seq $1

split answer to pure bash, see below...

R, 13 bytes

cat(1:scan())

Body must be at least 30 characters.

Javascript 182 177 160 154 139 138 132 bytes (valid)

1 byte saved thanks to @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``)}}

Arbitary precision to the rescue!

Because javascript can only count up to 2^53-1 (Thanks goes to @MartinBüttner for pointing it out), I needed to create arbitary precision to do this. It stores data in an array, and each "tick" it adds 1 to the last element, then goes trough the array, and if something exceedes 9, it sets that element to 0, and adds 1 to the one on the left hand.

Try it here! Note: press F12, to actually see the result, as I didn't want to make you wait for textboxes.

BTW.: I was the only one, who didn't know, ternary operators are so useful in codegolf?

if(statement)executeSomething();

is longer than

statement?executeSomething():0;

by 1 byte.

Javascript, 28 bytes (invalid - can't count to 2⁶⁴)

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

Java 8, 43/69/94 bytes

^{_{Crossed out 44 is still a regular 44 -- wait, I didn't cross it out I just replaced it :(}}

If I can return a LongStream: (43 bytes)

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

This is a lambda for a Function<Long,LongStream>. Technically, I should use rangeClosed instead of range, as I'm cutting off one from my maximum input in this way, but rangeClosed is longer than range.

If I have to print in the function: (69 bytes)

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

This is a lambda for a Consumer<Long>. Technically I'm abusing peek, as it is an intermediate operation, meaning this lambda is technically returning a LongStream like the first example; I should be using forEach instead. Again, golf is not nice code.

Unfortunately, since long's range is a signed 64-bit integer, it does not reach the requested 2^64-1, but merely 2^63-1.

However, Java SE 8 provides functionality to treat longs as if they were unsigned, by calling specific methods on the Long class explicitly. Unfortunately, as Java is still Java, this is rather long-winded, though shorter than the BigInteger version that it replaces. (94 bytes)

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

This is a Consumer<Long>, as the previous.

^{_{And just too long to avoid scroll.}}

05AB1E, 1 byte

Code:

L

Try it online!.

A more interesting approach:

FN>,

Explanation:

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

Try it online!.

MATLAB, 7 bytes

An unnamed anonymous function:

@(n)1:n

Run as:

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

Test it here!

If a full program is required, 17 bytes:

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

Test it here!

Haskell, 10 bytes

f n=[1..n]

Usage example: f 4-> [1,2,3,4].

MarioLANG, 19 bytes

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

Try it online!

Vertical programs are usually more golfable for simple loops in MarioLANG. I'm not sure what the interpreter does when encountering [ inside an elevator, but it seems to terminate the program when the current cell is 0. That's probably a useful trick in general.

Explanation

MarioLANG is a Brainfuck-like language (with an infinite memory tape of arbitrary-precision integers) where the instruction pointer resembles Mario walking and jumping around.

Mario starts in the top left corner and falls downward. ; reads an integer from STDIN and places it in the current memory cell. Now note that = is a ground cell for Mario to walk on, the " and # form an elevator (with # being the start) and ! makes mario stop on the elevator so that he doesn't walk off right away. The > and < set his movement direction. We can see that this gives a simple loop, containing the following code:

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

Now normally [ would conditionally make Mario skip the next depending on whether the current cell is zero or not. That is, as long as the counter is non-zero this does nothing. However, it seems that when Mario encounters a [ while riding an elevator and the current cell is 0, the program simply terminates immediately with an error, which means we don't even need to find a way to redirect him correctly.

Joe - 2 or 6

While you can use the inclusive variant of the range function..

1R

..that's boring! Let's instead take the cumulative sum (\/+) of a table of ones of shape n (1~T).

\/+1~T

Pyth - 3 2 bytes

1 bytes saved thanks to @DenkerAffe.

Without using the builtin.

hM

Try it online.

Pyke, 1 byte

S

Try it here!

Or 2 bytes without the builtin

mh

Try it here!

#h

Try it here!

Lh

Try it here!

dc, 15

?[d1-d1<m]dsmxf

Input read from stdin. This counts down from n, pushing a copy of each numbers to the stack. The stack is then output as one with the f command, so the numbers get printed in the correct ascending order.

Because all the numbers are pushed to the stack, this is highly likely to run out of memory before getting anywhere near 2^64. If this is a problem, then we can do this instead:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 bytes

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

The only thing of interest is to use n-x (where n is the goal and x the incremented variable) to test the end of the while loop instead of having a dedicated variable, so I end up having n-x and n-(n-x) = x in each loop run

Note: I can only count to 2^31-1. Well I guess the Terminators are not a real danger after all.

Piet, 64 Codels

With codelsize 20:

Npiet trace images

First loop:

Remaining trace for n=2:

Notes

• No Piet answer yet? Let me fix that with my first ever Piet program! This could probably be shorter with better rolls and less pointer manipulation though...

• The upper supported limit depends on the implementation of the interpreter. It would theoretically be possible to support arbitraryly large numbers with the right interpreter.

• The delimeter is ETX (Ascii 3), however this cannot be properly displayed in this answer so I'll just leave them out. It works in the console:

Output

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet trace for 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 Bytes

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

Takes input n as a string, should support up to 9007199254740991999999999

Explained:

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

Input read from stdin. bc handles arbitrary precision numbers by default, so the 2^64 max is no problem.

Actually, 1 byte

R

Boring builtin is boring. Requires a 64-bit version of Python 3 to get all the way up to 2**64.

Try it online! (due to memory and output length restrictions, the online interpreter can't go very high).

Here's a 5-byte version that doesn't require 64-bit Python 3 and is a little nicer on memory usage:

W;DWX

Try it online! (see above caveats)

Fuzzy-Octo-Guacamole, 7 bytes

^!_[+X]

Explanation:

^ 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 bytes (non competing)

literally, print range(input())

QBASIC, 43 bytes

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

Cubix, 17 bytes

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

Try it here

Cubix is a 2D language created by @ETHProductions where the commands are wrapped onto a cube. This program wraps onto a cube with an edge length of 2 as follows.

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

• I gets the integer input
• 0 push 0 to the stack
• - subtract top items of stack
• ! if truthy jump the next command @ terminate
• ; pop the subtraction result from the stack
• ) increment top of stack
• w move ip to the right and carry on. This causes it to drop to the next line
• O output the top of stack as a number
• N push linefeed (10) to the stack
• o output a linefeed
• w move ip to the right and carry on. This causes it to drop to the next face
• ! because TOS truthy, jump the @ terminate
• ; pop the linefeed from the stack
• U uturn to the left onto the - subtraction and resume from there

Python 2, 37 33 32 33 bytes

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

Presumably works up to 2**64 and beyond.

Shot down four bytes thanks to @dieter, and another thanks to @orlp. But apparently, as @Sp3000 found out, range() might have issues with higher values, so the function was changed to xrange(). Note: even xrange() might have issues, at least in 2.7.10.

Zsh, 12 bytes

echo {1..$1}

This works because variables are expanded before the braces.

V, 11 Bytes

é1@añYpñdd

Since this contains nasty UTF-8 and unprintables, here is a reversible hexdump:

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

V is an unfinished language I wrote, but this is working as of commit 19. This answer was a little more verbose than I'd like, but that's mostly because V has no knowledge of integers, only strings. So it's a decent answer! This will work up to 2^64, but it will probably take a very long time.

To make my explanation easier to read/write, I will work with this "Human readable form", which is actually how you would type this in vim.

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

Explanation:

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

If loopholes are allowed, here's a shorter version that prints 1 to n, but also prints a 0 (8 bytes):

é0@añYp

And in readable form:

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

This is shorter because the <A-q> at the end is implicit, so we don't need it if we don't have to delete the last line.