Supponiamo che una sottostringa sia una sezione continua di una stringa originale. Ad esempio catè una sottostringa di concatenate. Diremo che una sottostringa corretta è una sottostringa che non è uguale alla stringa originale. Ad esempio concatenateè una sottostringa concatenatema non una sottostringa corretta. (le stringhe a carattere singolo non hanno sottostringhe appropriate)

Definiremo ora una sequenza usando questi termini. Il n esimo termine in questa sequenza sarà il numero più piccolo in modo tale che non v'è una vera e propria sottostringa della sua rappresentazione binaria che non è una sottostringa di qualsiasi termine precedente nella sequenza. Il primo termine è 10.

Come esercizio, generiamo i primi 5 termini. Lavorerò in binario per semplificare le cose.

Il primo termine è 10. Poiché 11il numero più piccolo successivo, ha solo una sottostringa corretta, 1che è anche una sottostringa di 10, 11non è nella sequenza. 100tuttavia contiene la sottostringa corretta 00che non è una sottostringa di 10così 100è il nostro prossimo termine. Il prossimo è 101che contiene la sottostringa corretta unica che 01lo aggiunge alla sequenza, quindi 110contiene la sottostringa corretta 11che è nuova aggiungendola alla sequenza.

Ora abbiamo

10, 100, 101, 110

111è il prossimo ma contiene solo le sottostringhe 1e 11non è un termine. 1000tuttavia contiene l' 000aggiunta alla sequenza.

Ecco i primi termini della coppia in decimale

2, 4, 5, 6, 8, 9, 10, 11, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 30, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 50, 54, 56, 58

Compito

O

• Prendere n come input e generare il n esimo termine in questa sequenza (0 o 1 indicizzato)

• Emette continuamente i termini della sequenza

Questo è il codice-golf le risposte sono segnate in byte con meno byte meglio.

Python 3 , 88 80 78 75 byte

^{-6 byte grazie a Wheat Wizard
-2 byte grazie a RootTwo
-3 byte grazie a notjagan}

s={0}
n=1
while 1:n+=1;b=f"{n:b}";p={b[1:],b[:-1]};s|=p-s and{b,print(n)}|p

Provalo online!

Gelatina , 22 byte

BẆṖ
ṄÇ;ð⁹Çḟ¥?⁹⁸‘¤ß
2ç⁸

Provalo online!

Mathematica, 116 110 byte

x={};f=Subsequences[#~IntegerDigits~2]&;Do[MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]&&x~AppendTo~Echo@n,{n,2,∞}]

Emette infinitamente i termini della sequenza.

Spiegazione

x={};

x è l'elenco dei termini della sequenza finora.

f=Subsequences[#~IntegerDigits~2]&

fè un valore Functionche accetta un numero intero e restituisce tutta la Subsequencessua 2rappresentazione di base (incluso l'elenco vuoto {}e l'elenco completo di IntegerDigitsse stesso).

Do[...,{n,2,∞}]

Valuta ...per il valore di nda 2a ∞.

...&&x~AppendTo~Echo@n

Se lo ...è False, il secondo argomento di And( &&) non viene mai valutato. Se lo ...è True, quindi Echo@nstampa e restituisce n, che quindi AppendTol'elenco x.

MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]

Vogliamo verificare che una sottostringa corretta nnon sia una sottostringa di un termine precedente nella sequenza. Most@f@nl'elenco dei adeguati sottostringhe di n, abbiamo poi verificare se ci sono eventuali stringhe s_che è una MemberQdi quella lista in modo tale che l'elenco f/@xdi liste di stringhe di termini precedenti della sequenza è FreeQdi slivello 2.

Mathematica, 109 94 byte

s={};Do[!SubsetQ[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]]&&(s=s~Join~t;Echo@i),{i,∞}]

Emette continuamente i termini della sequenza

Grazie speciali a @ngenisis per -15 byte

Mathematica, 123 byte

(s=r={};For[i=2,i<2#,i++,If[!ContainsAll[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]],s=s~Join~t;r~AppendTo~i]];r[[#]])&

Prendi n come input e genera l'ennesimo termine in questa sequenza (1 indicizzato)

ingresso

[1000]

produzione

1342

Pyth , 20 byte

u+G
fP-Fm.:.Bd)+TG1Y

Questo stampa la sequenza all'infinito. Di conseguenza, può essere utilizzato offline.

Spiegazione (Lo spazio è una nuova riga):

u+G fP-Fm.:.Bd)+TG1Y
u                  Y    Apply the following function to the previous output
                        until it stops changing (or forever, in this case),
                        starting with the empty list
    f             1     Find the first positive integer where
               +TG      The integer prepended to the current list
        m               Map to
           .Bd          Convert to binary
         .:   )         Form all subsequences
      -F                Fold the filter-out function over the list
                        This iteratively removes all subsequences already seen
                        from the candidate
     P                  Remove the last subsequence which is the whole number.
   (newline)            Print that first integer
 +G                     Prepend that first integer to the list

Pyth , 20 byte

.V2I-=ZP.:jb2)Yb=+YZ

Provalo online!

Haskell, 172 byte

import Data.List
b 0=""
b n=b(n`div`2)++(show$n`mod`2)
s=nub.(tails=<<).inits
p x=s x\\[x]
n(_,l)x|(p.b)x\\l/=[]=(x,l++(s.b)x)|1<2=(0,l)
filter(>1)$fst<$>scanl n(1,[])[1..]

Provalo online.

Spiegazione

Il codice genera la sequenza continuamente.

• brestituisce la rappresentazione binaria di un Intcome aString
• s restituisce tutte le sottostringhe di una stringa
• p restituisce tutte le sottostringhe corrette di una stringa
• n è una funzione che viene applicata in modo iterativo e restituisce una tupla contenente:
  • l'elemento corrente, se è un membro della sequenza, altrimenti 0
  • un elenco di tutte le sottostringhe da verificare per tutti i seguenti numeri
• infine, scanlviene utilizzato per richiamare npiù e più volte e il suo output viene filtrato per contenere solo elementi maggiori di 1

Ecco una versione leggermente più leggibile, prima del golf:

import Data.List

binary :: Int -> String
binary 0=""
binary n|(d,r)<-divMod n 2=binary d++["01"!!r]

substrings :: String -> [String]
substrings xs = nub$inits xs>>=tails

properSubstrings :: String -> [String]
properSubstrings xs = substrings xs\\[xs]

sb  = substrings.binary
psb = properSubstrings.binary

g = scanl step (1,[]) [1..]
  where step (_,l) x | psb x \\ l /= [] = (x,l++sb x)
                     | otherwise        = (0,l)

f=filter(>1)$fst<$>g

JavaScript, 57 byte

for(x=1;;x++)/^10|10(00)*$/.test(x.toString(2))&&alert(x)

alert=x=>{if(x>100)throw 'Let we stop here.';document.write(x+'<br/>');};

for(x=1;;x++)/^10|10(00)*$/.test(x.toString(2))&&alert(x)

Scriviamo il numero dato n in forma binaria, quindi:

• Se il numero è inizia con 10, n must nella sequenza:
  • rimuovere il primo 1in esso, la stringa binaria rimanente non deve essere vista, poiché n è il numero più piccolo che può contenere tale stringa
• Se il numero inizia con 11:
  • Rimuovendo il primo 1in esso, la stringa binaria rimanente (lasciamola donare come si 1xdeve vedere dal momento che:
    • il numero 1xè nella sequenza, oppure
    • il numero 1x0è nella sequenza, poiché contiene una sottostringa univoca1x
  • Se è dispari (termina con 1), non deve essere nella sequenza, poiché:
    • ( n - 1) / 2 nella sequenza, o
    • ( n - 1) nella sequenza, poiché contiene una sottostringa unica ( n - 1) / 2
  • Se è pari (termina con 0), è nella sequenza se n / 2 non è nella sequenza
    • con la stessa idea, n / 2 non è nella sequenza se n / 2 è dispari o n / 4 è nella sequenza

Conclusione:

la forma binaria del numero inizia con 10o termina con 1seguito da un numero dispari di 0. Oppure descrivi in ​​regex: x match /^10|10(00)*$/.