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.

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!

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

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

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

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

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

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.

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

Haskell , 70 octets

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

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.

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)

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.

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.

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.

Pyth, 12

.f.AqMr8jZ10

Testez en ligne!

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

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;
}