Definamos un número autónomo como un entero positivo, cuyos dígitos aparecen en series de longitud igual a ellos mismos. En otras palabras, cualquier dígito decimal d (excluyendo 0 ) ocurre solo en corridas de longitud exactamente d .

Tarea

Puede elegir cualquiera de los tres métodos enumerados a continuación:

• Dado un número entero n , la salida de la n ésimo número autónomo (ya sea indexado-1 0 o).
• Dado un número entero n , genera los primeros n números autocontenidos.
• Imprime la secuencia indefinidamente.

Ejemplos

• 133322 es un número autónomo porque 3 aparece en una serie de tres 3 , 1 es único y 2 aparece en una serie de dos 2 .

• Por otro lado, 35553355 no lo es, porque, aunque 5 y 3 ocurren cinco y tres veces respectivamente, no forman corridas de dígitos adyacentes.

• 44422 no es autónomo, porque 4 solo ocurre tres veces.

• 12222333 tampoco, porque 2 aparece en una ejecución de cuatro 2 's, y no puede tratarse como dos ejecuciones separadas de dos 2 ' s.

No es sorprendente que este sea OEIS A140057 , y sus primeros términos son:

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

Puede tomar entradas y proporcionar salidas a través de cualquiera de los métodos estándar , en cualquier lenguaje de programación , mientras observa que estas lagunas están prohibidas de manera predeterminada. Este es el código de golf, por lo que gana el código más corto en bytes (en todos los idiomas).

Python 2 , 104 94 83 bytes

-10 bytes gracias al Sr. Xcoder
-11 bytes gracias a 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

Pruébalo en línea!

Mathematica, 66 bytes

Imprime la secuencia indefinidamente

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

Pruébalo en línea!

En TIO, debe finalizar la ejecución para ver el resultado, pero en Mathematica funciona bien.

-12 bytes de Martin Ender

05AB1E , 9 bytes

Devuelve el enésimo término de la secuencia, indexado en 1.

µNÔNγ€gJQ

Pruébalo en línea!

Explicación

µ           # 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 bytes

Devuelve el enésimo término de la secuencia, indexado en 0.

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

Nota : como siempre con las funciones recursivas, el rango de entrada depende del soporte de Optimización de Llamada de Cola y el tamaño de la pila de su motor.

Manifestación

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. versión, 65 bytes

No realiza ninguna entrada e imprime los resultados alert(), uno a la vez.

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

Pruébalo en línea! (Se detiene tan pronto como se excede el tamaño máximo de la pila).

Jalea , 7 bytes

DŒrZEµ#

Pruébalo en línea!

-4 bytes gracias a la sugerencia temprana del Sr. Xcoder .
-1 gracias a Jonathan Allan .

Toma información de STDIN.

CJam , 20 bytes

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

Pruébalo en línea!

Explicación:

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 bytes

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

Brachylog , 10 bytes

≜ℕẹḅ⟨l=h⟩ᵐ

Pruébalo en línea!

Infinitamente genera elementos de la secuencia a través de su variable de entrada. (Si realmente tiene que hacer la impresión en sí, agregue &ẉ⊥). Este es esencialmente un código para resolver el problema de decisión correspondiente con una ≜solución bruta antepuesta a la fuerza bruta primero:

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

Esperaba que esto solo tomara 9 bytes, pero ḅparece requerir un explícito ẹpara separar los dígitos de un número en ejecuciones.

JavaScript 4, 83 80 bytes

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 bytes

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

Pruébalo en línea!

Devuelve el nelemento -th de la secuencia, indexado a cero.

R , 56 bytes

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

Pruébalo en línea!

Utiliza la codificación de longitud de ejecución en el número dividido. Devuelve verdadero si todas las longitudes son iguales a los valores.

Nota: He cargado la methodsbiblioteca en TIO para ponerme ela trabajar.

Stax , 10 bytes

Ç≡∟Öz≈¢αV¢

Ejecutar y depurarlo

Este programa filtra todos los enteros positivos con un filtro. Los dígitos están codificados en longitud de ejecución. Para cada ejecución, el dígito debe ser igual a la longitud de la ejecución.

Pyth, 12

.f.AqMr8jZ10

Prueba en línea!

Perl 5 -p , 48 bytes

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

Pruébalo en línea!

Devuelve el enésimo elemento, 1 indexado.

Java 10, 121 bytes

Una lambda de inta int. La función toma un índice n y devuelve el n º valor de secuencia (1-indexado).

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

Pruébalo en línea

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