Я визначаю метод поєднання послідовності, щоб означати, що кожне число в послідовності є об'єднаним як рядок, тоді цей результат робиться цілим числом.

[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 цілочисків, що втрачають одиночку

Невикористані посилання на реалізацію. Я зробив це швидше, а не менше.

• Ідеон
• TIO (найшвидший, вищі межі)

Правила:

• Найкоротший код виграє
• Ви можете або (сказати, який):
  • Друкуйте цілі числа, що втрачаються одночасно, назавжди
  • Давши додатне ціле число n , надрукуйте або поверніть перші n елементів у вигляді списку або рядка, обмеженого комою чи пробілом.
• Вам слід підтримувати довільно великі цілі числа, якщо ваша мова дозволяє, особливо якщо ви друкуєте назавжди.

Натхненний / Пов'язані

Примітка. У OEIS для цієї послідовності ще немає запису.

Ще одна примітка: я назвав їх "Одномісно втраченими цілими людьми", щоб, в свою чергу, могли бути "Подвійно втрачені цілі особи", "N-ly Lossy Integers", "(N + 1) -ly Lossy Integers" та "Lossy Integers" "(об'єднання всього цього).

Математика, 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