Я определяю метод объединения последовательности, чтобы означать, что каждое число в последовательности объединяется в виде строки, тогда этот результат становится целым числом.

[1, 2, 3] -> 123

Для каждой конечной последовательности, состоящей по меньшей мере из 3 последовательных целых чисел, пропускающих ровно один элемент в последовательности, и этот пропущенный элемент не может быть первым или последним элементом в последовательности, выведите целое число, полученное из объединенной последовательности. Я называю это «целое число с потерями».

[1, 2, 3] -> {1, 3} (missing an element) -> 13

Эта последовательность целых чисел с одиночными потерями является объединением следующих подпоследовательностей (разбиений?):

Первая подпоследовательность {n, n+2}является A032607 .

{n, n+2}            -> 13, 24, 35, 46, 57, 68, 79, 810, 911, 1012, ...
{n, n+1, n+3}       -> 124, 235, 346, ...
{n, n+2, n+3}       -> 134, 245, 356, ...
{n, n+1, n+2, n+4}  -> 1235, 2346, 3457, ...
{n, n+1, n+3, n+4}  -> 1245, 2356, 3467, ...
{n, n+2, n+3, n+4}  -> 1345, 2456, 3567, ...
... 
for n ∈ ℕ (integers >= 1)

Эти целые числа должны быть напечатаны в порядке возрастания. Первые 25 целых чисел с потерями приведены ниже :

13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, ...

Первые 7597 целых чисел с единичными потерями

Неуправляемые эталонные реализации. Я сделал это, чтобы быть быстрее, а не меньше.

• Ideone
• TIO (самый быстрый, более высокие пределы)

Правила:

• Самый короткий код выигрывает
• Вы можете либо (скажите, какой):
  • Напечатайте однозначные числа с потерями навсегда
  • Если задано положительное целое число n , выведите или верните первые n элементов в виде списка или строки, разделенной запятыми или пробелами.
• Вы должны поддерживать произвольно большие целые числа, если ваш язык это позволяет, особенно если вы печатаете вечно.

Вдохновленный / Связанный

Примечание. Для этой последовательности еще нет записи в OEIS.

Еще одно примечание: я назвал их «Единственными целыми числами с потерями», чтобы в свою очередь могли быть «Двойные целые числа с потерями», «Целые числа с нулевыми потерями», (N + 1) - только целые числа с потерями »и« Целые числа с потерями » "(объединение всех этих).

Mathematica, 101 байт

Sort@Flatten@Table[FromDigits[""<>ToString/@(z~Range~x~Delete~y)],{x,3,#},{z,1,x-1},{y,2,x-z}][[1;;#]]&

Ура! На этот раз у меня самый короткий ответ!Party[Hard]

Haskell, 131 , 114 , 106 байт

iterate(\n->minimum[x|x<-[read(show=<<filter(/=k)[i..j])::Int|i<-[1..n],j<-[i+2..n],k<-[i+1..j-1]],x>n])13

Это ограничено размером Int, но его можно легко расширить, заменив Intна Integer.

Менее гольф:

concatInt x = read (concatMap show x) ::Int
allUpToN n = [concatInt $ filter (/=k) [i..j] | i <- [1..n], j <- [i+2..n], k <- [i+1..j-1]]
f n = minimum[x | x <- allUpToN, x > n ]
iterate f 13

8 байтов, сыгранных @nimi.

Python 3 136 127 126 122 байтов

решение грубой силы, я даже не пытаюсь n = 7000 (это уже 10 секунд для n = 100)

r=range
f=lambda n:sorted(int(''.join(str(i+k)for i in r(1,j)if l-i))for k in r(n)for j in r(4,n)for l in r(2,j-1))[:n]

объяснение

# f=lambda n:sorted( int(''.join(str(i+k) for i in r(1,j)   if l-i)) for k in r(n) for j in r(4,n) for l in r(2,j-1))[:n]
#            ──┬──                        ───────┬───────    ───┬──  ──────┬──────  ──────┬──────  ────────┬──────── ─┬─
#              │                                 │              │          │              │                │          └── selection of the n first numbers
#              │                                 │              │          │              │                └── loop to remove missing element
#              │                                 │              │          │              └── loop for the dimension of the list n to be sure we miss nothing xD
#              │                                 │              │          └── loop on the n in op description 
#              │                                 │              └── Test to remove missing element
#              │                                 └── loop on {n, n+1 ...} in the op description
#              └──── sort the list

Результаты

>>> f(25)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235]

>>> f(100)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, 1245, 1315, 1345, 1416, 1517, 1618, 1719, 1820, 1921, 2022, 2123, 2224, 2325, 2346, 2356, 2426, 2456, 2527, 2628, 2729, 2830, 2931, 3032, 3133, 3234, 3335, 3436, 3457, 3467, 3537, 3567, 3638, 3739, 3840, 3941, 4042, 4143, 4244, 4345, 4446, 4547, 4568, 4578, 4648, 4678, 4749, 4850, 4951, 5052, 5153, 5254, 5355, 5456, 5557, 5658, 5679, 5689, 5759, 5789, 5860, 5961, 6062, 6163, 6264, 6365, 6466, 6567, 6668, 6769, 6870, 6971, 7072, 7173, 7274, 7375]

Спасибо @ mbomb007 и @FricativeMelon за помощь

Python 3, 319 , 270 , 251 байт

t,h,n,k,q*=range,input(),1,2,
while h>len(q)or n*k<=len(str(q[h])):
 q+=[int("".join([str(c+s)for c in t(k+1)if c-y]))for s in t(10**~-n,10**n)for y in t(1,k)]
 if~-n:n*=k;k+=1
 else:n,k=k+1,2
 while n//k*k-n:k+=1
 n//=k;q.sort()
print(q[:h])

Принимает hкак входные данные из STDIN и печатает массив первых hцелых чисел с единичными потерями. Это также очень быстро, занимает всего несколько секунд h=7000.

Объяснение: Обратите внимание, что если бы у нас было бесконечное время, мы могли бы просто выполнить итерацию по всем n,kи для каждой пары отбросить каждое из n+1,n+2,...,n+k-1( k-1возможностей) и получить все (бесконечно много) значений из них, а затем просто отсортировать последовательность в порядке возрастания и усечь до hэлементы. Конечно, мы на самом деле не можем этого сделать, но если мы можем достичь точки, в которой первые отсортированные hэлементы больше не могут изменяться путем добавления значений любых будущих n,kпар, мы можем просто усечь их и сделать это за конечное время. Для любой n,kпары у нее есть хотя бы floor(log10(n)+1)*kцифры, возможно, больше. Итак, давайте сгруппируем эти пары по значению c(n,k)=floor(log10(n)+1)*k, где мы гарантируем, что если c(a,b)<c(n,k)мы обработаем a,bраньше n,k. Если у нас есть список отсортирован, и его последний элемент имеетdцифр, и d<c(n,k)для следующей, которую n,kмы собираемся обработать, мы можем остановиться, так как мы больше не можем получить число с таким количеством или меньшим количеством цифр, поскольку по нашей гарантии мы должны были уже обработать его тогда, и, следовательно, независимо от того, какие числа мы в конечном итоге вычисления, первые hэлементы не могут измениться, поэтому мы можем просто вернуть их.

Так что теперь нам просто нужна функция, которая гарантирует заявленный порядок c(n,k). Для каждого yполучаемого за c(n,k), мы должны обработать все так (n,k), чтобы y=c(n,k). Скажем L=floor(log10(n)+1)для некоторых n. Поэтому и y=L*kдержись. Начните с k=2,L=y/2, затем k=3,L=y/3;k=4,L=y/4...k=y,L=1пропустите нецелые значения L. Чтобы создать целую c(n,k)функцию, начните с (1,2)с y=2, и увеличение yна 1 и начать заново всякий раз , когда вы получаете L==1. Теперь у нас есть перечисление пар (L,k), и оно удовлетворяет нашему условию. Тем не менее, мы должны извлечь все возможное nиз L, которые мы делаем, перечисляя все целые числа с Lцифрами. Затем для каждой из этих (n,k)пар, для каждого изk-1Из возможных отброшенных элементов мы должны сгенерировать число с потерями, которое мы получим в результате, и добавить его в наш список, который начинается пустым. Затем мы сортируем список и повторяем следующую (L,k)пару, останавливаясь, когда мы сделали, d<c(n,k)как указано ранее.

Разбивка кода (немного устаревшая):

t=range                     #shortens code
def f(r,n,k):               #helper function
 for s in t(10**~-n,10**n): #for the (L,k) pair, add value of (s,k,y)
  for y in t(1,k):r+=[(int("".join(map(str,[c+s for c in t(k+1)if c!=y]))))]
 if n>1:                    #case where L!=1
  n*=k;k+=1                 #multiply n (which is n'/k from prev iter), inc k
 else:n,k=k+1,2             #reset n and k
 while n//k*k-n:k+=1        #find next proper divisor of n
 return(r,n//k,k)           #divide by that divisor and return
def g(h):                   #main function
 q,a,b=[],1,2               #initial values
 while h>=len(q)or a*b<=len(str(q[h])):(q,a,b)=f(q,a,b);q.sort()
 return q[:h]               #continues until at least h numbers and surpassed current max