前書き

奇妙に聞こえるかもしれませんが、から1までカウントするためのチャレンジは1つもありませんn。

これは同じことではありません。その1つは（閉じた）十分に説明されていない挑戦です。
これは同じことではありません。それは無期限にカウントアップすることです。

チャレンジ

から1までのすべての整数を出力するプログラムまたは関数を作成しnます。

ルール

• nどんな方法でも手に入れることができます。
• これnは常に正の整数であると想定できます。
• n任意のベースを取得できますが、常に10進数で出力する必要があります。
• 出力は、にない文字（またはパターン）で区切る必要があります0123456789。10進数以外の先頭または末尾の文字を使用できます（たとえば、などの配列を使用する場合[1, 2, 3, 4, 5, 6]）。
• 標準の抜け穴は拒否されます。
• 最短の言語ではなく、各言語で最短のアプローチを見つけたいので、私は答えを受け入れません。
• この編集後に回答を更新する必要があります。最後の編集の前に投稿された回答は、標準の抜け穴に関する変更ルールに準拠する必要があります（拒否したくありませんでしたが、コミュニティをroめたくありませんでした。私はそれらを否定しました）。
• デート後の任意の言語バージョン（または言語）を使用できます。この課題のためだけに作成された言語または言語バージョンは使用できません。

ボーナス

20％

• プログラムは、少なくとも18446744073709551615（2^64-1）までカウントできる必要があります。たとえば、新しいデータ型が大きな整数をサポートする唯一の方法である場合、それを構築する必要があります。あなたの言語が最大2 ^ 64-1までの巨大な整数をサポートする方法を持っていない場合、代わりにその特定の言語の上限をサポートする必要があります。

編集：制限をから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]。
範囲を構築するだけで機能し,、すべての範囲要素をインクリメントし:)て範囲を1ベースにします。

Mathematica、5バイト

Range

簡単です。

六角形、19

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

または、拡張六角形形式で：

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

基本的にこのプログラムを考案してくれたMartinに大いに感謝します。私はゴルフをして、長さ3の六角形に収まるようにしました。

オンラインでお試しください！

私はTimwiの素晴らしいHexagony関連のプログラムを持っていないので、この説明はあまりカラフルではありません。代わりに、膨大な量のテキストを読むことができます。いいじゃない？

いずれにせよ、IPが$マップの北を上に向けて配置されていると想像した場合、IPはの左上隅から東に向かって移動します。これ$により、次の命令がスキップされ@、プログラムが終了します。代わりに、?現在のメモリエッジを入力番号に設定する実行を行います。行の終わりに到達すると、六角形の中央の行に移動しますが、依然として東に向かっています。

プログラムの残りのほとんどはループです。まず、.これはノーオペレーションです。次に、...ええと...六角形の分岐点に遭遇します。<現在のメモリエッジが正の場合、命令はIPを右に60度回転させ、そうでない場合は左に60度回転させます。私たちは東に向かっているため、見出しは南または北東になります。入力はゼロよりも大きい（したがって正である）ため、常に南東に移動することから始めます。

次に、ヒット >を押して、東にリダイレクトします。これらの演算子は、フォーク部分にヒットした場合にのみフォークします。次に、'どのメモリエッジを変更するかを選択します。次に、ヒット)すると、現在のメモリエッジの値が増加します。すべてのメモリエッジは0から始まるため、これを最初に実行すると値1が取得されます。次に、2行目から1行目までジャンプして実行!し、数値を出力します。次に{、MのASCII値に10プラス8を掛けた値（778）で別のエッジに移動します。次に、六角形の最後から2番目の行にジャンプして戻り/ます。その結果、私たちは北西に移動します。.真ん中の行を過ぎて、;右下にあります。これにより、現在のメモリエッジ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

純粋なbashに対する回答を分割します。以下を参照してください...

R、13バイト

cat(1:scan())

本文は少なくとも30文字でなければなりません。

ジャバスクリプト182 177 160 154 139 138 132バイト（有効）

@ShaunHのおかげで1バイト節約

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)

これはaのラムダですFunction<Long,LongStream>。技術的rangeClosedにはrange、の代わりにを使用する必要がrangeClosedありrangeます。これは、この方法で最大入力から1つをカットするためです。

関数で印刷する必要がある場合：（69 bytes）

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

これはaのラムダですConsumer<Long>。技術的にはpeek、このラムダが技術的に最初の例のように返す中間操作であるため、悪用していLongStreamます。forEach代わりに使用する必要があります。繰り返しますが、ゴルフは良いコードではありません。

残念ながら、longの範囲は符号付き 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、プログラムは単に私たちも、正しく彼をリダイレクトする方法を見つける必要がないことを意味エラー、直ちに終了します。

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.