Giả sử chuỗi con là bất kỳ phần liên tục nào của chuỗi gốc. Ví dụ catlà một chuỗi con của concatenate. Chúng ta sẽ nói rằng một chuỗi con thích hợp là một chuỗi con không bằng chuỗi gốc. Ví dụ concatenatelà một chuỗi con của concatenatenhưng không phải là một chuỗi con thích hợp. (chuỗi ký tự đơn không có chuỗi con phù hợp)

Bây giờ chúng ta sẽ định nghĩa một chuỗi bằng các thuật ngữ này. Các n hạn thứ theo thứ tự này sẽ là số nhỏ nhất như rằng có một chuỗi thích hợp biểu diễn nhị phân của nó mà không phải là một chuỗi con của bất kỳ điều khoản trước đó trong chuỗi. Thuật ngữ đầu tiên là 10.

Như một bài tập cho phép tạo ra 5 điều khoản đầu tiên. Tôi sẽ làm việc trong hệ nhị phân để làm cho mọi thứ dễ dàng hơn.

Thuật ngữ đầu tiên là 10. Vì 11, số nhỏ nhất tiếp theo, chỉ có một chuỗi con thích hợp, 1cũng là một chuỗi con của 10, 11không nằm trong chuỗi. 100Tuy nhiên có chứa các chuỗi thích hợp 00mà không phải là một chuỗi của 10quá 100là hạn tiếp theo của chúng tôi. Tiếp theo là 101chứa chuỗi con thích hợp duy nhất 01thêm nó vào chuỗi, sau đó 110chứa chuỗi con thích hợp 11mới thêm chuỗi đó vào chuỗi.

Bây giờ chúng tôi có

10, 100, 101, 110

111là tiếp theo nhưng nó chỉ chứa các chuỗi con 1và 11làm cho nó không phải là một thuật ngữ. 1000tuy nhiên có chứa 000thêm nó vào chuỗi.

Dưới đây là các thuật ngữ cặp đôi đầu tiên trong thập phân

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

Bài tập

Hoặc

• Lấy n làm đầu vào và tạo số hạng thứ n trong chuỗi này (0 hoặc 1 được lập chỉ mục)

• Các điều khoản đầu ra liên tục của chuỗi

Đây là mã - câu trả lời golf được tính bằng byte với ít byte hơn là tốt hơn.

Python 3 , 88 80 78 75 byte

^{-6 byte nhờ Wheat Wizard
-2 byte nhờ RootTwo
-3 byte nhờ 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

Hãy thử trực tuyến!

Thạch , 22 byte

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

Hãy thử trực tuyến!

Toán học, 116 110 byte

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

Đầu ra vô hạn các điều khoản của chuỗi.

Giải trình

x={};

x là danh sách các điều khoản của trình tự cho đến nay.

f=Subsequences[#~IntegerDigits~2]&

flà một Functionsố lấy một số nguyên và trả về tất cả Subsequencescác 2biểu diễn cơ sở của nó (bao gồm cả danh sách trống {}và danh sách đầy đủ của IntegerDigitschính nó).

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

Đánh giá ...cho giá trị ntừ 2đến ∞.

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

Nếu ...là False, thì đối số thứ hai thành And( &&) không bao giờ được đánh giá. Nếu ...là True, sau đó Echo@nin và trả lại n, mà chúng tôi sau đó AppendTodanh sách x.

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

Chúng tôi muốn kiểm tra xem một số chuỗi con thích hợp nkhông phải là một chuỗi con của bất kỳ thuật ngữ nào trước đó trong chuỗi. Most@f@nlà danh sách các chuỗi con đúng đắn n, chúng ta sau đó kiểm tra xem có bất kỳ chuỗi con s_mà là một MemberQdanh sách đó như vậy mà danh sách f/@xcủa danh sách các chuỗi con từ ngữ trước của dãy là FreeQcác scấp 2.

Toán học, 109 94 byte

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

Các điều khoản đầu ra liên tục của chuỗi

Đặc biệt thanx đến @ngenisis cho -15 byte

Toán học, 123 byte

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

Lấy n làm đầu vào và tạo số hạng thứ n trong chuỗi này (1 được lập chỉ mục)

đầu vào

[1000]

đầu ra

1342

Bình thường , 20 byte

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

Điều này in trình tự vô hạn. Nó chỉ có thể được sử dụng ngoại tuyến như là một hệ quả.

Giải thích (Không gian là một dòng mới):

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

Bình thường , 20 byte

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

Hãy thử trực tuyến!

Haskell, 172 byte

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

Hãy thử trực tuyến.

Giải trình

Mã tạo ra chuỗi liên tục.

• btrả về biểu diễn nhị phân của IntmộtString
• s trả về tất cả các chuỗi con của một chuỗi
• p trả về tất cả các chuỗi con thích hợp của một chuỗi
• n là một hàm được áp dụng lặp đi lặp lại và trả về một tuple chứa:
  • phần tử hiện tại, nếu nó là thành viên của chuỗi, nếu không thì 0
  • một danh sách tất cả các chuỗi con để kiểm tra tất cả các số sau
• cuối cùng, scanlđược sử dụng để gọi đi gọi nlại và đầu ra của nó được lọc để chỉ chứa các phần tử lớn hơn 1

Đây là một phiên bản dễ đọc hơn một chút, trước khi chơi 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 byte

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)

Hãy để chúng tôi viết số n đã cho ở dạng nhị phân, sau đó:

• Nếu số bắt đầu bằng 10, n phải theo thứ tự:
  • loại bỏ cái đầu tiên 1trong đó, chuỗi nhị phân còn lại không được nhìn thấy, vì n là số nhỏ nhất có thể chứa chuỗi đó
• Nếu số bắt đầu bằng 11 :
  • Bằng cách loại bỏ chuỗi đầu tiên 1trong chuỗi, chuỗi nhị phân còn lại (chúng ta hãy quyên tặng nó dưới dạng1x phải thấy kể từ:
    • con số 1x nằm trong dãy, hoặc
    • số 1x0nằm trong chuỗi, vì nó chứa chuỗi con duy nhất1x
  • Nếu là số lẻ (kết thúc bằng 1), thì nó không được theo thứ tự, vì:
    • ( n - 1) / 2 trong chuỗi, hoặc
    • ( n - 1) trong chuỗi, vì nó chứa chuỗi con duy nhất ( n - 1) / 2
  • Nếu nó là chẵn (kết thúc bằng 0), nó nằm trong chuỗi iff n / 2 không nằm trong chuỗi
    • với cùng một ý tưởng, n / 2 không nằm trong chuỗi iff n / 2 là số lẻ hoặc n / 4 nằm trong chuỗi

Phần kết luận:

dạng nhị phân của số bắt đầu bằng 10hoặc kết thúc 1bằng số lẻ 0. Hoặc mô tả trong regex: x khớp /^10|10(00)*$/.