Wprowadzenie

Może to zabrzmieć dziwnie, ale nie mamy JEDENEGO wyzwania do liczenia od 1do nwłącznie.

To nie to samo. To jest (zamknięte), nie do końca wyjaśnione wyzwanie.
To nie to samo. Ten polega na liczeniu w nieskończoność.

Wyzwanie

Napisz program lub funkcję, która wypisze każdą liczbę całkowitą od 1do nwłącznie.

Zasady

• Możesz uzyskać ndowolny sposób.
• Możesz założyć, że nzawsze będzie dodatnią liczbą całkowitą.
• Możesz dostać się ndo dowolnej bazy, ale zawsze powinieneś generować dane dziesiętne.
• Dane wyjściowe muszą być oddzielone dowolnym znakiem (lub wzorem) spoza 0123456789. Dopuszczalne są nie dziesiętne znaki wiodące lub końcowe (na przykład przy użyciu tablic takich jak [1, 2, 3, 4, 5, 6]).
• Standardowe luki są odrzucane.
• Chcemy znaleźć najkrótsze podejście w każdym języku, a nie najkrótszy, więc nie przyjmę żadnej odpowiedzi.
• Musisz zaktualizować swoje odpowiedzi po tej edycji, odpowiedzi opublikowane przed ostatnią edycją muszą być zgodne z regułą zmiany dotyczącą standardowych luk (nie chciałem ich zaprzeczać, ale nie chciałem, aby społeczność ryczała, więc Zaprzeczyłem im).
• Możesz użyć dowolnej wersji językowej (lub języka) po randce. Nie możesz użyć żadnego języka ani wersji językowej stworzonej tylko dla tego wyzwania.

Bonusy

20%

• Twój program musi być w stanie policzyć co najmniej do 18446744073709551615( 2^64-1). Na przykład, jeśli nowy typ danych jest jedynym sposobem obsługi dużych liczb całkowitych, musisz go skonstruować. Jeśli twój język nie ma możliwości obsługi dużych liczb całkowitych do 2 ^ 64-1, zamiast tego musi być obsługiwany górny limit tego konkretnego języka.

EDYCJA : Zmieniłem limit z 2^64na, 2^64-1aby umożliwić więcej odpowiedzi.

EDYCJA : Zrobiłem premię 2 ^ 64-1, ponieważ nie było dużego zainteresowania tym wyzwaniem. Jeśli twoja odpowiedź obsługuje 2 ^ 64-1, możesz ją teraz edytować, aby uwzględnić premię. Możesz także opublikować odpowiedź, która jej nie obsługuje, jeśli jest krótsza.

MarioLANG , 29 bajtów

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

Wypróbuj online!

Wiem, że mój kod jest niestety bardzo smutny lub zły:

> :(

Happy MarioLANG, 46 bajtów

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

Wypróbuj online!

Szczęśliwsze podejście:

 :)

MarioLANG bez emocji, 41 bajtów

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

Wypróbuj online!

Pyth, 1 bajt

S

_{Treść musi mieć co najmniej 30 znaków; wszedłeś 14.}

Cjam, 5 bajtów

{,:)}

Wypróbuj online!

Jest to nienazwany blok, który oczekuje nna stosie i pozostawia listę z zakresem [1...n]na nim.
Działa po prostu budując zakres, ,a następnie zwiększając każdy element zakresu, :)aby zakres był oparty na jednym.

Mathematica, 5 bajtów

Range

Wystarczająco proste.

Sześciokąt, 19

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

Lub w rozszerzonym formacie sześciokąta:

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

Ogromne podziękowania dla Martina za to, że w zasadzie wymyśliłem ten program, właśnie grałem w golfa, aby zmieścić się w sześciokącie o długości boku 3.

Wypróbuj online!

Nie mam fantastycznych programów związanych z Hexagony firmy Timwi, więc to wyjaśnienie nie będzie bardzo kolorowe. Zamiast tego możesz przeczytać ogromną kroplę tekstu. Czy to nie miłe?

W każdym razie adres IP zaczyna się w lewym górnym rogu, w kierunku na $wschód, jeśli wyobrażasz sobie, że ten program został umieszczony na mapie północą skierowaną do góry. $Powoduje nam pominąć następną instrukcję, która byłaby @, co byłoby zakończyć program. Zamiast tego wykonujemy, ?który ustawia bieżącą krawędź pamięci jako liczbę wejściową. Teraz docieramy do końca rzędu, który prowadzi nas do środkowego rzędu sześciokąta, wciąż przesuwając się na wschód.

Większość reszty programu to pętla. Zaczynamy od tego, .co jest opcją. Następnie napotykamy rozwidlenie w ... uh ... sześciokącie ... <instrukcja powoduje, że IP obraca się o 60 stopni w prawo, jeśli bieżąca krawędź pamięci jest dodatnia, w przeciwnym razie obracamy o 60 stopni w lewo. Ponieważ zmierzamy na wschód, albo kończy się na tym, że kierujemy się na południe lub na północny wschód. Ponieważ wartość wejściowa jest większa od zera (a zatem dodatnia), zawsze zaczynamy od przejścia na południowy wschód.

Następnie trafiamy na coś, >co przekierowuje nas na wschód; operatorzy ci rozwidlają się tylko po uderzeniu w część widelca. Następnie uderzamy, 'co zmienia krawędź pamięci, na którą patrzymy. Następnie wciskamy, )która zwiększa wartość aktualnego zbocza pamięci. Ponieważ wszystkie krawędzie pamięci zaczynają się od 0, po raz pierwszy to robimy, otrzymujemy wartość 1. Następnie przeskakujemy do drugiej do górnej linii i wykonujemy, !która wypisuje naszą liczbę. Następnie przechodzimy do innej krawędzi {i przechowujemy wartość ASCII M pomnożoną przez 10 plus 8 (778). Następnie przeskakujemy z powrotem do drugiej do ostatniej linii sześciokąta i uderzamy w /. To powoduje, że przenosimy się na północny zachód. Mijamy. środkowy rząd i wychodzimy na;w prawym dolnym rogu. Spowoduje to wydrukowanie aktualnego modu krawędzi pamięci 256 jako ASCII. To bywa nowa linia. Trafiamy, 'co zabiera nas z powrotem do pierwszej krawędzi, która ma wartość, którą odczytujemy. Trafiamy, /co powoduje, że znów możemy iść na wschód. Następnie trafiamy, (która zmniejsza wartość. =powoduje, że znów kierujemy się w dobrym kierunku, aby skoczyć na skraj pamięci w przyszłości.

Teraz, ponieważ wartość jest dodatnia (chyba że zero), wracamy na dół sześciokąta. Tutaj uderzamy ., przeskakujemy, ;więc nic się nie dzieje i wracamy do początku pętli. Gdy wartość wynosi zero, wracamy do początku programu, w którym to samo dzieje się ponownie, ale ?nie można znaleźć innej liczby, i wybieramy inną ścieżkę rozgałęzienia. Ta ścieżka jest stosunkowo prosta: uderzamy, {co zmienia krawędź pamięci, ale już nas to nie obchodzi, a następnie uderzamy, @co kończy program.

MATL, 1 bajt

:

Przykładowe dane wyjściowe:

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

Wypróbuj online tutaj

GNU Coreutils, 6 bajtów

seq $1

podzielona odpowiedź na czysty bash, patrz poniżej ...

R, 13 bajtów

cat(1:scan())

Treść musi mieć co najmniej 30 znaków.

JavaScript 182 177 160 154 139 138 132 bajtów (prawidłowy)

1 bajt zapisany dzięki @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``)}}

Arbitralna precyzja na ratunek!

Ponieważ javascript może liczyć tylko do 2 ^ 53-1 (podziękowania dla @ MartinBüttner za wskazanie tego), musiałem stworzyć arbitralną precyzję, aby to zrobić. Przechowuje dane w tablicy, a każde „tik” dodaje 1 do ostatniego elementu, a następnie przechodzi przez tablicę, a jeśli coś przekracza 9, ustawia ten element na 0 i dodaje 1 do lewej.

Wypróbuj tutaj! Uwaga: naciśnij klawisz F12, aby zobaczyć wynik, ponieważ nie chciałem, abyś czekał na pola tekstowe.

BTW .: Byłem jedynym, który nie wiedział, że trójskładnikowi operatorzy są tak przydatni w codegolf?

if(statement)executeSomething();

jest dłuższy niż

statement?executeSomething():0;

o 1 bajt.

JavaScript, 28 bajtów (nieprawidłowy - nie można policzyć do 2 ⁶⁴ )

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

Java 8, 43/69/94 bajtów

^{_{Przekreślony 44 jest nadal zwykłym 44 - czekaj, nie przekreśliłem go, właśnie go zastąpiłem :(}}

Jeśli mogę zwrócić LongStream: ( 43 bytes)

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

To jest lambda dla Function<Long,LongStream>. Technicznie rzecz biorąc, powinienem użyć rangeClosedzamiast range, ponieważ odcinam jeden z moich maksymalnych nakładów w ten sposób, ale rangeClosedjest on dłuższy niż range.

Jeśli muszę wydrukować w funkcji: ( 69 bytes)

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

To jest lambda dla Consumer<Long>. Technicznie nadużywam peek, ponieważ jest to operacja pośrednia , co oznacza, że ​​ta lambda technicznie zwraca LongStreampodobny do pierwszego przykładu; Powinienem forEachzamiast tego używać . Znowu golf to niezły kod.

Niestety, od long„s zasięg jest podpisana 64-bitową liczbą całkowitą, to nie osiąga żądane 2^64-1, ale po prostu 2^63-1.

Jednak Java SE 8 zapewnia funkcjonalność do traktowania longs, jakby były niepodpisane, poprzez Longjawne wywoływanie określonych metod w klasie. Niestety, ponieważ Java jest nadal Javą, jest ona dość długa, choć krótsza niż wersja BigInteger, którą zastępuje. ( 94 bytes)

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

Jest to Consumer<Long>, jak poprzednio.

^{_{I po prostu za długo, aby uniknąć przewijania.}}

05AB1E , 1 bajt

Kod:

L

Wypróbuj online! .

Bardziej interesujące podejście:

FN>,

Wyjaśnienie:

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

Wypróbuj online! .

MATLAB, 7 bajtów

Anonimowa anonimowa funkcja:

@(n)1:n

Uruchom jako:

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

Sprawdź to tutaj!

Jeśli wymagany jest pełny program, 17 bajtów:

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

Sprawdź to tutaj!

Haskell, 10 bajtów

f n=[1..n]

Przykład użycia: f 4-> [1,2,3,4].

MarioLANG , 19 bajtów

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

Wypróbuj online!

Programy pionowe są zwykle bardziej grywalne dla prostych pętli w MarioLANG. Nie jestem pewien, co robi tłumacz podczas spotkania[ w windzie, ale wydaje się, że kończy działanie programu, gdy bieżąca komórka wynosi 0. To prawdopodobnie użyteczna sztuczka w ogóle.

Wyjaśnienie

MarioLANG jest językiem przypominającym Brainfuck (z nieskończoną taśmą liczb całkowitych o dowolnej precyzji), gdzie wskaźnik instrukcji przypomina Mario spacerującego i skaczącego.

Mario zaczyna w lewym górnym rogu i spada w dół. ;odczytuje liczbę całkowitą ze STDIN i umieszcza ją w bieżącej komórce pamięci. Zauważ teraz, że =jest to komórka naziemna, po której Mario może chodzić, "i #formuje windę (z #początkiem) i !sprawia, że ​​Mario zatrzymuje się na windzie, aby nie od razu odszedł. I >i <ustawić jego kierunek ruchu. Widzimy, że daje to prostą pętlę, zawierającą następujący kod:

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

Teraz normalnie [warunkowo sprawi, że Mario pominie następny, w zależności od tego, czy bieżąca komórka ma zero, czy nie. Oznacza to, że dopóki licznik jest niezerowy, nic nie robi. Wygląda jednak na to, że kiedy Mario napotyka na [chwilę jazdę windą, a obecna komórka jest 0, program po prostu natychmiast kończy się z błędem, co oznacza, że ​​nie musimy nawet znaleźć sposobu, aby go poprawnie przekierować.

Joe - 2 lub 6

Podczas gdy możesz skorzystać z opcjonalnego wariantu funkcji zakresu.

1R

..to jest nudne! Zamiast tego weźmy sumę sumaryczną ( \/+) tabeli o kształcie n ( 1~T).

\/+1~T

Pyth - 3 2 bajty

1 bajt zapisany dzięki @DenkerAffe.

Bez użycia wbudowanego.

hM

Wypróbuj online .

Pyke, 1 bajt

S

Wypróbuj tutaj!

Lub 2 bajty bez wbudowanego

mh

Wypróbuj tutaj!

#h

Wypróbuj tutaj!

Lh

Wypróbuj tutaj!

dc, 15

?[d1-d1<m]dsmxf

Wejście odczytane ze standardowego wejścia. To odlicza od n, wypychając kopię każdej liczby na stos. Stos jest następnie wyprowadzany jako jeden z fpoleceniem, więc liczby są drukowane we właściwej kolejności rosnącej.

Ponieważ wszystkie liczby są wypychane na stos, najprawdopodobniej zabraknie pamięci, zanim zbliży się do 2 ^ 64. Jeśli jest to problem, możemy to zrobić zamiast tego:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 bajtów

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

Jedyną interesującą rzeczą jest użycie nx (gdzie n jest celem, a x zmienną przyrostową) do przetestowania końca pętli while zamiast posiadania dedykowanej zmiennej, więc w końcu mam nx i n- (nx) = x w każdym przebiegu pętli

Uwaga : mogę policzyć tylko do 2 ^ 31-1. Cóż, myślę, że Terminatory wcale nie są prawdziwym zagrożeniem.

Piet, 64 kodeków

Z kodem wielkości 20:

Obrazy śledzenia Npiet

Pierwsza pętla:

Pozostały ślad dla n=2:

Notatki

• Brak odpowiedzi Piet? Pozwól mi to naprawić w moim pierwszym programie Piet! Może to być prawdopodobnie krótsze przy lepszych rolkach i mniejszej manipulacji wskaźnikiem ...

• Górny obsługiwany limit zależy od implementacji interpretera. Teoretycznie byłoby możliwe wspieranie dowolnie dużych liczb za pomocą właściwego tłumacza.

• Ogranicznikiem jest ETX(Ascii 3), jednak nie można go poprawnie wyświetlić w tej odpowiedzi, więc po prostu je pominę. Działa w konsoli:

Wydajność

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Ślad Npiet dla 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 bajtów

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

Pobiera dane wejściowe n jako ciąg, powinien obsługiwać do 9007199254740991999999999

Wyjaśnił:

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

Wejście odczytane ze standardowego wejścia. bcdomyślnie obsługuje dowolne liczby precyzji, więc 2 ^ 64 max nie stanowi problemu.

Właściwie 1 bajt

R

Nudne wbudowane jest nudne. Wymaga 64-bitowej wersji Python 3, aby uzyskać dostęp do pełnej wersji 2**64.

Wypróbuj online!(z powodu ograniczeń pamięci i długości wyjściowej interpreter online nie może być bardzo wysoki).

Oto 5-bajtowa wersja, która nie wymaga 64-bitowego języka Python 3 i jest nieco przyjemniejsza w użyciu pamięci:

W;DWX

Wypróbuj online! (patrz wyżej zastrzeżenia)

Fuzzy-Octo-Guacamole, 7 bajtów

^!_[+X]

Wyjaśnienie:

^ 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

Oracja, 31 bajtów (nie konkuruje)

literally, print range(input())

QBASIC, 43 bajty

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

Cubix , 17 bajtów

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

Wypróbuj tutaj

Cubix to język 2D stworzony przez @ETHProductions, w którym polecenia są zawijane w kostkę. Ten program jest zawijany na sześcianie o długości krawędzi 2 w następujący sposób.

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

• I pobiera liczbę całkowitą
• 0 pchnij 0 na stos
• - odejmij najlepsze elementy stosu
• ! jeśli tak naprawdę przeskocz następne polecenie @ kończy się
• ; wyskoczy wynik odejmowania ze stosu
• ) zwiększanie stosu
• wprzesuń ip w prawo i kontynuuj. Powoduje to, że spada do następnej linii
• O wypisuje górę stosu jako liczbę
• N pchnij linefeed (10) na stos
• o wyprowadza wysuw linii
• wprzesuń ip w prawo i kontynuuj. To powoduje, że opada na następną twarz
• ! ponieważ TOS to prawda, przeskocz @ terminację
• ; wysuń linijkę ze stosu
• Uskręć w lewo na -odejmowanie i stamtąd wznów

Python 2, 37 33 32 33 bajtów

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

Przypuszczalnie działa nawet 2**64dalej.

Zestrzelono cztery bajty dzięki @dieter , a kolejne dzięki @orlp . Ale najwyraźniej, jak się okazało @ Sp3000, range()mogą występować problemy z wyższymi wartościami, więc funkcja została zmieniona naxrange() . Uwaga: nawet xrange()mogą mieć problemy, przynajmniej w 2.7.10 .

Zsh, 12 bajtów

echo {1..$1}

Działa to, ponieważ zmienne są rozwijane przed nawiasami klamrowymi.

V, 11 bajtów

é1@añYpñdd

Ponieważ zawiera nieprzyjemny UTF-8 i nie można go drukować, oto odwracalny zrzut heksowy:

00000000: e931 4061 f159 7001 f164 64              [email protected]

V jest niedokończonym językiem, który napisałem, ale działa od 19-go zatwierdzenia . Ta odpowiedź była nieco bardziej szczegółowa, niż bym chciał, ale głównie dlatego, że V nie zna liczb całkowitych, tylko ciągi znaków. To przyzwoita odpowiedź! To będzie pracować do 2 ^ 64, ale to prawdopodobnie będzie trwać bardzo dużo czasu.

Aby moje wyjaśnienie było łatwiejsze do odczytania / napisania, będę pracować z tą „formą czytelną dla człowieka”, a właściwie tak napisałbyś w vimie.

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

Wyjaśnienie:

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

Jeśli luki są dozwolone, oto krótsza wersja, która drukuje 1 do n, ale także drukuje 0 (8 bajtów):

é0@añYp

I w czytelnej formie:

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

Jest to krótsze, ponieważ <A-q>na końcu jest niejawne, więc nie potrzebujemy go, jeśli nie musimy usuwać ostatniego wiersza.