Disons qu'une sous-chaîne est une section continue d'une chaîne d'origine. Par exemple, catest une sous-chaîne de concatenate. Nous dirons qu'une sous-chaîne correcte est une sous-chaîne qui n'est pas égale à la chaîne d'origine. Par exemple, concatenateest une sous-chaîne concatenatemais pas une sous-chaîne appropriée. (les chaînes de caractères uniques n'ont pas de sous-chaînes appropriées)

Nous allons maintenant définir une séquence en utilisant ces termes. Le n ième terme de cette séquence sera le plus petit nombre de sorte qu'il existe une sous-chaîne appropriée de sa représentation binaire qui n'est pas une sous-chaîne d'un terme antérieur de la séquence. Le premier terme est 10.

Comme un exercice permet de générer les 5 premiers termes. Je vais travailler en binaire pour faciliter les choses.

Le premier terme est 10. Puisque 11, le plus petit nombre suivant, n'a qu'une seule sous-chaîne appropriée, 1qui est également une sous-chaîne de 10, 11n'est pas dans la séquence. 100contient cependant la sous-chaîne appropriée 00qui n'est pas une sous-chaîne de 10sorte 100est notre prochain terme. Ensuite, 101qui contient la sous-chaîne appropriée unique en l' 01ajoutant à la séquence, puis 110contient la sous-chaîne appropriée 11qui est nouvelle en l'ajoutant à la séquence.

Maintenant nous avons

10, 100, 101, 110

111est à côté, mais il ne contient que les sous-chaînes 1et 11n'en fait pas un terme. 1000contient cependant l' 000ajouter à la séquence.

Voici les premiers termes du couple en décimal

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

Tâche

Soit

• Prenez n en entrée et générez le n ème terme dans cette séquence (soit 0 soit 1 indexé)

• Sortie en continu des termes de la séquence

Il s'agit du code-golf, les réponses sont notées en octets, moins les octets étant meilleurs.

Python 3 , 88 80 78 75 octets

^{-6 octets grâce à Wheat Wizard
-2 octets grâce à RootTwo
-3 octets grâce à 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

Essayez-le en ligne!

Gelée , 22 octets

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

Essayez-le en ligne!

Mathematica, 116 110 octets

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

Émet à l'infini les termes de la séquence.

Explication

x={};

x est la liste des termes de la séquence jusqu'à présent.

f=Subsequences[#~IntegerDigits~2]&

fest un Functionqui prend un entier et retourne toute Subsequencessa 2représentation de base (y compris la liste vide {}et la liste complète de IntegerDigitslui - même).

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

Évaluez la ...valeur de nà 2à ∞.

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

Si ...est False, alors le deuxième argument de And( &&) n'est jamais évalué. Si ...est True, puis Echo@nimprime et renvoie n, dont nous avons ensuite AppendTola liste x.

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

Nous voulons vérifier qu'une sous-chaîne correcte de nn'est pas une sous-chaîne d'un terme précédent dans la séquence. Most@f@nest la liste des sous-chaînes propres à n, on vérifie ensuite s'il y a des sous-chaînes s_qui font partie MemberQde cette liste de telle sorte que la liste f/@xdes listes de sous-chaînes des termes précédents de la séquence soit FreeQde sniveau 2.

Mathematica, 109 94 octets

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

Sortie en continu des termes de la séquence

Remerciements spéciaux à @ngenisis pour -15 octets

Mathematica, 123 octets

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

Prenez n en entrée et générez le nième terme dans cette séquence (1 indexé)

contribution

[1000]

production

1342

Pyth , 20 octets

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

Cela imprime la séquence à l'infini. Il ne peut donc être utilisé que hors ligne.

Explication (L'espace est une nouvelle ligne):

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 octets

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

Essayez-le en ligne!

Haskell, 172 octets

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

Essayez-le en ligne.

Explication

Le code génère la séquence en continu.

• brenvoie la représentation binaire d'un en Inttant queString
• s renvoie toutes les sous-chaînes d'une chaîne
• p renvoie toutes les sous-chaînes appropriées d'une chaîne
• n est une fonction qui est appliquée de manière itérative et renvoie un tuple contenant:
  • l'élément courant, s'il est membre de la séquence, sinon 0
  • une liste de toutes les sous-chaînes à comparer pour tous les nombres suivants
• enfin, scanlest utilisé pour appeler nencore et encore et sa sortie est filtrée pour ne contenir que des éléments supérieurs à 1

Voici une version légèrement plus lisible, avant de jouer au 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 octets

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)

Écrivons le nombre donné n sous forme binaire, puis:

• Si le nombre commence par 10, n doit dans l'ordre:
  • supprimez le premier 1, la chaîne binaire restante ne doit pas être vue, car n est le plus petit nombre pouvant contenir une telle chaîne
• Si le nombre commence par 11:
  • En supprimant le premier 1, la chaîne binaire restante (laissez-nous la donner comme il 1xfaut le voir puisque:
    • le numéro 1xest dans la séquence, ou
    • nombre 1x0est dans la séquence, car il contient une sous-chaîne unique1x
  • S'il est impair (se termine par 1), il ne doit pas dans l'ordre, car:
    • ( n - 1) / 2 dans la séquence, ou
    • ( n - 1) dans la séquence, car il contient une sous-chaîne unique ( n - 1) / 2
  • S'il est pair (se termine par 0), il est dans la séquence si n / 2 n'est pas dans la séquence
    • avec la même idée, n / 2 n'est pas dans la séquence si n / 2 est impair, ou n / 4 est dans la séquence

Conclusion:

la forme binaire du nombre commence par 10ou se termine par 1suivie d'un nombre impair de 0. Ou décrivez dans regex: x match /^10|10(00)*$/.