Définissons un nombre autonome comme un entier positif, dont les chiffres apparaissent dans des longueurs égales à eux-mêmes uniquement. En d'autres termes, tout chiffre décimal d (à l'exclusion de 0 ) n'apparaît que dans des séries de longueur exactement d .

Tâche

Vous pouvez choisir l'une des trois méthodes énumérées ci-dessous:

Étant donné un entier n , sortez le n ème nombre (indexé 0 ou 1).
Étant donné un entier n , sortez les n premiers nombres autonomes.
Imprimez la séquence indéfiniment.

Exemples

133322 est un nombre autonome car 3 apparaît dans une séquence de trois 3 , 1 est unique et 2 apparaît dans une séquence de deux 2 .
D'un autre côté, 35553355 ne l'est pas, car, bien que 5 et 3 se produisent respectivement cinq et trois fois, ils ne forment pas des séries de chiffres adjacents.
44422 n'est pas autonome, car 4 n'apparaît que trois fois.
12222333 n'est pas non plus, car 2 apparaît dans une série de 4 2 et il ne peut pas être traité comme deux séries distinctes de 2 2 .

Sans surprise, il s'agit d' OEIS A140057 , et ses premiers termes sont:

1, 22, 122, 221, 333, 1221, 1333, 3331, 4444, 13331, 14444, 22122, 22333, 33322, 44441, 55555, 122122, 122333, 133322, 144441, 155555

Vous pouvez prendre des entrées et fournir des sorties via l'une des méthodes standard , dans n'importe quel langage de programmation , tout en notant que ces failles sont interdites par défaut. Il s'agit du code golf, donc le code le plus court en octets (dans toutes les langues) gagne.

— M. Xcoder
source

8

Python 2 , 104 94 83 octets

-10 octets grâce à M. Xcoder
-11 octets grâce à Jonathan Allan

i=0
while 1:
 if`i`==''.join(d*int(d)for c,d in zip(`-i`,`i`)if d!=c):print i
 i+=1

Essayez-le en ligne!

— ovs
source

... est-ce réellement acceptable, car il tombera une fois idevient long ? Il peut être nécessaire de l' utiliserstr (je ne suis cependant jamais vraiment sûr de ces choses).

— Jonathan Allan

1

@JonathanAllan c'est une question intéressante. Normalement, nous sommes autorisés à supposer que c'est dans le type entier standard , pas long , mais Python ne rend pas cette distinction très claire ...

— FlipTack

6

Mathematica, 66 octets

Imprime la séquence indéfiniment

Do[##&&Print@t&@@(#==Tr[1^{##}]&@@@Split@IntegerDigits@t),{t,∞}]

Essayez-le en ligne!

Dans TIO, vous devez mettre fin à l'exécution pour voir le résultat, mais dans Mathematica fonctionne très bien.

-12 octets de Martin Ender

— J42161217
source

6

05AB1E , 9 octets

Renvoie le nième terme de la séquence, indexé sur 1.

µNÔNγ€gJQ

Essayez-le en ligne!

Explication

µ           # loop over increasing N until counter equals input
 NÔ         # push N with consecutive equal elements deduplicated
   Nγ       # push N grouped into runs of consecutive equal elements
     €g     # get the length of each run
       J    # join to a number
        Q   # check for equality
            # if true, implicitly increment counter

— Emigna
source

Une source d'inspiration possible de mon approche sur 10 octets:µNγD€gs€ÙQ

— M. Xcoder

6

JavaScript (ES6), 76 71 68 octets

Renvoie le nième terme de la séquence, indexé 0.

f=(n,k)=>+(k+'').replace(/(.)\1*/g,s=>s.length^s[0])||n--?f(n,-~k):k

NB : Comme toujours avec les fonctions récursives, la plage d'entrée dépend du support de Tail Call Optimization et de la taille de la pile de votre moteur.

Démo

Afficher l'extrait de code

f=(n,k)=>+(k+'').replace(/(.)\1*/g,s=>s.length^s[0])||n--?f(n,-~k):k

for(n = 0; n <= 10; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Développer l'extrait

Alt. version, 65 octets

Ne prend aucune entrée et imprime les résultats avec alert(), un à la fois.

f=k=>f(-~k,+(k+'').replace(/(.)\1*/g,s=>s.length^s[0])||alert(k))

Essayez-le en ligne! (Arrête dès que la taille maximale de la pile est dépassée.)

— Arnauld
source

4

Gelée , 7 octets

DŒrZEµ#

Essayez-le en ligne!

-4 octets grâce à la première suggestion de M. Xcoder .
-1 merci à Jonathan Allan .

Prend l'entrée de STDIN.

— Erik le Outgolfer
source

2

CJam , 20 octets

1{_Abe`::=:*{_p}&)}h

Essayez-le en ligne!

Explication:

1                       push 1
 {                }h    while TOS is truthy (i.e. forever):            example iteration: 14444
  _                       duplicate                                                       14444 14444       
   Ab                     convert to base 10 (get decimal digits)                         14444 [1 4 4 4 4]
     e`                   run-length encode (array of two-element arrays)                 14444 [[1 1] [4 4]]
       :                  map over the array:
        :                   fold between the two array elements with:
         =                    equality                                                    14444 [1 1]
          :               fold between the array elements with:
           *                multiplication (a.k.a. logical AND for 1 or 0)                14444 1
            {  }&         if this yields a result of 1:
             _              duplicate the number and                                      14444 14444
              p             print it                                                      14444 (output 14444)
                 )        increment the number                                            14445

— Esolanging Fruit
source

2

Haskell , 70 octets

import Data.List
filter(all(\s->read[s!!0]==length s).group.show)[1..]

— Xiyng
source

1

Vous pouvez laisser tomber le leader x=selon nos règles de golf .

— Laikoni

2

Brachylog , 10 octets

≜ℕẹḅ⟨l=h⟩ᵐ

Essayez-le en ligne!

Génère à l'infini des éléments de la séquence via sa variable d'entrée. (S'il doit réellement faire l'impression lui-même, ajoutez-le &ẉ⊥.) Il s'agit essentiellement d'un code pour résoudre le problème de décision correspondant avec un ≜préfixé pour forcer brutalement les plus petites solutions en premier:

        ᵐ    For every
  ḅ          run of
 ẹ           digits in
             the input variable
ℕ            (which is a non-negative integer),
   ⟨l  ⟩     its length
   ⟨  h⟩     and its first element
   ⟨ = ⟩     are equal.

Je m'attendais à ce que cela ne prenne que 9 octets, mais ḅsemble nécessiter une explicite ẹpour séparer les chiffres d'un nombre en exécutions.

— Chaîne indépendante
source

1

JavaScript 4, 83 80 octets

for(i=0;;)+(++i+'').replace(/(.)\1*/g,function(x,y){return y^x.length})||alert(i)

for(i=0;i<1000;)+(++i+'').replace(/(.)\1*/g,function(x,y){return y^x.length})||alert(i)

Développer l'extrait

— l4m2
source

"Javascript 1"? Existe-t-il un tel nom de langue?

— user202729

Je veux dire que cela fonctionne puisque JavaScript apparaît, je ne sais pas si le nom est correct

— l4m2

désolé il ne semble pas fonctionner en js1. J'ai lu et je n'ai trouvé aucun remplaçant

— l4m2

1

Perl 6 , 49 octets

{(grep /^((\d)$0*:<?{$/.comb==$0}>)+$/,^Inf)[$_]}

Essayez-le en ligne!

Renvoie le n-ième élément de la séquence, indexé zéro.

— Sean
source

Le \dpeut être.

— Jo King

1

R , 56 octets

function(n)all((r=rle(el(strsplit(c(n,''),''))))$l==r$v)

Essayez-le en ligne!

Utilise l'encodage de la longueur d'exécution sur le numéro de fractionnement. Renvoie vrai si toutes les longueurs sont égales aux valeurs.

Remarque: j'ai chargé la methodsbibliothèque dans TIO pour me mettre elau travail.

— MickyT
source

1

Stax , 10 octets

Ç≡∟Öz≈¢αV¢

Exécuter et déboguer

Ce programme filtre tous les entiers positifs avec un filtre. Les chiffres sont encodés en longueur. Pour chaque série, le chiffre doit être égal à la longueur de la série.

— récursif
source

0

Pyth, 12

.f.AqMr8jZ10

Testez en ligne!

10 octets:.fqFCr8jZT

— Erik the Outgolfer

0

Perl 5 `-p` , 48 octets

++$\=~s|(.)\1*|$1-length$&&&redo|gre for 1..$_}{

Essayez-le en ligne!

Renvoie le nième élément, 1 indexé.

— Xcali
source

0

Java 10, 121 octets

Un lambda de intà int. La fonction prend un index n et renvoie la n ème valeur (1 indexée) de la séquence.

n->{int x=0,m=1;for(;n>0;n-=m,m=1)for(var p:(++x+"").split("(?<=(.))(?!\\1)"))m=p.length()==p.charAt(0)-48?m:0;return x;}

Essayez-le en ligne

Non golfé

n -> {
    int x = 0, m = 1;
    for (; n > 0; n -= m, m = 1)
        for (var p : (++x + "").split("(?<=(.))(?!\\1)"))
            m = p.length() == p.charAt(0) - 48 ? m : 0;
    return x;
}

— Jakob
source

La séquence de nombres autonomes

Tâche

Exemples

Python 2 , 104 94 83 octets

Mathematica, 66 octets

05AB1E , 9 octets

JavaScript (ES6), 76 71 68 octets

Démo

Alt. version, 65 octets

Gelée , 7 octets

CJam , 20 octets

Haskell , 70 octets

Brachylog , 10 octets

JavaScript 4, 83 80 octets

Perl 6 , 49 octets

R , 56 octets

Stax , 10 octets

Pyth, 12

Perl 5 -p , 48 octets

Java 10, 121 octets

Non golfé

Perl 5 `-p` , 48 octets