Definiamo un numero indipendente come un numero intero positivo, le cui cifre appaiono in serie di lunghezza pari solo a se stesse. In altre parole, qualsiasi cifra decimale d (escluso 0 ) si verifica solo in esecuzioni di lunghezza esattamente d .

Compito

Puoi scegliere uno dei tre metodi elencati di seguito:

• Dato un intero n , uscita n ° (0 o 1-indicizzati) Numero autonoma.
• Dato un numero intero n , genera i primi n numeri indipendenti.
• Stampa la sequenza indefinitamente.

Esempi

• 133322 è un numero autonomo perché 3 appare in una sequenza di tre 3 , 1 è singolo e 2 si verifica in una sequenza di due 2 .

• D'altra parte, 35553355 non lo è, perché, sebbene 5 e 3 si verifichino rispettivamente cinque e tre volte, non formano sequenze di cifre adiacenti.

• 44422 non è autonomo, perché 4 si verifica solo tre volte.

• Neanche 12222333 , perché 2 appare in una sequenza di quattro 2 e non può essere trattato come due corse separate di due 2 .

Non sorprende che questo sia OEIS A140057 e i suoi primi termini sono:

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

Puoi prendere input e fornire output attraverso uno qualsiasi dei metodi standard , in qualsiasi linguaggio di programmazione , osservando che queste scappatoie sono proibite per impostazione predefinita. Questo è il codice golf, quindi vince il codice più breve in byte (in ogni lingua).

Python 2 , 104 94 83 byte

-10 byte grazie a Mr. Xcoder
-11 byte grazie 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

Provalo online!

Mathematica, 66 byte

Stampa la sequenza indefinitamente

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

Provalo online!

In TIO devi terminare l'esecuzione per vedere il risultato ma in Mathematica funziona bene.

-12 byte da Martin Ender

05AB1E , 9 byte

Restituisce l'ennesimo termine della sequenza, 1 indicizzato.

µNÔNγ€gJQ

Provalo online!

Spiegazione

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

Restituisce l' ennesimo termine della sequenza, indicizzato 0.

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

NB : Come sempre con le funzioni ricorsive, l'intervallo di input dipende dal supporto dell'ottimizzazione delle chiamate di coda e dalle dimensioni dello stack del motore.

dimostrazione

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. versione, 65 byte

Non accetta input e stampa i risultati con alert(), uno alla volta.

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

Provalo online! (Si interrompe non appena viene superata la dimensione massima dello stack.)

Gelatina , 7 byte

DŒrZEµ#

Provalo online!

-4 byte grazie al suggerimento iniziale di Mr. Xcoder .
-1 grazie a Jonathan Allan .

Riceve input da STDIN.

CJam , 20 byte

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

Provalo online!

Spiegazione:

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 byte

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

Brachylog , 10 byte

≜ℕẹḅ⟨l=h⟩ᵐ

Provalo online!

Genera infinitamente elementi della sequenza attraverso la sua variabile di input. (Se in realtà deve eseguire la stampa stessa, append &ẉ⊥.) Questo è essenzialmente un codice per risolvere il corrispondente problema decisionale con una ≜preposta a forzare prima le soluzioni più piccole:

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

Mi aspettavo che questo impiegasse solo 9 byte, ma ḅsembra richiedere un esplicito ẹper separare le cifre di un numero in esecuzioni.

JavaScript 4, 83 80 byte

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 byte

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

Provalo online!

Restituisce il n-th elemento della sequenza, indicizzato a zero.

R , 56 byte

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

Provalo online!

Utilizza la codifica della lunghezza della corsa sul numero diviso. Restituisce vero se tutte le lunghezze sono uguali ai valori.

Nota: ho caricato la methodslibreria in TIO per mettermi elal lavoro.

Stax , 10 byte

Ç≡∟Öz≈¢αV¢

Esegui ed esegui il debug

Questo programma filtra tutti i numeri interi positivi con un filtro. Le cifre sono codificate in base alla lunghezza. Per ogni corsa, la cifra deve essere uguale alla lunghezza della corsa.

Pyth, 12

.f.AqMr8jZ10

Test online!

Perl 5 -p , 48 byte

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

Provalo online!

Restituisce l'n-esimo elemento, 1 indicizzato.

Java 10, 121 byte

Un lambda da inta int. La funzione accetta un indice n e restituisce il n ° (1-indicizzato) valore di sequenza.

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

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