Digamos que una subcadena es cualquier sección continua de una cadena original. Por ejemplo, cates una subcadena de concatenate. Diremos que una subcadena adecuada es una subcadena que no es igual a la cadena original. Por ejemplo, concatenatees una subcadena concatenatepero no una subcadena adecuada. (las cadenas de caracteres individuales no tienen subcadenas adecuadas)

Ahora definiremos una secuencia usando estos términos. El n º término en esta secuencia será el número más pequeño de tal manera que hay una subcadena adecuada de su representación binaria que no es una subcadena de cualquier término anterior en la secuencia. El primer término es 10.

Como ejercicio vamos a generar los primeros 5 términos. Trabajaré en binario para facilitar las cosas.

El primer término es 10. Dado que 11el siguiente número más pequeño tiene solo una subcadena adecuada, 1que también es una subcadena 10, 11no está en la secuencia. 100sin embargo, contiene la subcadena adecuada 00que no es una subcadena de 10lo que 100es nuestro próximo término. El siguiente es el 101que contiene la subcadena adecuada única que lo 01agrega a la secuencia, luego 110contiene la subcadena adecuada 11que es nueva y la agrega a la secuencia.

Ahora tenemos

10, 100, 101, 110

111es el siguiente, pero contiene solo las subcadenas 1y 11no es un término. 1000sin embargo contiene 000agregarlo a la secuencia.

Aquí están los primeros dos términos en decimal

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

Tarea

Ya sea

• Tome n como entrada y generar el n º término en esta secuencia (ya sea 0 o 1 indexada)

• Salida continua de términos de la secuencia

Este es el código de respuestas de golf se puntúan en bytes con menos bytes que son mejores.

Python 3 , 88 80 78 75 bytes

^{-6 bytes gracias a Wheat Wizard
-2 bytes gracias a RootTwo
-3 bytes gracias 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

Pruébalo en línea!

Jalea , 22 bytes

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

Pruébalo en línea!

Mathematica, 116 110 bytes

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

Produce infinitamente términos de la secuencia.

Explicación

x={};

x es la lista de términos de la secuencia hasta ahora.

f=Subsequences[#~IntegerDigits~2]&

fes un Functionque toma un número entero y devuelve toda Subsequencessu 2representación base (incluida la lista vacía {}y la lista completa de IntegerDigitssí mismo).

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

Evaluar el ...valor de nfrom 2a ∞.

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

Si ...es así False, entonces el segundo argumento para And( &&) nunca se evalúa. Si ...es así True, luego Echo@nimprime y devuelve n, que luego AppendTola lista x.

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

Queremos verificar que alguna subcadena adecuada nno sea una subcadena de ningún término anterior en la secuencia. Most@f@nes la lista de subcadenas adecuadas de n, luego verificamos si hay alguna subcadena s_que sea una MemberQde esa lista de tal manera que la lista f/@xde listas de subcadenas de términos anteriores de la secuencia sea FreeQde snivel 2.

Mathematica, 109 94 bytes

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

Salida continua de términos de la secuencia

Gracias especiales a @ngenisis para -15 bytes

Mathematica, 123 bytes

(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[[#]])&

Tome n como entrada y genere el enésimo término en esta secuencia (1 indexado)

entrada

[1000]

salida

1342

Pyth , 20 bytes

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

Esto imprime la secuencia infinitamente. Solo se puede usar fuera de línea como consecuencia.

Explicación (El espacio es una nueva línea):

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 bytes

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

Pruébalo en línea!

Haskell 172 bytes

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

Pruébalo en línea.

Explicación

El código genera la secuencia continuamente.

• bdevuelve la representación binaria de an Intcomo aString
• s devuelve todas las subcadenas de una cadena
• p devuelve todas las subcadenas adecuadas de una cadena
• n es una función que se aplica de forma iterativa y devuelve una tupla que contiene:
  • el elemento actual, si es miembro de la secuencia, de lo contrario 0
  • una lista de todas las subcadenas para verificar los siguientes números
• finalmente, scanlse usa para llamar nuna y otra vez y su salida se filtra para contener solo elementos mayores que 1

Aquí hay una versión un poco más legible, antes de jugar al 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 bytes

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)

Vamos a escribir el número dado n en forma binaria, entonces:

• Si el número comienza con 10, n debe en la secuencia:
  • elimine el primero 1, no se debe ver la cadena binaria restante, ya que n es el número más pequeño que puede contener dicha cadena
• Si el número comienza con 11:
  • Al eliminar el primero 1, la cadena binaria restante (vamos a donarlo como 1xdebe verse desde:
    • número 1xestá en la secuencia, o
    • número 1x0está en la secuencia, ya que contiene una subcadena única1x
  • Si es impar (termina con 1), no debe en la secuencia, ya que:
    • ( n - 1) / 2 en la secuencia, o
    • ( n - 1) en la secuencia, ya que contiene una subcadena única ( n - 1) / 2
  • Si es par (termina con 0), está en la secuencia si f n / 2 no está en la secuencia
    • con la misma idea, n / 2 no está en la secuencia si n / 2 es impar o n / 4 está en la secuencia

Conclusión:

la forma binaria del número comienza con 10o termina con 1seguido de un número impar de 0. O describa en regex: x match /^10|10(00)*$/.