Defino el método de combinar una secuencia para significar que cada número de la secuencia se concatena como una cadena, luego ese resultado se convierte en un entero.

[1, 2, 3] -> 123

Por cada secuencia finita de al menos 3 enteros consecutivos, que faltan exactamente un elemento en la secuencia, y este elemento que falta puede no ser el primer o el último elemento en la secuencia, genera el entero resultante de la secuencia combinada. Me refiero a esto como un "entero con pérdida individual".

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

Esta secuencia de enteros con pérdida individual es la unión de las siguientes subsecuencias (particiones?):

La primera subsecuencia {n, n+2}es 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)

Estos enteros deben imprimirse en orden ascendente. Los primeros 25 enteros con pérdida individual están a continuación :

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

Primeros 7597 enteros con pérdida individual

Implementaciones de referencia sin golf. Lo hice para ser más rápido, en lugar de más pequeño.

• Ideona
• TIO (más rápido, límites más altos)

Reglas:

• El código más corto gana
• Usted puede (decir cuál):
  • Imprime los enteros perdidos para siempre
  • Dado un número entero positivo n , imprime o devuelve los primeros n elementos como una lista, o una cadena delimitada por comas o espacios en blanco.
• Debe admitir enteros arbitrariamente grandes si su idioma lo permite, especialmente si imprime para siempre.

Inspirado por / relacionado

Nota: Todavía no hay una entrada en el OEIS para esta secuencia.

Otra nota: los llamé "Enteros con pérdida única" para que a su vez pudiera haber "Enteros con pérdida doble", "Enteros con pérdida N-ly", "Enteros con pérdida (N + 1)" y "Enteros con pérdida" "(unión de todos estos).

Mathematica, 101 bytes

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

¡Hurra! ¡Por una vez tengo la respuesta más corta!Party[Hard]

Haskell, 131 , 114 , 106 bytes

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

Esto está limitado por el tamaño de Int, pero se puede extender fácilmente reemplazándolo Intpor Integer.

Menos golfizado:

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 bytes jugado por @nimi.

Python 3, 136 127 126 122 bytes

solución de fuerza bruta, ni siquiera intento n = 7000 (ya toma 10 segundos para 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]

Explicació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

Resultados

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

Gracias a @ mbomb007 y @FricativeMelon por su ayuda

Python 3, 319 , 270 , 251 bytes

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

Toma una hentrada de STDIN e imprime una matriz de los primeros henteros con pérdidas individuales. También es muy rápido, toma solo unos segundos h=7000.

Explicación: Tenga en cuenta que, si tuviéramos tiempo infinito, podríamos simplemente iterar sobre todo n,ky para cada par soltar cada una de las n+1,n+2,...,n+k-1( k-1posibilidades) y obtener todos (infinitamente muchos) valores de esos, luego simplemente ordenar la secuencia en orden ascendente y truncar a helementos. Por supuesto, en realidad no podemos hacer eso, pero si podemos llegar a un punto en el que los primeros helementos ordenados ya no puedan cambiar agregando los valores de cualquier n,kpar futuro , simplemente podemos truncarlos y terminar, en un tiempo finito. Para cualquier n,kpar, tiene al menos floor(log10(n)+1)*kdígitos, posiblemente más. Entonces, agrupemos estos pares por el valor c(n,k)=floor(log10(n)+1)*k, donde garantizamos que si c(a,b)<c(n,k)procesamos a,bantes n,k. Si tenemos la lista ordenada, y su último elemento tieneddígitos, y d<c(n,k)para el siguiente n,kque vamos a procesar, podemos detenernos, ya que no podemos obtener un número con tantos o menos dígitos, ya que por nuestra garantía ya deberíamos haberlo procesado, y por lo tanto, sin importar qué números terminaría computando, los primeros helementos no pueden cambiar, así que solo podemos devolverlos.

Así que ahora solo necesitamos la función que garantiza el orden establecido c(n,k). Para cada uno que se pueda yobtener c(n,k), debemos procesar todo (n,k)eso y=c(n,k). Digamos L=floor(log10(n)+1)por algunos n. Por y=L*klo tanto debe sostenerse. Comience con k=2,L=y/2, luego haga k=3,L=y/3;k=4,L=y/4...k=y,L=1, omitiendo valores no enteros de L. Para generar toda la c(n,k)función, comenzar con (1,2)con y=2, e incrementar yen 1 y empezar de nuevo cada vez que reciba L==1. Ahora tenemos una enumeración de pares (L,k), y satisface nuestra condición. Sin embargo, tenemos que recuperar toda posible na partir L, lo que hacemos mediante la enumeración de todos los números enteros con Ldígitos. Luego, para cada uno de esos (n,k)pares, para cada uno de losk-1posibles elementos descartados debemos generar el número de pérdida que obtenemos como resultado y agregarlo a nuestra lista, que comienza en blanco. Luego ordenamos la lista y repetimos en el siguiente (L,k)par, deteniéndonos cuando tenemos d<c(n,k)como se indicó anteriormente.

Desglose del código (un poco desactualizado):

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