Katakanlah substring adalah bagian berkelanjutan dari string asli. Misalnya catadalah substring dari concatenate. Kami akan mengatakan bahwa substring yang tepat adalah substring yang tidak sama dengan string asli. Misalnya concatenateadalah substring concatenatetetapi bukan substring yang tepat. (string karakter tunggal tidak memiliki substring yang tepat)

Kami sekarang akan menentukan urutan menggunakan istilah-istilah ini. The n th istilah dalam urutan ini akan menjadi nomor terkecil sehingga ada substring yang tepat dari representasi biner yang bukan merupakan substring dari setiap istilah sebelumnya dalam urutan. Istilah pertama adalah 10.

Sebagai latihan mari kita menghasilkan 5 istilah pertama. Saya akan bekerja dalam biner untuk mempermudah.

Istilah pertama adalah 10. Karena 11, angka terkecil berikutnya, hanya memiliki satu substring yang tepat, 1yang juga merupakan substring 10, 11tidak ada dalam urutan. 100Namun memang mengandung substring 00yang tepat yang bukan substring 10sehingga 100adalah istilah kita selanjutnya. Berikutnya adalah101 yang berisi substring unik yang tepat 01menambahkannya ke urutan, lalu 110berisi substring 11yang tepat yang baru menambahkannya ke urutan.

Sekarang kita punya

10, 100, 101, 110

111berikutnya, tetapi hanya berisi substring 1dan 11membuatnya bukan istilah. 1000Namun berisi 000menambahkannya ke urutan.

Berikut adalah istilah pasangan pertama dalam desimal

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

Tugas

Antara

• Ambil n sebagai input dan hasilkan istilah ke- n dalam urutan ini (0 atau 1 diindeks)

• Secara kontinu menampilkan persyaratan urutan

Ini adalah jawaban kode-golf diberi skor dalam byte dengan lebih sedikit byte menjadi lebih baik.

Python 3 , 88 80 78 75 byte

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

Cobalah online!

Jelly , 22 byte

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

Cobalah online!

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

Secara tak terbatas menampilkan ketentuan urutan.

Penjelasan

x={};

x adalah daftar syarat urutan sejauh ini.

f=Subsequences[#~IntegerDigits~2]&

fadalah Functionyang mengambil integer dan mengembalikan semua representasi Subsequencesbasisnya 2(termasuk daftar kosong {}dan daftar lengkapnya IntegerDigitssendiri).

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

Mengevaluasi ...nilai dari ndari 2hingga ∞.

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

Jika ...adalah False, maka argumen kedua And( &&) tidak pernah dievaluasi. Jika ...ini True, maka Echo@nmencetak dan kembali n, yang kemudian kita AppendTodaftar x.

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

Kami ingin memeriksa bahwa beberapa substring yang tepat nbukan merupakan substring dari istilah sebelumnya dalam urutan. Most@f@nadalah daftar substring yang tepat n, kami kemudian memeriksa apakah ada substring s_yang merupakan MemberQdaftar yang seperti bahwa daftar f/@xdari daftar substring istilah sebelumnya urutannya adalah FreeQdari spada tingkat 2.

Mathematica, 109 94 byte

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

Secara kontinu menampilkan persyaratan urutan

Thanx khusus untuk @ngenisis untuk -15 byte

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

Ambil n sebagai input dan hasilkan istilah ke-n dalam urutan ini (1 diindeks)

memasukkan

[1000]

keluaran

1342

Pyth , 20 byte

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

Ini mencetak urutan tanpa batas. Itu hanya dapat digunakan secara offline sebagai konsekuensinya.

Penjelasan (Spasi adalah baris baru):

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 byte

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

Cobalah online!

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

Cobalah online.

Penjelasan

Kode menghasilkan urutan secara terus menerus.

• bmengembalikan representasi biner dari IntsebagaiString
• s mengembalikan semua substring dari sebuah string
• p mengembalikan semua substring yang tepat dari sebuah string
• n adalah fungsi yang diterapkan secara iteratif dan mengembalikan tuple yang berisi:
  • elemen saat ini, jika itu adalah anggota urutan, jika tidak 0
  • daftar semua substring untuk memeriksa semua nomor berikut
• akhirnya, scanldigunakan untuk memanggil nberulang-ulang dan hasilnya disaring hanya mengandung elemen lebih besar dari 1

Berikut versi yang sedikit lebih mudah dibaca, sebelum bermain 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)

Mari kita menulis angka yang diberikan n dalam bentuk biner, lalu:

• Jika angka dimulai dengan 10, n harus dalam urutan:
  • hapus yang pertama 1di dalamnya, string biner yang tersisa tidak boleh dilihat, karena n adalah angka terkecil yang mungkin mengandung string tersebut
• Jika nomornya dimulai dengan 11:
  • Dengan menghapus yang pertama 1di dalamnya, string biner yang tersisa (mari kita sumbangkan seperti yang 1xharus dilihat sejak:
    • angka 1xada dalam urutan, atau
    • angka 1x0dalam urutan, karena mengandung sub string unik1x
  • Jika aneh (diakhiri dengan 1), itu tidak boleh dalam urutan, karena:
    • ( n - 1) / 2 dalam urutan, atau
    • ( n - 1) dalam urutan, karena berisi sub string unik ( n - 1) / 2
  • Jika bahkan (ujung dengan 0), itu adalah dalam urutan IFF n / 2 tidak dalam urutan
    • dengan ide yang sama, n / 2 adalah tidak dalam urutan IFF n / 2 ganjil, atau n / 4 adalah dalam urutan

Kesimpulan:

bentuk biner dari angka dimulai dengan 10atau diakhiri dengan 1diikuti oleh angka ganjil 0. Atau jelaskan dalam regex: x cocok /^10|10(00)*$/.