Infiniment nombreux ℕ

Question

Contexte:

Une séquence de naturels infinis est une séquence qui contient chaque nombre naturel une infinité de fois.

Pour clarifier, chaque numéro doit être imprimé plusieurs fois!

Le défi:

Sortie d'une séquence de naturels infinis avec le code le plus court.

Règles:

1. Chaque nombre doit être séparé par une quantité (finie) de caractères visibles, d'espaces blancs ou de nouvelle ligne qui ne sont pas des chiffres.
2. Le programme ne peut pas se terminer (à moins que vous n'ayez écrit tous les nombres d'une manière ou d'une autre).
3. Toute manière d'écrire une telle séquence est acceptable.

Exemples:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
...

1, 1, 2, 1, 2, 3, 1, 2, 3, 4...

Notez que nous écrivons tous les naturels de 1 à N pour tout N ∈ ℕ.

Les commentaires et les modifications de la question sont les bienvenus. Inspiré de mon examen de calcul.

Answer 1

Scratch 3.0 , 13 20 blocs / 121 70 octets

En tant que syntaxe SB:

define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n

Cela dit chaque terme de la séquence. Un délai peut être ajouté afin que les numéros ne se déclenchent pas rapidement.

Je n'ai jamais vu de scratch aussi abusé. Vous appelez la fonction de nom vide avec des paramètres vides . Mon Dieu. Tout ce qui économise des octets!

-51 merci à @att

Essayez-le sur Scratch

Explication à venir.

Answer 2

Husk , 2 octets

ḣN

Essayez-le en ligne!

Première réponse de Husk! Utilise également la séquence de la question

Comment ça fonctionne

ḣN - Main program
 N - The infinite list [1, 2, 3, ...]
ḣ  - Prefixes; [[1], [1, 2], [1, 2, 3], ...]

Answer 3

05AB1E , 2 octets

∞L

Essayez-le en ligne! Le pied de page met en forme la sortie comme l'exemple de l'article.

∞pousse une liste de tous les nombres naturels, Lprend la plage [1 .. n]pour chaque nombre.

Answer 4

R , 26 25 24 octets

-1 octet grâce à Dominic van Essen

repeat cat(rpois(9,9)+1)

Essayez-le en ligne!

Produit une séquence infinie aléatoire d'entiers, tirée de \$Poisson(9)\$distribution (+1 pour éviter de produire des 0). Ils sont sortis par lots de 9 à la fois, pour plus "d'efficacité". Toute valeur positive de la moyenne fonctionnerait; l'utilisation d'une moyenne de 9 maximise la variance pour les nombres à 1 caractère.

Tous les nombres apparaissent infiniment souvent en ce sens que pour tout entier \$k\$, le nombre prévu d'occurrences de \$k\$dans le premier \$n\$les réalisations vont à \$\infty\$comme \$n\to\infty\$:

$$E\left[\sum_{i=1}^n\mathbb{I}_{X_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$

Les appels catsignifient que les nombres entiers dans un lot de 9 sont séparés par des espaces, mais qu'il n'y a pas de séparateur entre les lots. La grande majorité des nombres à 3 et 4 chiffres dans la sortie sont dus à cet artefact, mais il existe une garantie théorique que de tels nombres (et des nombres plus grands) seront éventuellement générés, du moins si nous supposons que le générateur de nombres aléatoires sous-jacent est parfait.

---

Pour une plus grande variance, nous pouvons suivre la suggestion de Giuseppe pour le même nombre d'octets:

repeat cat(1%/%runif(9))

Essayez-le en ligne!

Cela induit plus de 1s et des nombres plus grands (y compris quelques très grands nombres grâce à l' catartefact). Encore une fois, le nombre d'occurrences de n'importe quel entier va à l'infini lorsque la taille de la sortie passe à l'infini.

---

Deux autres réponses R sont plus courtes, utilisant des méthodes déterministes: celles de Giuseppe et de Dominic van Essen

Answer 5

Python 2 , 31 octets

R=1,
while 1:print R;R+=len(R),

Essayez-le en ligne!

Merci à @Danis d'avoir sauvé un octet ici R+=R[-1]+1,. Ce

Impressions:

(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
    ...

Accumule une liste de nombres de 1 à n (sauf 1 apparaît deux fois) à chaque fois en ajoutant le dernier élément plus un.

32 octets

R=[1]
for x in R:print R;R+=x+1,

Essayez-le en ligne!

---

Python 2 , 30 octets (conjecturé)

n=2
while 1:print~-2**n%n;n+=1

Essayez-le en ligne!

La séquence de \$2^n \bmod n\$( A015910 ) est supposé prendre toutes les valeurs \$k \geq 0\$sauf \$k=1\$. Je ne sais pas s'il est également supposé que chaque valeur apparaît infiniment plusieurs fois, mais cela semble cohérent avec les solutions connues pour des valeurs spécifiques .

Nous calculons plutôt \$(2^n-1) \bmod n\$, ce qui fait \$0\$plutôt que \$1\$ être la seule valeur manquante (si la conjecture est vraie).

En regardant la sortie, vous pourriez penser que \$2\$n'est jamais sorti , mais il apparaît en fait en premier pour \$n=4700063497\$et pour des valeurs progressivement plus élevées dans A050259 .

---

Python 2 , 33 octets

R=[1]
for x in R:print x;R+=x+1,1

Essayez-le en ligne!

C'est plus long, mais c'est assez astucieux, imprimer la séquence ABACABA .

Answer 6

Haskell , 17 octets

[[1..x]|x<-[1..]]

Essayez-le en ligne!

Puisque le défi semble autoriser une sortie non plate, nous pouvons simplement générer une liste des listes [1],[1,2],[1,2,3,],..., comme suggéré par @AZTECCO.

Haskell , 19 octets

l=1:do x<-l;[x+1,1]

Essayez-le en ligne!

Une liste plate infinie définie de manière récursive avec la séquence ABACABA1,2,1,3,1,2,1,4,... ( A001511 ).

Une variante de même longueur:

l=(:[1]).succ=<<0:l

Essayez-le en ligne!

20 octets

l=do x<-[1..];[1..x]

Essayez-le en ligne!

Compter 1,1,2,1,2,3,1,2,3,4,..., mais comme une liste plate.

Answer 7

Bash + GNU Coreutils, 20 ans

seq -fseq\ %g inf|sh

Essayez-le en ligne! - Expire après 60 secondes.

Answer 8

sed 4.2.2 , 20

:;s/(1*).*/1\1 &/p;b

Essayez-le en ligne!

La sortie est unaire, selon ce méta consensus .

Answer 9

Bash , 20 octets

seq inf|xargs -l seq

Essayez-le en ligne!

Answer 10

R , 21 octets

(également identifié presque simultanément par Robin Ryder)

while(T<-T+1)cat(T:0)

Essayez-le en ligne!

Similaire à l'exemple de séquence, mais chaque sous-série est inversée et la valeur initiale de chaque sous-série est représentée par un zéro initial (donc, 03pour 3, par exemple).

Si vous n'aimez pas les zéros initiaux, regardez la version précédente en utilisant show(ci-dessous), ou la réponse de Giuseppe .

---

R , 23 22 octets

Edit: -1 octet grâce à Robin Ryder

while(T<-T+1)show(1:T)

Essayez-le en ligne!

Renvoie la séquence utilisée dans l'exemple, plus un nombre infini supplémentaire de copies du nombre 1.
Chaque nombre est séparé par un espace " ", une nouvelle ligne plus crochet, " \n[" ou un crochet plus espace " [ ".

Joueur de 2 octets (au moment de la publication, au moins ...) que les deux autres réponses R ...

Answer 11

Gelée , 4 octets

‘RṄß

Essayez-le en ligne!

Je pense que cela génère tous les nombres un nombre infini de fois, mais comme c'est un format de sortie différent, je ne suis pas sûr à 100%

Comment ça fonctionne

‘RṄß - Main link. Left argument is initially n = 0
‘    - Increment
 R   - Range
  Ṅ  - Print
   ß - Recursively run the main link

Pour n = 0, ‘RṄsorties [1]. Nous récurons ensuite, en utilisant n = [1]. ‘RṄpuis sorties [[1, 2]], et nous récurons à nouveau, en utilisant n = [[1, 2]], quelles sorties [[[1, 2], [1, 2, 3]]]etc.

Answer 12

Octave , 29 28 octets

do disp(fix(1/rand)) until 0

Essayez-le en ligne!

Cela génère une séquence \$(x_k)\$de nombres naturels aléatoires indépendants et distribués de manière identique. Chaque valeur \$x_k\$est obtenu comme \$1/r\$arrondi vers zéro, où \$r\$a une distribution uniforme sur l'intervalle \$(0,1)\$.

Pour un index donné \$k\$, et pour tout \$n \in \mathbb N\$, il y a une probabilité non nulle que \$x_k=n\$(ignorant les inexactitudes en virgule flottante). Par conséquent, avec probabilité \$1\$chaque \$n\$apparaît infiniment souvent dans la séquence \$(x_k)\$.

Answer 13

R , 25 21 octets

repeat T=print(T:0+1)

Essayez-le en ligne!

Impressions 2..1, 3..1, 4..1et ainsi de suite.

Merci à Robin Ryder pour -4 octets.

Cela fonctionne car printrenvoie son premier argument de manière invisible.

Answer 14

Befunge , 5 octets

>1+?.

Essayez-le en ligne!

À chaque sortie, il y a 50% de chances que le nombre actuel soit imprimé et remis à 1, et 50% de chances qu'il 2soit imprimé et que le nombre actuel augmente d'un certain nombre impair aléatoire (suivant une distribution exponentielle). Cela peut se produire plusieurs fois, donc des nombres impairs peuvent également être générés.

Chaque nombre naturel a une probabilité non nulle de se produire, donc il sera finalement imprimé une infinité de fois.

Explication

>1+?.
>      # Go east.
 1+    # Initialize a counter to 1.
   ?   # Go in a random direction.
       # If the instruction pointer goes west:
  +    # Add the top two stack elements together.
       # If there is a 2 on top, this adds it to the counter.
       # If not, this does nothing.
 1     # Create a new 1 on the top of the stack.
>      # Go east.
 1+    # Add 1 to get 2, which remains on top of the counter.
   ?   # Repeat.
       
   ?   # If the IP goes east:
    .  # Print and delete the top of the stack.
>      # Go east.
 1+    # Add 1.
       # If there was a 2 that was printed and the counter remains, the 1 gets added to it.
       # If the counter was printed instead, this creates a new 1.
   ?   # Repeat.

   ?   # If the IP goes north or south, it wraps around to the ? instruction and repeats.

---

Befunge-98 , 14 octets

]:.1-:0`j
]:+!

Essayez-le en ligne!

Une solution déterministe, imprimant chaque plage de 1 à ndans l'ordre décroissant.

Explication

]           # Turn right (to the south) and go to the second line.

]:+!      
]           # Turn right again (to the west).
   !        # Take the logical NOT of the secondary counter (which is now 0) to get 1.
  +         # Add the 1 to the main counter.
 :          # Duplicate the main counter to form a secondary counter.
]           # Turn right (to the north) and go to the first line.

]:.1-:0`j 
]           # Turn right (to the east).
 :          # Duplicate the secondary counter.
  .         # Print and delete the duplicate.
   1-       # Subtract 1 from the secondary counter.
     0`     # Is the secondary counter greater than 0?
       j    # If so, jump over the ] instruction and repeat the first line.
]           # If not, turn right (to the south) and go to the second line.

Answer 15

transporter , 27 octets

   >v
1","@"}
^+^<#-1
1+<<<

Essayez-le en ligne!

Cela compte à rebours à partir des nombres successifs.

Answer 16

Wolfram Language (Mathematica) , 25 octets

Do[Print@n,{m,∞},{n,m}]

Essayez-le en ligne!

-1 octet @att

Answer 17

Brachylog , 4 octets

⟦₁ẉ⊥

Essayez-le en ligne!

  ẉ     Print with a newline
⟦₁      the range from 1 to something,
   ⊥    then try again.

Answer 18

J , 13 octets

$:@,~[echo@#\

Essayez-le en ligne!

Sorties 1, 1 2, 1 2 3 4, 1 2 3 4 5 6 7 8, etc, avec chaque numéro sur sa propre ligne.

• echo@#\Affiche les longueurs de préfixe de la liste actuelle, c'est-à-dire 1..noù n est la longueur actuelle de la liste. Ceci est fait comme un effet secondaire.
• $:@,~Ajoutez la liste à elle ,~- même et appelez la fonction de manière récursive $:@.

Answer 19

Rouille , 54 octets

(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))

Essayez-le en ligne

Answer 20

Rubis , 17 octets

loop{p *1..$.+=1}

Essayez-le en ligne!

Answer 21

Charbon , 8 octets

Ｗ¹«Ｉ⊕ⅉＤ⸿

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Fonctionne en imprimant à plusieurs reprises le numéro suivant sur la toile, puis en vidant la totalité de la toile.

2 octets pour une version qui imprime le \$ n \$ème terme d'une séquence:

ＩΣ

Essayez-le en ligne! Explication: imprime simplement la somme numérique de l'entrée. Étant donné n'importe quel nombre naturel \$ n \$, toutes les valeurs de la forme \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$avoir une somme numérique de \$ n \$pour chaque \$ m \$, ainsi chaque nombre naturel apparaît infiniment souvent.

Answer 22

C (gcc) , 43 octets

i;main(j){for(;;)printf("%d ",j=--j?:++i);}

Essayez-le en ligne!

Answer 23

JavaScript (V8) , 26 octets

for(a=b='';;)write(a+=--b)

Essayez-le en ligne!

Caractère -utilisé comme séparateur et la sortie commence par lui, donc je ne suis pas vraiment sûr que cela soit acceptable.

Answer 24

C (gcc) , ^{52 49} 44 octets

Sauvé 5 octets grâce à AZTECCO !!!

f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}

Essayez-le en ligne!

Answer 25

Java (JDK) , 61 octets

v->{for(int i,j=2;;j++)for(i=0;++i<j;)System.out.println(i);}

Essayez-le en ligne!

Edit: Merci @user de me raser quelques octets et de m'avoir aidé à apprendre quelque chose aujourd'hui! Un grand merci à @KevinCruijssen pour -2 octets.

Answer 26

Bash, 21 octets

s(){ seq $[++n];s;};s

1
1
2
1
2
3
…

Exécutez la version 21B sur Try It Online

Cela définit une fonction squi s'exécute seq NUMBERoù NUMBERcommence 1et s'incrémente à chaque exécution, puis elle s'exécute elle-même de manière récursive. Après la définition, nous courons s.

Pour que le coût de 5B soit spécifié -s\ (le séparateur est un caractère espace), il peut être adapté à une solution une réponse par ligne à 26 octets:

s(){ seq -s\  $[++n];s;};s

1
1 2
1 2 3
…

Exécutez la version 26B sur Try It Online

Answer 27

Zsh, 29 .. 19 octets

Solution par @AdamKatz: essayez-le en ligne!

for ((;++i;))seq $i

_{19 octets, port de bash: s(){seq $[++n];s};s
25 octets (par @AdamKatz): for ((;++i;))echo {1..$i}
25 octets : for ((;;i++))shuf -i 1-$i
26 octets (par @AdamKatz): for ((;;))echo {1..$[++i]}
29 octets : for ((i=1;;))echo {1..$[i++]}
j'ai essayé d'utiliser /dev/randompour une alternative mais c'était le bordel!}

Answer 28

Perl 5 , 22 20 octets

say while$_.=++$i.$"

Essayez-le en ligne!

Answer 29

AWK , 34 octets

{for(;;++i)for(j=0;j++<i;)print j}

Essayez-le en ligne!

Answer 30

APL (Dyalog Unicode) , 12 11 octets (SBCS)

1 octet enregistré grâce à @ovs

{∇1+⍴⎕←⍳⍵}1

Essayez-le en ligne!

Celui-ci utilise également la séquence de la question.