Einführung

Es mag seltsam klingen, aber wir haben nicht EINE Herausforderung für das Zählen von 1bis neinschließlich.

Das ist nicht dasselbe. Das ist eine (abgeschlossene) nicht gut erklärte Herausforderung.
Das ist nicht dasselbe. In diesem Fall geht es darum, auf unbestimmte Zeit hochzuzählen.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die jede ganze Zahl von 1bis neinschließlich ausgibt.

Regeln

• Sie können njeden Weg bekommen.
• Sie können davon ausgehen, dass dies nimmer eine positive ganze Zahl ist.
• Sie können nin jeder Basis erhalten, aber Sie sollten immer in Dezimalzahlen ausgeben.
• Die Ausgabe muss durch ein beliebiges Zeichen (oder Muster) getrennt werden, das nicht in enthalten ist 0123456789. Nicht-dezimale führende oder nachfolgende Zeichen sind zulässig (z. B. bei Verwendung von Arrays wie [1, 2, 3, 4, 5, 6]).
• Standardlücken werden verweigert.
• Wir wollen den kürzesten Ansatz in jeder Sprache finden, nicht die kürzeste Sprache, deshalb werde ich keine Antwort akzeptieren.
• Sie müssen Ihre Antwort (en) nach dieser Änderung aktualisieren. Antworten, die vor der letzten Änderung veröffentlicht wurden, müssen der Änderungsregel für Standardlücken entsprechen (ich wollte sie nicht ablehnen, aber ich wollte die Community nicht zum Brüllen bringen, also Ich habe sie bestritten).
• Sie können eine beliebige Sprachversion (oder Sprache) nach der Datierung verwenden. Sie können keine Sprache oder Sprachversion verwenden, die nur für diese Herausforderung erstellt wurde.

Boni

20%

• Ihr Programm muss mindestens bis 18446744073709551615( 2^64-1) zählen können. Wenn beispielsweise ein neuer Datentyp die einzige Möglichkeit ist, große Ganzzahlen zu unterstützen, müssen Sie ihn erstellen. Wenn Ihre Sprache keine Möglichkeit hat, große Ganzzahlen bis zu 2 ^ 64-1 zu unterstützen, muss stattdessen die Obergrenze dieser bestimmten Sprache unterstützt werden.

EDIT : Ich habe das Limit von 2^64auf geändert2^64-1 , um mehr Antworten zu ermöglichen.

EDIT : Ich habe die 2 ^ 64-1-Regel zu einem Bonus gemacht, da an dieser Herausforderung nicht viel Interesse bestand. Wenn Ihre Antwort 2 ^ 64-1 unterstützt, können Sie sie jetzt bearbeiten, um den Bonus einzuschließen. Sie können auch eine Antwort posten, die diese nicht unterstützt, wenn sie kürzer ist.

MarioLANG , 29 Bytes

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

Probieren Sie es online!

Ich weiß, mein Code ist traurig, sehr traurig oder wütend:

> :(

Glückliches MarioLANG, 46 Bytes

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

Probieren Sie es online!

Ein glücklicherer Ansatz:

 :)

Nicht-emotionales MarioLANG, 41 Bytes

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

Probieren Sie es online!

Pyth, 1 Byte

S

_{Der Text muss mindestens 30 Zeichen lang sein. Sie haben 14 eingegeben.}

Cjam, 5 Bytes

{,:)}

Probieren Sie es online!

Dies ist ein unbenannter Block, der nauf dem Stapel erwartet und eine Liste mit dem Bereich [1...n]darauf hinterlässt .
Bilden Sie einfach den Bereich mit ,und erhöhen Sie dann jedes Bereichselement mit :), um den Bereich einseitig zu machen.

Mathematica, 5 Bytes

Range

Einfach genug.

Hexagony, 19

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

Oder im erweiterten Sechseckformat:

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

Vielen Dank an Martin für die Idee dieses Programm, ich habe es nur golfed in einer Seitenlänge 3 Sechseck passen.

Probieren Sie es online!

Ich habe keine fantastischen Hexagony-bezogenen Programme von Timwi, daher wird diese Erklärung nicht sehr farbenfroh sein. Stattdessen können Sie einen riesigen Textklumpen lesen. Ist das nicht nett

In jedem Fall beginnt die IP in der oberen linken Ecke des $Fensters und bewegt sich nach Osten, wenn Sie sich vorstellen, dass dieses Programm mit der Nordausrichtung nach oben auf einer Karte platziert wurde. Das $veranlasst uns, den nächsten Befehl zu überspringen @, der das Programm beenden würde. Stattdessen wird ausgeführt, ?wodurch die aktuelle Speicherflanke als Eingangsnummer festgelegt wird. Jetzt erreichen wir das Ende der Reihe, die uns zur mittleren Reihe des Sechsecks führt und sich immer noch nach Osten bewegt.

Der größte Teil des Programms besteht aus einer Schleife. Wir fangen mit .dem No-Op an. Als nächstes stoßen wir auf eine Gabelung im ... äh ... Sechseck ... die <Anweisung bewirkt, dass sich die IP um 60 Grad nach rechts dreht, wenn die aktuelle Speicherflanke positiv ist, andernfalls drehen wir uns um 60 Grad nach links. Da wir uns nach Osten bewegen, ist unser Kurs entweder nach Süden oder nach Nordosten. Da die Eingabe größer als Null (und daher positiv) ist, beginnen wir immer mit dem Südosten.

Als nächstes treffen wir eine, >die uns nach Osten umleitet; Diese Operatoren gabeln sich nur, wenn Sie den Gabelteil treffen. Dann treffen wir, 'welche Änderungen welchen Erinnerungsrand wir betrachten. Dann treffen wir, )was den Wert der aktuellen Speicherflanke erhöht. Da alle Speicherflanken bei 0 beginnen, erhalten wir beim ersten Mal den Wert 1. Als nächstes springen wir in die zweite bis oberste Zeile und führen !den Ausdruck unserer Nummer aus. Dann bewegen wir uns mit zu einer anderen Flanke {und speichern den ASCII-Wert von M multipliziert mit 10 plus 8 (778). Dann springen wir zurück zur vorletzten Zeile des Sechsecks und drücken die Taste /. Dies führt dazu, dass wir nach Nordwesten ziehen. Wir gehen rechts unten am vorbei . Dies druckt die aktuelle Speicherflanke mod 256 als ASCII aus. Dies ist zufällig ein Zeilenumbruch. Wir treffen. in der mittleren Reihe vorbei und kommen an der heraus;' was uns zurück zu der ersten Kante bringt, die den Wert hat, den wir eingelesen haben. Das Treffen, /das uns veranlasst, wieder nach Osten zu gehen. Dann treffen wir, (was den Wert dekrementiert. =veranlasst uns, wieder die richtige Richtung für das zukünftige Gedächtnisspringen einzuschlagen.

Da der Wert nun positiv ist (es sei denn, er ist Null), kehren wir zum unteren Rand des Sechsecks zurück. Hier schlagen wir zu, .dann springen wir über das, ;damit nichts passiert, und wir kehren zum Anfang der Schleife zurück. Wenn der Wert Null ist, kehren wir zum Anfang des Programms zurück, wo dasselbe wieder passiert, aber ?keine andere Zahl gefunden wird, und wir nehmen den anderen Verzweigungspfad. Dieser Weg ist relativ einfach: Wir treffen, {was den Speicherrand verändert, aber es ist uns egal, dann treffen wir, @was das Programm beendet.

MATL, 1 Byte

:

Beispielausgabe:

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

Probieren Sie es hier online aus

GNU Coreutils, 6 Bytes

seq $1

geteilte Antwort auf pure Bash, siehe unten ...

R, 13 Bytes

cat(1:scan())

Body muss mindestens 30 Zeichen lang sein.

Javascript 182 177 160 154 139 138 132 Bytes (gültig)

1 Byte gespart dank @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``)}}

Willkürliche Präzision zur Rettung!

Da Javascript nur bis zu 2 ^ 53-1 zählen kann (Danke an @ MartinBüttner für den Hinweis), musste ich dafür eine willkürliche Präzision schaffen. Es speichert Daten in einem Array und fügt bei jedem "Häkchen" 1 zum letzten Element hinzu, durchläuft dann das Array und setzt dieses Element auf 0, wenn etwas über 9 liegt, und fügt 1 zum Element auf der linken Seite hinzu.

Probieren Sie es hier aus! Hinweis: Drücken Sie F12, um das Ergebnis tatsächlich zu sehen, da ich Sie nicht auf Textfelder warten lassen wollte.

Übrigens: Ich war der einzige, der nicht wusste, dass ternäre Operatoren im Codegolf so nützlich sind.

if(statement)executeSomething();

ist länger als

statement?executeSomething():0;

um 1 Byte.

Javascript, 28 Bytes (ungültig - kann nicht bis 2 ^{64 zählen} )

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

Java 8, 43/69/94 Bytes

^{_{Durchgestrichene 44 ist immer noch eine normale 44 - warte, ich habe es nicht durchgestrichen, ich habe es nur ersetzt :(}}

Wenn ich ein zurückgeben kann LongStream: ( 43 bytes)

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

Dies ist ein Lambda für a Function<Long,LongStream>. Technisch sollte ich rangeClosedstattdessen verwenden range, da ich auf diese Weise einen von meinem maximalen Input abschneide, der aber rangeClosedlänger ist alsrange .

Wenn ich in der Funktion drucken muss: ( 69 bytes)

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

Dies ist ein Lambda für a Consumer<Long>. Technisch missbrauche ich peek, da es sich um eine Zwischenoperation handelt , was bedeutet, dass dieses Lambda technisch LongStreamwie das erste Beispiel zurückgegeben wird. Ich sollte verwendenforEach stattdessen verwenden. Auch hier ist Golf kein schöner Code.

Leider, denn long‚s - Bereich ist ein signiertes 64-Bit - Integer, nicht erreicht es nicht die angeforderte 2^64-1, sondern lediglich 2^63-1.

Allerdings bietet Java SE 8 Funktionalität zu behandeln longs , als ob sie ohne Vorzeichen waren, durch spezifische Methoden , die auf der anrufenden LongKlasse explizit. Da Java immer noch Java ist, ist dies leider ziemlich umständlich, obwohl es kürzer ist als die BigInteger-Version, die es ersetzt. ( 94 bytes)

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

Dies ist ein Consumer<Long>, wie der vorherige.

^{_{Und einfach zu lang, um Schriftrollen zu vermeiden.}}

05AB1E , 1 Byte

Code:

L

Probieren Sie es online! .

Ein interessanterer Ansatz:

FN>,

Erläuterung:

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

Probieren Sie es online! .

MATLAB, 7 Bytes

Eine unbenannte anonyme Funktion:

@(n)1:n

Rennen wie:

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

Teste es hier!

Wenn ein volles Programm benötigt wird, 17 Bytes:

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

Teste es hier!

Haskell, 10 Bytes

f n=[1..n]

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

MarioLANG , 19 Bytes

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

Probieren Sie es online!

Vertikale Programme eignen sich normalerweise besser für einfache Loops in MarioLANG. Ich bin mir nicht sicher, was der Dolmetscher tut, wenn er [in einem Aufzug vorkommt, aber es scheint, als würde er das Programm beenden, wenn die aktuelle Zelle 0 ist. Das ist wahrscheinlich ein nützlicher Trick im Allgemeinen.

Erläuterung

MarioLANG ist eine Brainfuck-ähnliche Sprache (mit einem unendlichen Speicherband von Ganzzahlen mit willkürlicher Genauigkeit), in der der Befehlszeiger an Mario erinnert, der herumläuft und herumspringt.

Mario beginnt in der oberen linken Ecke und fällt nach unten. ;Liest eine Ganzzahl aus STDIN und platziert sie in der aktuellen Speicherzelle. Nun beachte, dass =es sich bei Mario um eine Bodenzelle handelt, auf der er gehen "und #einen Aufzug bilden kann (wobei Mario #der Start ist) !. Das >und <stellte seine Bewegungsrichtung ein. Wir können sehen, dass dies eine einfache Schleife ergibt, die den folgenden Code enthält:

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

Normalerweise [würde nun Mario abhängig davon, ob die aktuelle Zelle Null ist oder nicht, das nächste Mal überspringen. Das heißt, solange der Zähler nicht Null ist, geschieht nichts. Es sieht jedoch so aus, als ob Mario [beim Fahren eines Aufzugs auf die aktuelle Zelle stößt und das 0Programm einfach sofort mit einem Fehler beendet wird. Das heißt, wir müssen nicht einmal einen Weg finden, um ihn korrekt umzuleiten.

Joe - 2 oder 6

Während Sie die inklusive Variante der Bereichsfunktion nutzen können.

1R

..das ist langweilig! Nehmen wir stattdessen die kumulative Summe ( \/+) einer Tabelle mit Einsen der Form n ( 1~T).

\/+1~T

Pyth - 3 2 Bytes

Dank @DenkerAffe 1 Byte gespart.

Ohne das eingebaute zu benutzen.

hM

Probieren Sie es online aus .

Pyke, 1 Byte

S

Probieren Sie es hier aus!

Oder 2 Bytes ohne das eingebaute

mh

Probieren Sie es hier aus!

#h

Probieren Sie es hier aus!

Lh

Probieren Sie es hier aus!

dc, 15

?[d1-d1<m]dsmxf

Eingabe von stdin gelesen. Dies zählt ab n, indem eine Kopie jeder Zahl auf den Stapel gelegt wird. Der Stapel wird dann als eins mit der ausgegebenf Befehl , sodass die Zahlen in der richtigen aufsteigenden Reihenfolge gedruckt werden.

Da alle Zahlen auf den Stack verschoben werden, ist es sehr wahrscheinlich, dass der Speicher knapp wird, bevor er sich 2 ^ 64 annähert. Wenn dies ein Problem ist, können wir dies stattdessen tun:

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

Das einzige, was von Interesse ist, ist die Verwendung von nx (wobei n das Ziel und x die inkrementierte Variable ist), um das Ende der while-Schleife zu testen, anstatt eine dedizierte Variable zu haben. Am Ende habe ich also nx und n- (nx) = x in jeder Schleife laufen

Hinweis : Ich kann nur bis 2 ^ 31-1 zählen. Nun, ich denke, die Terminatoren sind doch keine wirkliche Gefahr.

Piet, 64 Codels

Mit Codegröße 20:

Npiet Spurenbilder

Erste Schleife:

Verbleibende Spur für n=2:

Anmerkungen

• Noch keine Piet-Antwort? Lassen Sie mich das mit meinem ersten Piet-Programm beheben! Dies könnte bei besseren Würfeln und weniger Zeigermanipulation wahrscheinlich kürzer sein ...

• Die obere unterstützte Grenze hängt von der Implementierung des Interpreters ab. Theoretisch wäre es möglich, mit dem richtigen Interpreter beliebig große Zahlen zu unterstützen.

• Der Begrenzer ist ETX(Ascii 3), dies kann jedoch in dieser Antwort nicht richtig angezeigt werden, so dass ich sie einfach weglassen werde. Es funktioniert in der Konsole:

Ausgabe

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet Spur für 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)}

Nimmt die Eingabe nals Zeichenfolge, sollte bis zu 9007199254740991999999999 unterstützen

Erklärt:

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

Eingabe von stdin gelesen. bcStandardmäßig werden Zahlen mit willkürlicher Genauigkeit verarbeitet, sodass die maximale Anzahl von 2 ^ 64 kein Problem darstellt.

Eigentlich 1 Byte

R

Langweilig gebaut ist langweilig. Benötigt eine 64-Bit-Version von Python 3 2**64.

Probieren Sie es online!(Aufgrund von Speicher- und Ausgabelängenbeschränkungen kann der Online-Interpreter nicht sehr hoch sein.)

Hier ist eine 5-Byte-Version, die kein 64-Bit-Python 3 erfordert und die die Speichernutzung ein wenig verbessert:

W;DWX

Probieren Sie es online! (siehe oben Vorbehalte)

Fuzzy-Octo-Guacamole, 7 Bytes

^!_[+X]

Erläuterung:

^ 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 (nicht konkurrierend)

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!

Probieren Sie es hier aus

Cubix ist eine 2D-Sprache, die von @ETHProductions erstellt wurde, wobei die Befehle in einen Würfel eingeschlossen werden. Dieses Programm bricht wie folgt auf einen Würfel mit einer Kantenlänge von 2 um.

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

• I Ruft die Ganzzahleingabe ab
• 0 Drücke 0 auf den Stapel
• - subtrahiere die obersten Gegenstände des Stapels
• !wenn wahrheitsgemäßer Sprung der nächste Befehl @beendet
• ; Pop das Subtraktionsergebnis vom Stapel
• ) Inkrementieren Sie die Oberseite des Stapels
• wBewegen Sie die IP-Adresse nach rechts und fahren Sie fort. Dadurch wird es in die nächste Zeile verschoben
• O gib den Anfang des Stapels als Zahl aus
• N Schieben Sie den Zeilenvorschub (10) auf den Stapel
• o einen Zeilenvorschub ausgeben
• wBewegen Sie die IP-Adresse nach rechts und fahren Sie fort. Dies bewirkt, dass es zum nächsten Gesicht fällt
• !weil TOS wahr ist, springe das @terminate
• ; Ziehen Sie den Zeilenvorschub aus dem Stapel
• UBiegen Sie nach links auf die -Subtraktion ab und fahren Sie von dort fort

Python 2, 37 33 32 33 Bytes

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

Funktioniert vermutlich bis zu 2**64und darüber hinaus.

Abgeschossen vier Bytes dank @dieter , und eine andere dank @orlp . Wie @ Sp3000 herausfand, kann range()es jedoch anscheinend zu Problemen mit höheren Werten kommen, weshalb die Funktion in geändert wurdexrange() . Hinweis: xrange()Möglicherweise gibt es sogar Probleme, zumindest in 2.7.10 .

Zsh, 12 Bytes

echo {1..$1}

Dies funktioniert, weil Variablen vor den geschweiften Klammern erweitert werden.

V, 11 Bytes

é1@añYpñdd

Da dies unangenehmes UTF-8 und nicht druckbare Dateien enthält, gibt es hier einen umkehrbaren Hexdump:

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

V ist eine unvollendete Sprache, die ich geschrieben habe, aber dies funktioniert ab Commit 19 . Diese Antwort war etwas ausführlicher als ich es gerne hätte, aber das liegt hauptsächlich daran, dass V keine ganzen Zahlen kennt, sondern nur Strings. Es ist also eine anständige Antwort! Dies wird bis zu 2 ^ 64 funktionieren, aber es wird wahrscheinlich sehr lange dauern lange .

Um das Lesen und Schreiben meiner Erklärung zu vereinfachen, werde ich mit dieser "vom Menschen lesbaren Form" arbeiten.

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

Erläuterung:

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

Wenn Lücken erlaubt sind, gibt es eine kürzere Version, die 1 bis n ausgibt, aber auch eine 0 (8 Bytes) ausgibt:

é0@añYp

Und in lesbarer Form:

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

Dies ist kürzer, da das <A-q>Ende implizit ist, sodass wir es nicht benötigen, wenn wir die letzte Zeile nicht löschen müssen.