Допустим, подстрока - это любое непрерывное сечение исходной строки. Например cat, это подстрока concatenate. Мы скажем, что правильная подстрока - это подстрока, которая не равна исходной строке. Например concatenate, это подстрока, concatenateно не правильная подстрока. (односимвольные строки не имеют правильных подстрок)

Теперь мы определим последовательность, используя эти термины. П - й член этой последовательности будет наименьшее число такое , что существует правильная подстрока его двоичное представление , которое не является подстрока любой более ранний срок в последовательности. Первый термин есть 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 проиндексированный)

• Непрерывно выводим члены последовательности

Это код-гольф ответы оцениваются в байтах с меньшим количеством байтов, тем лучше.

Python 3 , 88 80 78 75 байт

^{-6 байт благодаря Wheat Wizard
-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]&

fa, Functionкоторый принимает целое число и возвращает все Subsequencesего базовое 2представление (включая пустой список {}и полный список самого IntegerDigitsсебя).

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

Оценить ...по стоимости nот 2до ∞.

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

Если ...есть False, то второй аргумент And( &&) никогда не оценивается. Если ...есть True, то Echo@nпечатает и возвращает n, что мы тогда AppendToсписок x.

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

Мы хотим проверить, что некоторая правильная подстрока nне является подстрокой какого-либо предыдущего члена последовательности. Most@f@nсписок соответствующих подстрок n, мы затем проверить , есть ли подстроки , s_который является MemberQв этот список , так что список f/@xсписков подстрок предыдущих членов последовательности находится FreeQна sна уровне 2.

Mathematica, 109 94 байта

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

Непрерывно выводим члены последовательности

Специальное спасибо @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возвращает двоичное представление Intв видеString
• s возвращает все подстроки строки
• p возвращает все правильные подстроки строки
• n это функция, которая применяется итеративно и возвращает кортеж, содержащий:
  • текущий элемент, если он является членом последовательности, в противном случае 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в последовательности, или
    • число 1x0в последовательности, так как оно содержит уникальную подстроку1x
  • Если он нечетный (заканчивается на 1), он не должен быть в последовательности, так как:
    • ( n - 1) / 2 в последовательности или
    • ( n - 1) в последовательности, поскольку она содержит уникальную подстроку ( n - 1) / 2
  • Если оно четное (заканчивается 0), оно находится в последовательности, если n / 2 не находится в последовательности
    • с той же идеей, n / 2 не входит в последовательность, если n / 2 нечетно, или n / 4 находится в последовательности

Вывод:

двоичная форма числа начинается с 10или заканчивается с 1последующим нечетным числом 0. Или опишите в регулярном выражении: х совпадают /^10|10(00)*$/.