Tôi xác định phương pháp kết hợp một chuỗi có nghĩa là mọi số trong chuỗi được nối thành một chuỗi, sau đó kết quả đó được tạo thành một số nguyên.

[1, 2, 3] -> 123

Đối với mỗi chuỗi hữu hạn có ít nhất 3 số nguyên liên tiếp, thiếu chính xác một phần tử trong chuỗi và phần tử bị thiếu này có thể không phải là phần tử đầu tiên hoặc cuối cùng trong chuỗi, xuất ra số nguyên từ chuỗi kết hợp. Tôi đang đề cập đến điều này như là một "số nguyên mất mát đơn lẻ".

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

Chuỗi các số nguyên mất đơn này là sự kết hợp của các chuỗi sau (phân vùng?):

Phần tiếp theo đầu tiên {n, n+2}là 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)

Các số nguyên này phải được in theo thứ tự tăng dần. 25 số nguyên mất đơn đầu tiên dưới đây :

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 số nguyên tổn thất đơn đầu tiên

Thực hiện tham chiếu Ungolfed. Tôi làm cho nó nhanh hơn, nhỏ hơn.

• Ý tưởng
• TIO (nhanh nhất, giới hạn cao hơn)

Quy tắc:

• Mã ngắn nhất sẽ thắng
• Bạn có thể (nói cái nào):
  • In các số nguyên mất đơn lẻ mãi mãi
  • Cho một số nguyên dương n , in hoặc trả về n phần tử đầu tiên dưới dạng danh sách hoặc chuỗi được phân cách bằng dấu phẩy hoặc khoảng trắng.
• Bạn nên hỗ trợ các số nguyên lớn tùy ý nếu ngôn ngữ của bạn cho phép, đặc biệt là nếu bạn in mãi mãi.

Lấy cảm hứng từ / Liên quan

Lưu ý: Vẫn chưa có mục nào trong OEIS cho chuỗi này.

Một lưu ý khác: Tôi đặt tên cho chúng là "Số nguyên tổn thất đơn lẻ" để lần lượt có thể là "Số nguyên tổn thất nghi ngờ", "Số nguyên tổn thất N-ly", "Số nguyên tổn thất" (N + 1) và "Số nguyên tổn thất" "(Liên minh tất cả những thứ này).

Toán học, 101 byte

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

Yay! Để một lần tôi có câu trả lời ngắn nhất!Party[Hard]

Haskell, 131 , 114 , 106 byte

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

Điều này bị giới hạn bởi kích thước Int, nhưng nó có thể dễ dàng mở rộng bằng cách thay thế Intbằng Integer.

Ít chơi gôn hơn:

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 byte được chơi bởi @nimi.

Python 3, 136 127 126 122 byte

Giải pháp vũ lực, tôi thậm chí không thử n = 7000 (đã mất 10 giây cho 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]

Giải trình

# 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

Các kết quả

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

Cảm ơn @ mbomb007 và @FricativeMelon vì sự giúp đỡ của họ

Python 3, 319 , 270 , 251 byte

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

Lấy hđầu vào từ STDIN và in một mảng các hsố nguyên mất đơn đầu tiên . Nó cũng rất nhanh, chỉ mất vài giây h=7000.

Giải thích: Lưu ý rằng, nếu chúng ta có thời gian vô hạn, chúng ta chỉ cần lặp đi lặp lại tất cả n,kvà cho mỗi cặp bỏ từng n+1,n+2,...,n+k-1( k-1khả năng) và nhận tất cả (vô số) giá trị từ các giá trị đó, sau đó chỉ cần sắp xếp chuỗi theo thứ tự tăng dần và cắt ngắn hcác yếu tố. Tất nhiên, chúng ta thực sự không thể làm điều đó, nhưng nếu chúng ta có thể đạt đến điểm mà các hphần tử được sắp xếp đầu tiên không còn có thể thay đổi bằng cách thêm các giá trị của bất kỳ n,kcặp nào trong tương lai , chúng ta có thể cắt ngắn sau đó và hoàn thành trong thời gian hữu hạn. Đối với bất kỳ n,kcặp nào , nó có ít nhất floor(log10(n)+1)*kchữ số, có thể nhiều hơn. Vì vậy, hãy nhóm các cặp này theo giá trị c(n,k)=floor(log10(n)+1)*k, nơi chúng tôi đảm bảo rằng nếu c(a,b)<c(n,k), chúng tôi xử lý a,btrước n,k. Nếu chúng ta đã sắp xếp danh sách, và phần tử cuối cùng của nó códchữ số, và d<c(n,k)cho lần tiếp theo n,kchúng ta sẽ xử lý, chúng ta có thể dừng lại, vì chúng ta không còn có thể nhận được một số có nhiều chữ số đó hay ít hơn, vì chúng ta đã xử lý nó rồi, và do đó, bất kể chúng ta là số nào sẽ kết thúc tính toán, các hyếu tố đầu tiên không thể thay đổi, vì vậy chúng tôi chỉ có thể trả lại chúng.

Vì vậy, bây giờ chúng ta chỉ cần chức năng đảm bảo thứ tự đã nêu trên c(n,k). Đối với mỗi ycó thể đạt được c(n,k), chúng ta phải xử lý tất cả (n,k)như vậy y=c(n,k). Hãy nói L=floor(log10(n)+1)cho một số n. Do đó y=L*kphải giữ. Bắt đầu với k=2,L=y/2, sau đó làm k=3,L=y/3;k=4,L=y/4...k=y,L=1, bỏ qua các giá trị không nguyên của L. Để tạo ra toàn bộ c(n,k)chức năng, bắt đầu với (1,2)với y=2, và tăng ythêm 1 và bắt đầu lại bất cứ khi nào bạn nhận được L==1. Bây giờ chúng tôi có một bảng liệt kê các cặp (L,k), và nó đáp ứng điều kiện của chúng tôi. Tuy nhiên, chúng tôi cần truy xuất tất cả những gì có thể ntừ Lđó, chúng tôi thực hiện bằng cách liệt kê tất cả các số nguyên có Lchữ số. Sau đó, cho mỗi (n,k)cặp, cho mỗik-1kết quả có thể bị giảm, chúng ta phải tạo ra số mất mát mà chúng ta nhận được và thêm nó vào danh sách của mình, bắt đầu trống. Sau đó, chúng tôi sắp xếp danh sách và lặp lại trên (L,k)cặp tiếp theo , dừng lại khi chúng tôi có d<c(n,k)như đã nêu trước đó.

Sự cố mã (một chút lỗi thời):

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