Digamos que uma substring seja qualquer seção contínua de uma string original. Por exemplo, caté uma substring de concatenate. Diremos que uma substring adequada é uma substring que não é igual à string original. Por exemplo, concatenateé uma substring, concatenatemas não uma substring adequada. (cadeias de caracteres únicos não possuem substrings apropriadas)

Agora definiremos uma sequência usando esses termos. O n º termo nesta seqüência será o menor número tal que há uma substring adequada de sua representação binária que não é uma substring de qualquer termo anteriormente na seqüência. O primeiro termo é 10.

Como exercício, vamos gerar os 5 primeiros termos. Vou trabalhar em binário para facilitar as coisas.

O primeiro termo é 10. Como 11o próximo número menor, possui apenas uma substring adequada, 1que também é uma substring 10, 11não está na sequência. 100no entanto, contém a substring adequada, 00que não é uma substring, 10portanto 100é o próximo termo. A seguir, é 101que contém a substring apropriada exclusiva, 01adicionando-a à sequência e, em seguida, 110contém a substring apropriada, 11que é nova, adicionando-a à sequência.

Agora temos

10, 100, 101, 110

111é o próximo, mas contém apenas as substrings 1e 11não é um termo. 1000no entanto, contém 000adicioná-lo à sequência.

Aqui estão os primeiros dois termos em 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

Tarefa

Ou

• Tome n como entrada e gerar o n ésimo termo nesta sequência (0 ou 1 indexada)

• Termos de saída contínuos da sequência

Isto é , as respostas do código-golfe são pontuadas em bytes, com menos bytes sendo melhores.

Python 3 , 88 80 78 75 bytes

^{-6 bytes graças ao Assistente de Trigo
-2 bytes graças ao RootTwo
-3 bytes graças ao 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

Experimente online!

Gelatina , 22 bytes

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

Experimente online!

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,∞}]

Gera infinitamente termos da sequência.

Explicação

x={};

x é a lista de termos da sequência até agora.

f=Subsequences[#~IntegerDigits~2]&

fé um Functionque pega um número inteiro e retorna toda a Subsequencessua 2representação básica (incluindo a lista vazia {}e a lista completa de IntegerDigitssi mesma).

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

Avalie o ...valor de nde 2até ∞.

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

Se ...for False, o segundo argumento para And( &&) nunca é avaliado. Se ...for True, então Echo@nimprime e retorna n, que entãoAppendTo a lista x.

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

Queremos verificar se alguma substring adequada de nnão é uma substring de nenhum termo anterior na sequência. Most@f@na lista de substrings adequadas de n, nós, em seguida, verifique se existem substrings s_que é um MemberQda lista de modo que a lista f/@xde listas de substrings de termos anteriores da sequência é FreeQde snível 2.

Mathematica, 109 94 bytes

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

Termos de saída contínuos da sequência

Agradecimento especial a @ngenisis por -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 e gere o enésimo termo nesta sequência (1 indexado)

entrada

[1000]

resultado

1342

Pitão , 20 bytes

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

Isso imprime a sequência infinitamente. Só pode ser usado offline como consequência.

Explicação (O espaço é uma nova linha):

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

Pitão , 20 bytes

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

Experimente online!

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

Experimente online.

Explicação

O código gera a sequência continuamente.

• bretorna a representação binária de um Intcomo umString
• s retorna todas as substrings de uma string
• p retorna todas as substrings apropriadas de uma string
• n é uma função aplicada iterativamente e retorna uma tupla contendo:
  • o elemento atual, se for um membro da sequência, caso contrário, 0
  • uma lista de todas as substrings para verificar os seguintes números
• finalmente, scanlé usado para chamar nrepetidamente e sua saída é filtrada para conter apenas elementos maiores que 1

Aqui está uma versão um pouco mais legível, antes do golfe:

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 escrever o número dado n na forma binária, então:

• Se o número começar 10, n deve na sequência:
  • remova a primeira 1, a cadeia binária restante não deve ser vista, pois n é o menor número que pode conter essa cadeia
• Se o número começar com 11:
  • Removendo a primeira 1, a cadeia binária restante (vamos doá-la como1x deve ser vista desde:
    • número 1x está na sequência ou
    • número 1x0está na sequência, pois contém uma sub-string exclusiva1x
  • Se for ímpar (termina com 1), não deve estar na sequência, pois:
    • ( n - 1) / 2 na sequência, ou
    • ( n - 1) na sequência, uma vez que contém uma sub-string exclusiva ( n - 1) / 2
  • Se for par (termina com 0), está na sequência se n / 2 não estiver na sequência
    • com a mesma idéia, n / 2 não está na sequência se n / 2 for ímpar ou n / 4 estiver na sequência

Conclusão:

a forma binária do número começa com 10ou termina com 1seguido pelo número ímpar de 0. Ou descreva em regex: x match /^10|10(00)*$/.