Vamos definir um número independente como um número inteiro positivo, cujos dígitos aparecem em execuções de comprimento iguais apenas a si mesmos. Em outras palavras, qualquer dígito decimal d (excluindo 0 ) ocorre apenas em execuções de comprimento exatamente d .

Tarefa

Você pode escolher qualquer um dos três métodos listados abaixo:

• Dado um número inteiro n , a saída do n th (0 ou 1-indexado) número de auto-contido.
• Dado um número inteiro n , imprima os primeiros n números independentes.
• Imprima a sequência indefinidamente.

Exemplos

• 133322 é um número independente, porque 3 aparece em uma execução de três 3 's, 1 é único e 2 ocorre em uma execução de dois 2 ' s.

• Por outro lado, 35553355 não é, porque, embora 5 e 3 ocorram cinco e três vezes respectivamente, eles não formam execuções de dígitos adjacentes.

• 44422 não é independente, porque 4 ocorre apenas três vezes.

• 12222333 também não é, porque 2 aparece em uma execução de quatro 2 's e não pode ser tratado como duas execuções separadas de dois 2 ' s.

Não surpreende que seja o OEIS A140057 e seus primeiros termos são:

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

Você pode receber e fornecer saída através de qualquer um dos métodos padrão , em qualquer linguagem de programação , observando que essas brechas são proibidas por padrão. Esse é o código golf, portanto o código mais curto em bytes (em todos os idiomas) vence.

Python 2 , 104 94 83 bytes

-10 bytes graças ao Sr. Xcoder
-11 bytes graças 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

Experimente online!

Mathematica, 66 bytes

Imprime a sequência indefinidamente

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

Experimente online!

No TIO, é necessário encerrar a execução para ver o resultado, mas no Mathematica funciona bem.

-12 bytes de Martin Ender

05AB1E , 9 bytes

Retorna o enésimo termo da sequência, indexada em 1.

µNÔNγ€gJQ

Experimente online!

Explicação

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

Retorna o n-ésimo termo da sequência, indexada em 0.

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

NB : Como sempre com funções recursivas, o intervalo de entrada depende do suporte da Otimização de chamada de cauda e do tamanho da pilha do seu mecanismo.

Demo

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. versão, 65 bytes

Não recebe entrada e imprime os resultados alert(), um de cada vez.

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

Experimente online! (Pára assim que o tamanho máximo da pilha é excedido.)

Geléia , 7 bytes

DŒrZEµ#

Experimente online!

-4 bytes graças à sugestão inicial do Sr. Xcoder .
-1 graças a Jonathan Allan .

Recebe entrada de STDIN.

CJam , 20 bytes

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

Experimente online!

Explicação:

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

Braquilog , 10 bytes

≜ℕẹḅ⟨l=h⟩ᵐ

Experimente online!

Infinitamente gera elementos da sequência através de sua variável de entrada. (Se ele realmente tiver que fazer a impressão em si, acrescente &ẉ⊥.) Este é essencialmente o código para resolver o problema de decisão correspondente , com um ≜prefixo para força bruta primeiro das menores soluções:

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

Eu esperava que isso levasse apenas 9 bytes, mas ḅparece exigir um explícito ẹpara separar os dígitos de um número em execuções.

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)[$_]}

Experimente online!

Retorna o n-ésimo elemento da sequência, indexado a zero.

R , 56 bytes

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

Experimente online!

Utiliza a codificação de duração da execução no número de divisão. Retorna true se todos os comprimentos forem iguais aos valores.

Nota: Carreguei a methodsbiblioteca no TIO para começar ela trabalhar.

Stax , 10 bytes

Ç≡∟Öz≈¢αV¢

Execute e depure

Este programa filtra todos os números inteiros positivos com um filtro. Os dígitos são codificados no comprimento da execução. Para cada execução, o dígito deve ser igual ao comprimento da execução.

Pyth, 12

.f.AqMr8jZ10

Teste online!

Perl 5 -p , 48 bytes

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

Experimente online!

Retorna o n-ésimo elemento, 1 indexado.

Java 10, 121 bytes

Um lambda de intpara int. A função tem um índice n e retorna o n ° (1-indexado) valor sequência.

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

Experimente Online

Ungolfed

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