Angenommen, eine Teilzeichenfolge ist ein zusammenhängender Abschnitt einer ursprünglichen Zeichenfolge. Zum Beispiel catist ein Teilstring von concatenate. Wir werden sagen, dass eine richtige Teilzeichenfolge eine Teilzeichenfolge ist, die nicht der ursprünglichen Zeichenfolge entspricht. Zum Beispiel concatenateist eine Teilzeichenfolge concatenateeine richtige Teilzeichenfolge, aber nicht. (Einzelzeichenfolgen haben keine richtigen Teilzeichenfolgen)

Wir werden nun eine Sequenz mit diesen Begriffen definieren. Der n- te Term in dieser Sequenz ist die kleinste Zahl, sodass es einen geeigneten Teilstring seiner Binärdarstellung gibt, der kein Teilstring eines früheren Terms in der Sequenz ist. Der erste Begriff ist 10.

Als Übung erzeugen wir die ersten 5 Terme. Ich werde in Binärform arbeiten, um die Dinge einfacher zu machen.

Der erste Begriff ist 10. Da 11die nächstkleinere Zahl nur eine richtige Teilzeichenfolge hat, 1die auch eine Teilzeichenfolge von ist 10, 11ist sie nicht in der Sequenz. 100Enthält jedoch die richtige Teilzeichenfolge, 00die keine Teilzeichenfolge ist, 10so 100ist unser nächster Begriff. Als nächstes wird 101die eindeutige richtige Teilzeichenfolge 01angezeigt, die der Sequenz hinzugefügt wird. Anschließend wird 110die richtige Teilzeichenfolge angezeigt, 11die der Sequenz neu hinzugefügt wird.

Jetzt haben wir

10, 100, 101, 110

111ist weiter oben, aber es enthält nur die Teilzeichenfolgen 1und 11macht es nicht zu einem Begriff. 1000Enthält jedoch das 000Hinzufügen zur Sequenz.

Hier sind die ersten paar Begriffe in Dezimalzahl

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

Aufgabe

Entweder

• Nehmen Sie n als Eingabe und generieren Sie den n- ten Term in dieser Reihenfolge (entweder 0 oder 1 indiziert)

• Kontinuierliche Ausgabe von Begriffen der Sequenz

Dies ist Code-Golf- Antworten werden in Bytes bewertet, wobei weniger Bytes besser sind.

Python 3 , 88 80 78 75 Bytes

^{-6 Bytes dank Wheat Wizard
-2 Bytes dank RootTwo
-3 Bytes dank 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

Probieren Sie es online!

Jelly , 22 Bytes

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

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

Gibt unendlich viele Terme der Sequenz aus.

Erläuterung

x={};

x ist die Liste der Begriffe der Sequenz bis jetzt.

f=Subsequences[#~IntegerDigits~2]&

fist ein FunctionWert, der eine Ganzzahl annimmt und die gesamte SubsequencesBasisdarstellung 2(einschließlich der leeren Liste {}und der vollständigen Liste von sich IntegerDigitsselbst) zurückgibt .

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

...Wert von nvon 2bis auswerten ∞.

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

Wenn ...ja False, wird das zweite Argument von And( &&) niemals ausgewertet. Wenn ...ja True, dann Echo@ndruckt und gibt das aus n, was wir dann in AppendToder Liste haben x.

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

Wir möchten überprüfen, ob eine richtige Teilzeichenfolge von nkeine Teilzeichenfolge eines vorherigen Terms in der Sequenz ist. Most@f@ndie Liste der richtigen Strings ist n, überprüfen wir dann , ob es irgendwelche Teile sind , s_die eine ist MemberQvon dieser Liste , so dass die Liste f/@xder Listen von Teil früherer Glieder der Folge ist FreeQdie sauf Stufe 2.

Mathematica, 109 94 Bytes

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

Kontinuierliche Ausgabe von Begriffen der Sequenz

Spezieller Dank an @ngenisis für -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[[#]])&

Nehmen Sie n als Eingabe und generieren Sie den n-ten Term in dieser Reihenfolge (1 indiziert)

Eingang

[1000]

Ausgabe

1342

Pyth , 20 Bytes

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

Dies gibt die Sequenz unendlich aus. Sie kann daher nur offline verwendet werden.

Erklärung (Das Leerzeichen ist ein Zeilenumbruch):

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

Probieren Sie es 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..]

Probieren Sie es online aus.

Erläuterung

Der Code generiert die Sequenz kontinuierlich.

• bgibt die binäre Darstellung von a Intals zurückString
• s Gibt alle Teilzeichenfolgen einer Zeichenfolge zurück
• p Gibt alle richtigen Teilzeichenfolgen einer Zeichenfolge zurück
• n ist eine Funktion, die iterativ angewendet wird und ein Tupel zurückgibt, das Folgendes enthält:
  • das aktuelle Element, wenn es ein Mitglied der Sequenz ist, sonst 0
  • eine Liste aller zu überprüfenden Teilzeichenfolgen für alle folgenden Zahlen
• Schließlich scanlwird verwendet , um rufen nimmer und immer wieder , und sein Ausgang gefiltert wird , um nur die Elemente enthalten , größer als 1 ist

Hier ist eine etwas besser lesbare Version vor dem Golfen:

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)

Lassen Sie uns die gegebene Zahl n in binärer Form schreiben , dann:

• Wenn die Zahl mit beginnt 10, muss n in der Reihenfolge sein:
  • Entfernen Sie die erste 1darin, die verbleibende Binärzeichenfolge muss nicht gesehen werden, da n die kleinste Zahl ist, die eine solche Zeichenfolge enthalten kann
• Wenn die Nummer beginnt mit 11:
  • Durch Entfernen der ersten 1darin, die verbleibende Binärzeichenfolge (lassen Sie uns es spenden, wie gesehen werden 1xmuss, da:
    • Nummer 1xist in der Reihenfolge, oder
    • Zahl 1x0ist in der Sequenz, da sie eine eindeutige Unterzeichenfolge enthält1x
  • Wenn es ungerade ist (endet mit 1), darf es nicht in der Reihenfolge sein, da:
    • ( n - 1) / 2 in der Sequenz oder
    • ( n - 1) in der Sequenz, da sie eine eindeutige Unterzeichenfolge ( n - 1) / 2 enthält
  • Wenn es gerade ist (endet mit 0), ist es in der Folge, wenn n / 2 nicht in der Folge ist
    • mit der gleichen Idee ist n / 2 nicht in der Folge, wenn n / 2 ungerade ist oder n / 4 in der Folge ist

Fazit:

die binäre Form der Zahl beginnt mit 10oder endet mit, 1gefolgt von einer ungeraden Zahl von 0. Oder beschreiben Sie in Regex: x match /^10|10(00)*$/.