introduction

Cela peut sembler étrange, mais nous n'avons pas eu UN défi pour compter de 1à n, inclus.

Ce n'est pas la même chose. Celui-ci est un défi (fermé) pas bien expliqué.
Ce n'est pas la même chose. Celui-ci consiste à compter indéfiniment.

Défi

Écrivez un programme ou une fonction qui imprime chaque entier de 1à ninclusif.

Règles

• Vous pouvez obtenir nn'importe quel moyen.
• Vous pouvez supposer que ce nsera toujours un entier positif.
• Vous pouvez entrer ndans n'importe quelle base, mais vous devez toujours produire en décimal.
• La sortie doit être séparée par tout caractère (ou motif) qui ne se trouve pas 0123456789. Les caractères de début ou de fin non décimaux sont autorisés (par exemple lors de l'utilisation de tableaux tels que [1, 2, 3, 4, 5, 6]).
• Les failles standard sont refusées.
• Nous voulons trouver l'approche la plus courte dans chaque langue, pas la langue la plus courte, donc je n'accepterai aucune réponse.
• Vous devez mettre à jour vos réponses après cette modification, les réponses publiées avant la dernière modification doivent respecter la règle de changement concernant les failles standard (je ne voulais pas les refuser, mais je ne voulais pas faire rugir la communauté, alors Je les ai niés).
• Vous pouvez utiliser n'importe quelle version linguistique (ou langue) post-datation. Vous ne pouvez pas utiliser de langue ou de version linguistique spécialement conçue pour ce défi.

Bonus

20%

• Votre programme doit pouvoir compter au moins jusqu'à 18446744073709551615( 2^64-1). Par exemple, si un nouveau type de données est le seul moyen de prendre en charge de grands nombres entiers, vous devez le construire. Si votre langue n'a aucun moyen de prendre en charge des entiers énormes jusqu'à 2 ^ 64-1, la limite supérieure de cette langue particulière doit être prise en charge à la place.

EDIT : J'ai changé la limite de 2^64à 2^64-1pour autoriser plus de réponses.

EDIT : J'ai fait de la règle 2 ^ 64-1 un bonus, car ce défi n'a pas suscité beaucoup d'intérêt. Si votre réponse prend en charge 2 ^ 64-1, vous pouvez maintenant la modifier pour inclure le bonus. De plus, vous pouvez poster une réponse ne la supportant pas, si elle est plus courte.

MarioLANG , 29 octets

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

Essayez-le en ligne!

Je sais que mon code est tristement super triste ou en colère:

> :(

Joyeux MarioLANG, 46 octets

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

Essayez-le en ligne!

Une approche plus heureuse:

 :)

MarioLANG non émotionnel, 41 octets

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

Essayez-le en ligne!

Pyth, 1 octet

S

_{Le corps doit contenir au moins 30 caractères; vous avez entré 14.}

Cjam, 5 octets

{,:)}

Essayez-le en ligne!

Il s'agit d'un bloc sans nom qui attend nsur la pile et laisse une liste avec la plage [1...n]dessus.
Fonctionne en construisant simplement la plage avec ,puis en incrémentant chaque élément de la plage avec :)pour rendre la plage unitaire.

Mathematica, 5 octets

Range

Assez simple.

Hexagonie, 19

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

Ou au format hexagonal étendu:

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

Un grand merci à Martin pour avoir proposé ce programme, je l'ai juste joué au golf pour s'adapter à un hexagone de 3 côtés.

Essayez-le en ligne!

Je n'ai pas les fantastiques programmes liés à Hexagony de Timwi, donc cette explication ne sera pas très colorée. Au lieu de cela, vous pouvez lire une énorme tache de texte. N'est-ce pas agréable?

Dans tous les cas, l'IP commence dans le coin supérieur gauche, sur le $, se déplaçant vers l'est si vous imaginez que ce programme a été placé avec le nord orienté vers le haut sur une carte. Le $nous fait sauter la prochaine instruction, qui serait @, qui mettrait fin au programme. Au lieu de cela, nous exécutons ?ce qui définit le bord de mémoire actuel comme étant le numéro d'entrée. Nous arrivons maintenant à la fin de la rangée, ce qui nous amène à la rangée médiane de l'hexagone, toujours en mouvement vers l'Est.

La plupart du reste du programme est une boucle. Nous commençons par .ce qui est un no-op. Ensuite, nous rencontrons une fourchette dans ... euh ... l'hexagone ... l' <instruction fait pivoter l'IP de 60 degrés vers la droite si le bord de mémoire actuel est positif, sinon nous tournons de 60 degrés vers la gauche. Puisque nous nous déplaçons vers l'est, nous nous retrouvons soit avec notre cap vers le sud ou le nord-est. Puisque l'entrée est supérieure à zéro (et donc positive), nous commençons toujours par aller vers le sud-est.

Ensuite, nous avons frappé un >qui nous redirige vers l'est; ces opérateurs ne bifurquent que si vous frappez la partie fourche. Ensuite, nous frappons 'ce qui change le bord de mémoire que nous regardons. Ensuite, nous frappons )qui incrémente la valeur du bord de mémoire actuel. Étant donné que tous les fronts de mémoire commencent à 0, la première fois que nous le faisons, nous obtenons une valeur de 1. Ensuite, nous sautons à la deuxième ligne supérieure et exécutons !ce qui imprime notre numéro. Ensuite, nous passons à un autre bord avec {et stockons la valeur ASCII de M multipliée par 10 plus 8 (778). Ensuite, nous revenons à l'avant-dernière ligne de l'hexagone et frappons le /. Cela nous amène à nous déplacer vers le nord-ouest. Nous passons devant la .rangée du milieu et sortons sur la;en bas à droite. Ceci imprime le mod de bord de mémoire actuel 256 en ASCII. Cela se trouve être une nouvelle ligne. Nous frappons, 'ce qui nous ramène au premier bord qui a la valeur que nous lisons. Le nous frappons /qui nous oblige à nous déplacer à nouveau vers l'Est. Ensuite, nous frappons (ce qui diminue la valeur. =nous amène à faire face à nouveau dans la bonne direction pour le futur saut de bord de mémoire.

Maintenant, comme la valeur est positive (à moins qu'elle ne soit nulle), nous retournons au bas de l'hexagone. Ici, nous frappons .puis nous sautons par-dessus ;pour que rien ne se passe, et nous retournons au début de la boucle. Lorsque la valeur est zéro, nous retournons au début du programme, où le même problème se produit à nouveau mais ?ne parvient pas à trouver un autre nombre, et nous prenons l'autre chemin de branchement. Ce chemin est relativement simple: nous frappons {ce qui change le bord de la mémoire, mais nous ne nous soucions plus, puis nous frappons @qui termine le programme.

MATL, 1 octet

:

Exemple de sortie:

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

Essayez-le en ligne ici

GNU Coreutils, 6 octets

seq $1

réponse partagée à bash pur, voir ci-dessous ...

R, 13 octets

cat(1:scan())

Le corps doit contenir au moins 30 caractères.

Javascript 182 177 160 154 139 138 132 octets (valide)

1 octet enregistré grâce à @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``)}}

La précision arbitraire à la rescousse!

Parce que javascript ne peut compter que jusqu'à 2 ^ 53-1 (merci à @ MartinBüttner de l'avoir signalé), j'avais besoin de créer une précision arbitraire pour ce faire. Il stocke les données dans un tableau, et chaque "tick" il ajoute 1 au dernier élément, puis passe à travers le tableau, et si quelque chose dépasse 9, il définit cet élément à 0 et ajoute 1 à celui de la main gauche.

Essayez-le ici! Remarque: appuyez sur F12 pour voir le résultat, car je ne voulais pas vous faire attendre les zones de texte.

BTW .: J'étais le seul, qui ne savait pas, les opérateurs ternaires sont si utiles en codegolf?

if(statement)executeSomething();

est plus long que

statement?executeSomething():0;

par 1 octet.

Javascript, 28 octets (invalide - ne peut pas compter jusqu'à 2 ⁶⁴ )

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

Java 8, 43/69/94 octets

^{_{Barré 44 est toujours un 44 régulier - attendez, je ne l'ai pas barré je l'ai juste remplacé :(}}

Si je peux retourner un LongStream: ( 43 bytes)

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

Ceci est un lambda pour un Function<Long,LongStream>. Techniquement, je devrais utiliser rangeClosedau lieu de range, car j'en coupe un de mon entrée maximale de cette façon, mais il rangeClosedest plus long que range.

Si je dois imprimer dans la fonction: ( 69 bytes)

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

Ceci est un lambda pour un Consumer<Long>. Techniquement peek, j'abuse , car c'est une opération intermédiaire , ce qui signifie que cette lambda renvoie techniquement un LongStreamcomme le premier exemple; Je devrais utiliser à la forEachplace. Encore une fois, le golf n'est pas un bon code.

Malheureusement, comme longla plage de est un entier 64 bits signé , elle n'atteint pas la requête 2^64-1, mais simplement 2^63-1.

Cependant , Java SE 8 fournit des fonctionnalités pour traiter les longs comme s'ils n'étaient pas signés, en appelant Longexplicitement des méthodes spécifiques sur la classe. Malheureusement, comme Java est toujours Java, c'est assez long, bien que plus court que la version BigInteger qu'il remplace. ( 94 bytes)

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

C'est un Consumer<Long>, comme le précédent.

^{_{Et juste trop longtemps pour éviter le défilement.}}

05AB1E , 1 octet

Code:

L

Essayez-le en ligne! .

Une approche plus intéressante:

FN>,

Explication:

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

Essayez-le en ligne! .

MATLAB, 7 octets

Une fonction anonyme sans nom:

@(n)1:n

Courir comme:

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

Testez-le ici!

Si un programme complet est requis, 17 octets:

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

Testez-le ici!

Haskell, 10 octets

f n=[1..n]

Exemple d'utilisation: f 4-> [1,2,3,4].

MarioLANG , 19 octets

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

Essayez-le en ligne!

Les programmes verticaux sont généralement plus faciles à jouer pour les boucles simples dans MarioLANG. Je ne suis pas sûr de ce que fait l'interprète lorsqu'il rencontre à l' [intérieur d'un ascenseur, mais il semble mettre fin au programme lorsque la cellule actuelle est à 0. C'est probablement une astuce utile en général.

Explication

MarioLANG est un langage de type Brainfuck (avec une bande de mémoire infinie d'entiers de précision arbitraire) où le pointeur d'instruction ressemble à Mario marchant et sautant.

Mario commence dans le coin supérieur gauche et tombe vers le bas. ;lit un entier depuis STDIN et le place dans la cellule mémoire actuelle. Notez maintenant que =Mario est une cellule au sol sur laquelle marcher, "et #forme un ascenseur (avec #le départ) et !fait que Mario s'arrête sur l'ascenseur pour qu'il ne marche pas tout de suite. Le >et <définir sa direction de mouvement. Nous pouvons voir que cela donne une boucle simple, contenant le code suivant:

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

Maintenant, normalement [, conditionnellement, Mario passerait au suivant selon que la cellule actuelle est nulle ou non. Autrement dit, tant que le compteur est différent de zéro, cela ne fait rien. Cependant, il semble que lorsque Mario rencontre un [certain temps dans un ascenseur et que la cellule actuelle se trouve 0, le programme se termine simplement immédiatement avec une erreur, ce qui signifie que nous n'avons même pas besoin de trouver un moyen de le rediriger correctement.

Joe - 2 ou 6

Bien que vous puissiez utiliser la variante inclusive de la fonction de plage.

1R

..c'est ennuyant! Prenons plutôt la somme cumulée ( \/+) d'un tableau de ceux de forme n ( 1~T).

\/+1~T

Pyth - 3 2 octets

1 octets économisés grâce à @DenkerAffe.

Sans utiliser la fonction intégrée.

hM

Essayez-le en ligne .

Pyke, 1 octet

S

Essayez-le ici!

Ou 2 octets sans le intégré

mh

Essayez-le ici!

#h

Essayez-le ici!

Lh

Essayez-le ici!

dc, 15

?[d1-d1<m]dsmxf

Entrée lue depuis stdin. Cela décompte à partir de n, en poussant une copie de chaque numéro dans la pile. La pile est ensuite sortie comme une seule avec la fcommande, donc les nombres sont imprimés dans le bon ordre croissant.

Parce que tous les nombres sont poussés vers la pile, cela risque fort de manquer de mémoire avant de se rapprocher de 2 ^ 64. Si c'est un problème, nous pouvons le faire à la place:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 octets

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

La seule chose intéressante est d'utiliser nx (où n est l'objectif et x la variable incrémentée) pour tester la fin de la boucle while au lieu d'avoir une variable dédiée, donc je finis par avoir nx et n- (nx) = x dans chaque boucle

Remarque : je ne peux compter que jusqu'à 2 ^ 31-1. Eh bien, je suppose que les Terminators ne sont pas un vrai danger après tout.

Piet, 64 Codels

Avec codelsize 20:

Images de trace Npiet

Première boucle:

Trace restante pour n=2:

Remarques

• Pas encore Piet réponse? Permettez-moi de résoudre ce problème avec mon tout premier programme Piet! Cela pourrait probablement être plus court avec de meilleurs rouleaux et moins de manipulation du pointeur ...

• La limite supérieure prise en charge dépend de la mise en œuvre de l'interpréteur. Il serait théoriquement possible de prendre en charge des nombres arbitrairement élevés avec le bon interprète.

• Le délimiteur est ETX(Ascii 3), mais cela ne peut pas être correctement affiché dans cette réponse, je vais donc les laisser de côté. Cela fonctionne dans la console:

Sortie

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Trace Npiet pour 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 octets

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

Prend l'entrée nsous forme de chaîne, devrait prendre en charge jusqu'à 9007199254740991999999999

Expliqué:

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

Entrée lue depuis stdin. bcgère les nombres de précision arbitraires par défaut, donc le 2 ^ 64 max n'est pas un problème.

En fait, 1 octet

R

Boring builtin est ennuyeux. Nécessite une version 64 bits de Python 3 pour obtenir tout le chemin jusqu'à 2**64.

Essayez-le en ligne! (en raison de restrictions de mémoire et de longueur de sortie, l'interpréteur en ligne ne peut pas aller très haut).

Voici une version à 5 octets qui ne nécessite pas Python 3 64 bits et est un peu plus agréable sur l'utilisation de la mémoire:

W;DWX

Essayez-le en ligne! (voir les mises en garde ci-dessus)

Octo-Guacamole floue, 7 octets

^!_[+X]

Explication:

^ 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 octets (non concurrent)

literally, print range(input())

QBASIC, 43 octets

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

Cubix , 17 octets

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

Essayez-le ici

Cubix est un langage 2D créé par @ETHProductions où les commandes sont enveloppées dans un cube. Ce programme encapsule sur un cube avec une longueur de bord de 2 comme suit.

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

• I obtient l'entrée entière
• 0 pousser 0 dans la pile
• - soustraire les éléments supérieurs de la pile
• !si la vérité saute la prochaine commande se @termine
• ; pop le résultat de la soustraction de la pile
• ) incrémenter le haut de la pile
• wdéplacez ip vers la droite et continuez. Cela le fait passer à la ligne suivante
• O sortir le haut de la pile sous forme de nombre
• N pousser le saut de ligne (10) vers la pile
• o sortie d'un saut de ligne
• wdéplacez ip vers la droite et continuez. Cela le fait passer au visage suivant
• !parce que TOS véridique, saute la @fin
• ; sauter le saut de ligne de la pile
• Utourner vers la gauche sur la -soustraction et reprendre à partir de là

Python 2, 37 33 32 33 octets

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

Fonctionne probablement jusqu'à 2**64et au-delà.

Abattu quatre octets grâce à @dieter , et un autre grâce à @orlp . Mais apparemment, comme @ Sp3000 l'a découvert, il range()pourrait y avoir des problèmes avec des valeurs plus élevées, donc la fonction a été remplacée parxrange() . Remarque: même xrange()peut avoir des problèmes, au moins dans 2.7.10 .

Zsh, 12 octets

echo {1..$1}

Cela fonctionne car les variables sont développées avant les accolades.

V, 11 octets

é1@añYpñdd

Puisqu'il contient un méchant UTF-8 et des non imprimables, voici un hexdump réversible:

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

V est une langue inachevée que j'ai écrite, mais cela fonctionne dès le commit 19 . Cette réponse était un peu plus verbeuse que je ne le souhaiterais, mais c'est principalement parce que V n'a aucune connaissance des entiers, seulement des chaînes. C'est donc une réponse décente! Cela va travailler jusqu'à 2 ^ 64, mais il faudra probablement très longtemps.

Pour rendre mon explication plus facile à lire / écrire, je vais travailler avec ce "formulaire lisible par l'homme", qui est en fait la façon dont vous tapez ceci dans vim.

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

Explication:

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

Si les failles sont autorisées, voici une version plus courte qui affiche 1 à n, mais affiche également un 0 (8 octets):

é0@añYp

Et sous une forme lisible:

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

Ceci est plus court car <A-q>à la fin est implicite, donc nous n'en avons pas besoin si nous n'avons pas à supprimer la dernière ligne.