ให้เราบอกว่าซับสตริงเป็นส่วนต่อเนื่องของสตริงเดิม ยกตัวอย่างเช่นเป็นย่อยของcat concatenateเราจะบอกว่าสตริงย่อยที่เหมาะสมคือสตริงย่อยที่ไม่เท่ากับสตริงเดิม ตัวอย่างเช่นconcatenateสตริงย่อยconcatenateแต่ไม่ใช่สตริงย่อยที่เหมาะสม (สตริงอักขระเดี่ยวไม่มีสตริงย่อยที่เหมาะสม)

ตอนนี้เราจะกำหนดลำดับโดยใช้คำเหล่านี้ คำที่nในลำดับนี้จะเป็นจำนวนที่เล็กที่สุดซึ่งมีซับสตริงที่เหมาะสมของการแทนฐานสองของมันที่ไม่ใช่ซับสตริงของคำก่อนหน้าใด ๆ ในลำดับ 10ในระยะแรกคือ

ในฐานะที่เป็นแบบฝึกหัดให้สร้าง 5 คำแรก ฉันจะทำงานในรูปแบบไบนารีเพื่อทำให้สิ่งต่าง ๆ ง่ายขึ้น

10ในระยะแรกคือ เนื่องจาก11ตัวเลขที่เล็กที่สุดถัดไปมีสตริงย่อยที่เหมาะสมเพียงอันเดียวเท่านั้น1ซึ่งเป็นสตริงย่อยของ10ซึ่ง11ไม่ได้อยู่ในลำดับ 100อย่างไรก็ตามมีสตริงย่อยที่เหมาะสม00ซึ่งไม่ใช่ซับสตริงของคำ10นั้น100คือคำถัดไปของเรา ถัดไปคือ101สิ่งที่มีสตริงย่อยที่เหมาะสมที่ไม่ซ้ำกัน01เพิ่มลงในลำดับจากนั้น110มีสตริงย่อยที่เหมาะสม11ซึ่งเป็นใหม่เพิ่มไปยังลำดับ

ตอนนี้เรามี

10, 100, 101, 110

111ถัดไป แต่มีเฉพาะวัสดุพิมพ์1และ11ทำให้ไม่ใช่คำศัพท์ 1000อย่างไรก็ตามมี000การเพิ่มลงในลำดับ

นี่เป็นคำศัพท์คู่แรกในทศนิยม

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

งาน

ทั้ง

• รับnเป็นอินพุตและสร้างคำที่nในลำดับนี้ (ดัชนี 0 หรือ 1 ทั้งสอง)

• เอาต์พุตข้อกำหนดอย่างต่อเนื่องของลำดับ

นี่คือคำตอบของcode-golf ที่มีหน่วยเป็นไบต์และมีจำนวนไบต์น้อยกว่าดีกว่า

Python 3 , 88 80 78 75 ไบต์

^{-6 ไบต์ขอบคุณตัวช่วยสร้างข้าวสาลี
-2 ไบต์ขอบคุณ RootTwo
-3 ไบต์ขอบคุณ 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

ลองออนไลน์!

เยลลี่ , 22 ไบต์

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

ลองออนไลน์!

Mathematica, 116 110 ไบต์

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

เอาท์พุทเงื่อนไขของลำดับอย่างไม่มีที่สิ้นสุด

คำอธิบาย

x={};

x คือรายการของข้อกำหนดของลำดับจนถึง

f=Subsequences[#~IntegerDigits~2]&

fคือ a Functionซึ่งใช้จำนวนเต็มและส่งกลับค่าSubsequencesการ2แทนฐานทั้งหมด(รวมถึงรายการที่ว่างเปล่า{}และรายการทั้งหมดของIntegerDigitsตัวเอง)

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

ประเมิน...มูลค่าnจากการ2∞

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

ถ้า...เป็นFalseเช่นนั้นแล้วอาร์กิวเมนต์ที่สองเป็นAnd( &&) จะไม่ถูกประเมินค่า ถ้า...เป็นTrueแล้วEcho@nพิมพ์และผลตอบแทนnซึ่งเราแล้วรายการAppendTox

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

เราต้องการตรวจสอบว่าสตริงย่อยที่เหมาะสมของnไม่ใช่สตริงย่อยของคำก่อนหน้าใด ๆ ในลำดับ Most@f@nเป็นรายการของสตริงที่เหมาะสมของnเราแล้วตรวจสอบว่ามีสตริงใด ๆs_ซึ่งเป็นMemberQของรายการดังกล่าวว่ารายการf/@xของรายการของสตริงของข้อตกลงก่อนหน้าของลำดับคือFreeQของที่ระดับs2

Mathematica, 109 94 ไบต์

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

เอาต์พุตข้อกำหนดอย่างต่อเนื่องของลำดับ

thanx พิเศษถึง@ngenisisสำหรับ -15 ไบต์

Mathematica, 123 ไบต์

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

รับ n เป็นอินพุตและสร้างคำที่ n ในลำดับนี้ (1 ดัชนี)

อินพุต

[1000]

เอาท์พุต

1342

Pyth , 20 ไบต์

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

นี่จะพิมพ์ลำดับไปเรื่อย ๆ สามารถใช้งานแบบออฟไลน์ได้เท่านั้น

คำอธิบาย (พื้นที่คือบรรทัดใหม่):

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 ไบต์

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

ลองออนไลน์!

Haskell, 172 ไบต์

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

ลองออนไลน์

คำอธิบาย

รหัสสร้างลำดับอย่างต่อเนื่อง

• bส่งคืนการแทนค่าฐานสองของInta เป็นString
• s ส่งคืนสตริงย่อยทั้งหมดของสตริง
• p ส่งคืนสตริงย่อยที่เหมาะสมทั้งหมดของสตริง
• n เป็นฟังก์ชั่นที่ใช้ซ้ำ ๆ และส่งคืน tuple ที่มี:
  • องค์ประกอบปัจจุบันถ้ามันเป็นสมาชิกของลำดับมิฉะนั้น 0
  • รายการของสตริงย่อยทั้งหมดเพื่อตรวจสอบหมายเลขต่อไปนี้ทั้งหมด
• ในที่สุดscanlจะใช้ในการเรียกnซ้ำแล้วซ้ำอีกและเอาท์พุทของมันจะถูกกรองเพื่อให้มีองค์ประกอบที่มากกว่า 1

นี่เป็นรุ่นที่อ่านง่ายขึ้นเล็กน้อยก่อนเล่นกอล์ฟ:

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 ไบต์

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)

ให้เราเขียนตัวเลขที่ระบุnในรูปแบบไบนารีแล้ว:

• ถ้าจำนวนเริ่มต้นด้วย10, nต้องอยู่ในลำดับ:
  • ลบครั้งแรก1ในนั้นจะต้องไม่เห็นสตริงไบนารีที่เหลืออยู่เนื่องจากnเป็นจำนวนที่น้อยที่สุดซึ่งอาจมีสตริงดังกล่าว
• หากตัวเลขเริ่มต้นด้วย 11 :
  • โดยการลบแรก1ในนั้นสตริงไบนารีที่เหลือ (ให้เราบริจาคเป็น1xเห็นตั้งแต่:
    • จำนวน 1xอยู่ในลำดับหรือ
    • number 1x0อยู่ในลำดับเนื่องจากมีสตริงย่อยที่ไม่ซ้ำกัน1x
  • หากเป็นเลขคี่ (ลงท้ายด้วย 1) จะต้องไม่อยู่ในลำดับเนื่องจาก:
    • ( n - 1) / 2 ตามลำดับหรือ
    • ( n - 1) ในลำดับเนื่องจากมีสตริงย่อยที่ไม่ซ้ำกัน ( n - 1) / 2
  • หากเป็นเลขคู่ (ลงท้ายด้วย 0) จะอยู่ในลำดับ iff n / 2 ไม่อยู่ในลำดับ
    • ด้วยความคิดเดียวกันn / 2 ไม่อยู่ในลำดับ iff n / 2 เป็นเลขคี่หรือ n / 4 อยู่ในลำดับ

สรุป:

รูปแบบไบนารีของจำนวนเริ่มต้นด้วย10หรือปลายด้วยตามด้วยเลขคี่1 0หรืออธิบายใน regex: x /^10|10(00)*$/แข่งขัน