我定义了一种组合序列的方法，该方法意味着将序列中的每个数字连接为一个字符串，然后将结果设为整数。

[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-有损整数”，“（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

@nimi打高尔夫球的8个字节。

Python 3中，136个 127 126 122字节

蛮力解决方案，我什至不尝试n = 7000（n = 100已经花了10秒）

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