Giriş

Garip gelebilir ama biz sayılarak için TEK meydan yok 1etmek ndahil,.

Bu aynı şey değil. Bu bir (kapalı) iyi açıklanmamış bir meydan okumadır.
Bu aynı şey değil. Bu süresiz olarak saymakla ilgilidir.

Meydan okuma

Her tamsayıdan kapsayıcıya 1doğru basan bir program veya işlev yazın n.

kurallar

• nHerhangi bir şekilde alabilirsiniz .
• Bunun nher zaman pozitif bir tamsayı olacağını varsayabilirsin .
• nHerhangi bir tabana girebilirsiniz , ancak her zaman ondalık biçimde çıkmalısınız.
• Çıktı, içinde olmayan herhangi bir karakter (veya desen) ile ayrılmalıdır 0123456789. Ondalık olmayan satır başlarına veya sondaki karakterlere izin verilir (örneğin, gibi diziler kullanılırken [1, 2, 3, 4, 5, 6]).
• Standart boşluklar reddedilir.
• Her dilde en kısa yaklaşımı bulmak istiyoruz, en kısa dilde değil, bu yüzden herhangi bir cevabı kabul etmeyeceğim.
• Bu düzenlemeden sonra cevaplarınızı güncellemelisiniz, son düzenlemeden önce gönderilen yanıtlar standart boşluklar hakkındaki değişiklik kuralına uymalıdır (reddetmek istemedim, ancak topluluk kükremesi yapmak istemedim, Onları reddettim).
• Arkadaşlık sonrası herhangi bir dil sürümünü (veya dilini) kullanabilirsiniz. Sadece bu zorluk için hazırlanan herhangi bir dili veya dili kullanamazsınız.

Bonuslar

% 20

• Programınız en az 18446744073709551615( 2^64-1) sayıma kadar sayılmalıdır . Örneğin, büyük bir tam sayıyı desteklemenin tek yolu yeni bir veri türü ise, onu oluşturmalısınız. Dilinizde 2 ^ 64-1'e kadar dev tam sayıları destekleyecek bir yolu yoksa, o dilin üst sınırının desteklenmesi gerekir.

DÜZENLEME : Ben den sınırı değiştirdik 2^64için 2^64-1daha fazla cevap izin vermek.

EDIT : 2 ^ 64-1 kuralını bonus yaptım, çünkü bu zorluğa fazla ilgi duymadım. Cevabınız 2 ^ 64-1 destekliyorsa, bonusu dahil etmek için şimdi düzenleyebilirsiniz. Ayrıca, kısaltılmışsa, desteklemeyen bir cevap gönderebilirsiniz.

MarioLANG , 29 bayt

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

Çevrimiçi deneyin!

Kodumun ne yazık ki çok üzgün veya kızgın olduğunu biliyorum:

> :(

Mutlu MarioLANG, 46 bayt

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

Çevrimiçi deneyin!

Daha mutlu bir yaklaşım:

 :)

Duygusal olmayan MarioLANG, 41 bayt

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

Çevrimiçi deneyin!

Pyth, 1 bayt

S

_{Gövde en az 30 karakter olmalı; 14 girdiniz.}

Cjam, 5 bayt

{,:)}

Çevrimiçi deneyin!

Bu, nyığın üzerinde bekleyen ve aralığının [1...n]üzerinde bir liste bırakan, adsız bir bloktur .
Seriyi sadece bir temel oluşturacak şekilde oluşturarak ,ve ardından her aralık öğesini artırarak çalışır :).

Mathematica, 5 bayt

Range

Yeterince basit.

Altıgen, 19

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

Veya genişletilmiş altıgen biçiminde:

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

Martin'e temelde bu programla geldiği için çok teşekkür ederim , sadece 3 altıgen kenar uzunluğuna sığacak şekilde golf oynadım.

Çevrimiçi deneyin!

Timwi'nin fantastik Hexagony ile ilgili programlarına sahip değilim, bu yüzden bu açıklama çok renkli olmayacak. Bunun yerine, devasa bir metin bloğu okudunuz. Bu iyi değil mi?

Her durumda IP, sol üst köşede başlar ve $bu programın Kuzeyi yukarı bakacak şekilde bir harita üzerinde yerleştirildiğini düşünüyorsanız, Doğuya doğru hareket eder. Bunun $nedeni @, programı sonlandıracak olan sonraki talimatı atlamamıza neden olur . Bunun yerine, ?geçerli bellek kenarını giriş numarası olarak ayarlayanı yürütürüz . Şimdi, bizi doğuya doğru hareket ettiren, altıgenin orta sırasına götüren sıranın sonuna ulaşıyoruz.

Programın geri kalanının çoğu bir döngüdür. .Hayır-op olan ile başlıyoruz . Daha sonra ... uh ... altıgen ... içinde bir çatalla karşılaşırız, <talimat mevcut bellek kenarı pozitif ise IP'nin sağa doğru 60 derece dönmesine neden olur, aksi halde 60 derece sola döneriz. Doğuya doğru hareket ettiğimizden, ya güney ya da Kuzeydoğu olma yolunda ilerliyoruz. Girdi sıfırdan büyük (ve dolayısıyla pozitif) olduğundan, her zaman Güney Doğu'ya giderek başlarız.

Sonra >bizi doğuya yönlendiren bir şeye çarptık; bu operatörler sadece çatal kısmına bastığınızda çatal olur. Sonra 'hangi hafıza kenarına baktığımızı değiştiriyoruz. Ardından ), geçerli bellek kenarının değerini hangi artışlarla artırdığımızı gördük . Tüm bellek kenarları 0'dan başladığından, ilk yaptığımızda 1 değerini alırız. Daha sonra ikinci - en üst satıra atlar ve !sayımızın çıktısını alırız. Daha sonra {ASCII M değerini 10 artı 8 (778) ile çarparak başka bir kenara taşırız. Sonra altıgenin ikinci ile son çizgisine geri atlıyoruz /. Bu bize Kuzey Batı'yı hareket ettirmemize neden oldu. .Ortadaki çizgiyi geçip, dışarı çıkıyoruz.;sağ altta. Bu, geçerli bellek kenarı modunu 256 ASCII olarak basar. Bu yeni bir satır olur. 'Bizi okuduğumuz değere sahip ilk kenara götüren vurulduk . /Bizi tekrar doğuya doğru hareket etmeye zorlayan vurduk. Sonra (hangi değeri azaltıyoruz. =gelecekteki hafıza kenarı atlayışı için tekrar doğru yöne bakmamıza neden olur.

Şimdi, değer pozitif olduğundan (sıfır olmadıkça) altıgenin dibine geri döneriz. Burada çarptık, .sonra atlıyoruz, ;böylece hiçbir şey olmuyor ve döngünün başlangıcına geri dönüyoruz. Değer sıfır olduğunda, programın başlangıcına geri döneriz, aynı şeyler tekrar olur ama ?başka bir sayı bulamaz ve diğer dallanma yolunu izleriz. Bu yol göreceli olarak basittir: {hafıza kenarını değiştiren vuruş yapıyoruz, ancak artık umurumuzda değil, daha sonra @programı bitiren vuruş yapıyoruz .

MATL, 1 bayt

:

Örnek çıktı:

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

Burada çevrimiçi deneyin

GNU Coreutils, 6 bayt

seq $1

yanıtı saf bash'a bölün, aşağıya bakın ...

R, 13 bayt

cat(1:scan())

Gövde en az 30 karakter olmalıdır.

Javascript 182 177 160 154 139 138 132 bayt (geçerli)

@ShaunH sayesinde 1 bayt kurtarıldı

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``)}}

Kurtarmaya hassas hassasiyet!

Javascript yalnızca 2 ^ 53-1'e kadar sayabildiğinden (Teşekkürler bunu işaret ettiği için @ MartinBüttner'e gider), bunu yapmak için hassas bir hassasiyet oluşturmam gerekiyordu. Bir dizide veri depolar ve her bir "tick", son elemana 1 ekler, sonra diziye gider ve eğer bir şey 9'u aşarsa, o elemana 0 değerini verir ve sol eldekie 1 ekler.

Burada dene! Not: Metin kutularını bekletmek istemediğim için sonucu görmek için F12 tuşuna basın.

BTW .: Üç kişi operatörleri codegolf'ta bu kadar yararlı olan tek kişi bendim?

if(statement)executeSomething();

daha uzun

statement?executeSomething():0;

1 bayt ile.

Javascript, 28 bayt (geçersiz - 2 ⁶⁴ sayılmaz )

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

Java 8, 43/69/94 bayt

^{_{44'ü geçip hala normal bir 44 - bekle, geçmedim sadece değiştirdim :(}}

Eğer döndürebilirsem LongStream: ( 43 bytes)

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

Bu bir için bir lambda Function<Long,LongStream>. Teknik olarak, rangeClosedyerine kullanmam gerekir range, çünkü bu şekilde maksimum girişimden birini kesiyorum, ancak rangeCloseddaha uzun range.

İşlevde yazdırmak zorunda kalırsam: ( 69 bytes)

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

Bu bir için bir lambda Consumer<Long>. Teknik peekolarak, bir ara işlem olduğu için kötüye kullanıyorum , yani bu lambda teknik LongStreamolarak ilk örneği döndürüyor ; Bunun forEachyerine kullanmalıyım. Yine, golf güzel bir kod değildir.

İçin maalesef longbireyin aralığı ise imzalanmış 64 bitlik tamsayı, bu talep ulaşamazsa 2^64-1, ama sadece 2^63-1.

Ancak , Java SE 8 tedavi için işlevsellik sağlar longs sanki onlar üzerinde özel yöntemler arayarak, imzasız olduğunu Longaçıkça sınıfta. Ne yazık ki, Java hala Java olduğu için, bu oldukça uzun soluktur, fakat değiştirdiği BigInteger sürümünden daha kısadır. ( 94 bytes)

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

Bu bir Consumer<Long>önceki gibi.

^{_{Ve kaydırma yapmamak için sadece çok uzun.}}

05AB1E , 1 bayt

Kod:

L

Çevrimiçi deneyin! .

Daha ilginç bir yaklaşım:

FN>,

Açıklama:

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

Çevrimiçi deneyin! .

MATLAB, 7 bayt

Adsız bir adsız işlev:

@(n)1:n

Olarak çalıştırmak:

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

Burada test et!

Tam bir program gerekiyorsa, 17 bayt:

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

Burada test et!

Haskell, 10 bayt

f n=[1..n]

Kullanım örneği: f 4-> [1,2,3,4].

MarioLANG , 19 bayt

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

Çevrimiçi deneyin!

MarioLANG'daki dikey döngüler genellikle basit döngüler için daha golf oynamaktadır. Emin değilimTercümanın [asansörün içinde karşılaştığında ne yaptığından , ancak mevcut hücre 0 olduğunda programı sonlandırıyor gibi görünüyor. Bu muhtemelen genel olarak faydalı bir numaradır.

açıklama

MarioLANG, talimat göstergesinin Mario içinde dolaşıp zıpladığını andırdığı Brainfuck benzeri bir dildir (isteğe bağlı tam sayıların sonsuz bellek bandı ile).

Mario sol üst köşeden başlar ve aşağıya düşer. ;STDIN'den bir tamsayı okur ve geçerli bellek hücresine yerleştirir. Şimdi =, Mario'nun yürümesi için bir zemin hücresi olduğunu "ve #bir asansör oluşturduğunu ( #başlangıç ​​olarak) ve !mario'nun asansörde durmasını sağladığını ve böylece hemen yürümeyeceğini unutmayın. >Ve <onun hareket yönünü ayarlamak. Bunun, aşağıdaki kodu içeren basit bir döngü verdiğini görebiliriz:

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

Şimdi normal olarak [şartlı olarak Mario'nun mevcut hücrenin sıfır olup olmamasına bağlı olarak bir sonraki atlamasını sağlar. Yani, sayaç sıfır olmadıkça bu hiçbir şey yapmaz. Ancak, Mario [asansöre binerken bir süre karşılaştığında ve şu anki hücre olduğunda 0, program derhal bir hatayla sona ermektedir, bu da onu doğru şekilde yönlendirmek için bir yol bulmamız gerekmediği anlamına gelir.

Joe - 2 ya da 6

Range işlevinin kapsayıcı değişkenini kullanabilirsiniz.

1R

..bu sıkıcı! Bunun yerine \/+n ( 1~T) şeklindeki bir tablonun kümülatif toplamını ( ) alalım .

\/+1~T

Pyth - 3 2 bayt

@DenkerAffe sayesinde 1 bayt kaydedildi.

Yerleşik kullanmadan.

hM

Çevrimiçi deneyin .

Pyke, 1 bayt

S

Burada dene!

Yerleşik olmayan 2 bayt

mh

Burada dene!

#h

Burada dene!

Lh

Burada dene!

dc, 15

?[d1-d1<m]dsmxf

Giriş stdin'den okunur. Bu n, her sayının bir kopyasını yığına iterek, geri sayım yapar . Yığın daha sonra fkomutla tek olarak çıkar , böylece sayılar doğru artan sırada yazdırılır.

Tüm sayılar yığına bastırıldığı için, bu durum 2 ^ 64'e yakın herhangi bir yere ulaşmadan önce bellek tükenmesi olasılığı yüksektir. Eğer bu bir problemse, bunun yerine bunu yapabiliriz:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 bayt

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

İlgilenilen tek şey nx (burada n hedef ve artan değişken x) özel bir değişkene sahip olmak yerine while döngüsünün sonunu test etmek için kullanmaktır. her döngü çalışmasında

Not : Sadece 2 ^ 31-1'e kadar sayabilirim. Sanırım Terminatörler sonuçta gerçek bir tehlike değil.

Piet, 64 Codels

Codelsize 20 ile:

Npiet izleme görüntüleri

İlk döngü:

Şunun için kalan iz n=2:

notlar

• Henüz Piet cevabı yok mu? Şimdiye kadarki ilk Piet programımla bunu düzelteyim! Bu muhtemelen daha iyi rulolar ve daha az imleç manipülasyonu ile daha kısa olabilir ...

• Desteklenen üst sınır, tercümanın uygulanmasına bağlıdır. Teorik olarak isteğe bağlı olarak büyük sayıları doğru yorumlayıcı ile desteklemek mümkün olacaktır.

• Sınır ETX(Ascii 3), ancak bu cevapta doğru şekilde görüntülenemiyor, bu yüzden onları dışarıda bırakacağım. Konsolda çalışıyor:

Çıktı

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet izlemesi 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 Bayt

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

Giriş alır nBir dize olarak , 9007199254740991999999999’a kadar desteklemelidir

Açıklaması:

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

Giriş stdin'den okunur. bcvarsayılan olarak rasgele kesinlikli sayıları yönetir, bu nedenle 2 ^ 64 maks sorun değildir.

Aslında, 1 bayt

R

Sıkıcı yerleşik sıkıcıdır. Başa çıkmak için Python 3'ün 64 bit sürümünü gerektirir 2**64.

Çevrimiçi deneyin! (bellek ve çıktı uzunluğu kısıtlamaları nedeniyle, çevrimiçi tercüman çok yükseğe çıkamaz).

64-bit Python 3 gerektirmeyen ve bellek kullanımı konusunda biraz daha hoş bir 5-bayt sürümü:

W;DWX

Çevrimiçi deneyin! (yukarıdaki uyarılara bakın)

Bulanık Octo-Guacamole, 7 bayt

^!_[+X]

Açıklama:

^ 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 bayt (rekabet etmeyen)

literally, print range(input())

QBASIC, 43 bayt

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

Cubix , 17 bayt

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

Burada dene

Cubix, @ETHProductions tarafından oluşturulan, komutların bir küp üzerine sarılı olduğu bir 2D dilidir. Bu program aşağıdaki gibi bir kenar uzunluğu 2 olan bir küp üzerine sarılır.

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

• I tamsayı girişini alır
• 0 yığına 0 it
• - yığının en üst öğelerini çıkar
• ! eğer truthy sonraki komutu atlarsa @ sonlandırırsa
• ; yığından çıkarma sonucunu çıkar
• ) yığının arttırılması
• wipi sağa hareket ettirin ve devam edin. Bu bir sonraki satıra düşmesine neden olur
• O yığının tepesini bir sayı olarak çıkar
• N linefeed (10) istifine itin
• o satır beslemesi vermek
• wipi sağa hareket ettirin ve devam edin. Bu, bir sonraki yüze düşmesine neden olur
• !çünkü TOS truthy, @sonlandırmayı atla
• ; satır beslemesini yığından çıkar
• Uçıkarma için sola uturn -ve oradan devam

Python 2, 37 33 32 33 bayt

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

Muhtemelen 2**64ve ötesine kadar çalışır .

Dört aşağı Shot @dieter sayesinde bayt , ve @orlp başka sayesinde . Fakat görünüşe göre, @ Sp3000'in belirttiği gibi, range()daha yüksek değerlerle ilgili sorunlar olabilir, bu yüzden işlev değiştirildixrange() . Not: xrange()En azından 2.7.10'da bile sorunlar olabilir .

Zsh, 12 bayt

echo {1..$1}

Bu işe yarar çünkü değişkenler ayraçlardan önce genişletilir.

V, 11 Bayt

é1@añYpñdd

Bu, kötü UTF-8 ve yazdırılamayan içerdiğinden, geri dönüşümlü bir hexdump:

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

V, yazdığım bitmemiş bir dil, ancak bu 19 . Bu cevap istediğimden biraz daha ayrıntılıydı, ama bunun nedeni V'nin tamsayılar bilgisine sahip olmaması, sadece dizgelerdi. Bu yüzden iyi bir cevap! Bu olacak 2 ^ 64 kadar çalışır, ancak muhtemelen alacak çok uzun zaman.

Açıklamamı okumayı / yazmayı kolaylaştırmak için, bu "İnsan tarafından okunabilir bir form" ile çalışacağım, aslında bunu vim'de nasıl yazacağınızı.

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

Açıklama:

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

Boşluklara izin veriliyorsa, işte 1'den n'ye basan ancak 0 (8 bayt) da basan daha kısa bir sürüm:

é0@añYp

Ve okunabilir biçimde:

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

Bu daha kısadır, çünkü <A-q>sonunda kapalıdır, bu nedenle son satırı silmek zorunda kalmazsak buna ihtiyacımız yoktur.