ฉันกำหนดวิธีการรวมลำดับเพื่อหมายถึงว่าทุกหมายเลขในลำดับนั้นเรียงต่อกันเป็นสตริงจากนั้นผลลัพธ์นั้นจึงเป็นจำนวนเต็ม

[1, 2, 3] -> 123

สำหรับทุกลำดับที่ จำกัด อย่างน้อย 3 จำนวนเต็มติดต่อกันหายไปหนึ่งองค์ประกอบในลำดับและองค์ประกอบที่ขาดหายไปนี้อาจไม่ได้เป็นองค์ประกอบแรกหรือครั้งสุดท้ายในลำดับเอาท์พุทจำนวนเต็มที่เกิดจากลำดับรวมกัน ฉันหมายถึงสิ่งนี้ว่า "จำนวนเต็มสูญเสียโดยลำพัง"

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

ลำดับของจำนวนเต็มที่สูญเสียโดยลำพังนี่คือการรวมกันขององค์ประกอบต่อไปนี้ (พาร์ติชัน?):

subsequence แรก{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 สำหรับลำดับนี้

หมายเหตุอื่น: ฉันตั้งชื่อพวกเขาว่า "Singly Lossy Integers" เพื่อที่จะได้เป็น "Doubly Lossy Integers", "N-ly Lossy Integers", "(N + 1) - Integers Lossy ที่สูญเสีย" และ "Lossy Integers" "(รวมสิ่งเหล่านี้ทั้งหมด)

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แต่ก็สามารถขยายได้อย่างง่ายดายโดยการแทนที่ด้วยIntInteger

หักกอล์ฟ:

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 ไบต์ golfed โดย @nimi

Python 3, 136 127 126 122 bytes

วิธีการแก้ปัญหาที่ดุร้ายฉันไม่ลองแม้แต่ 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)พูด Let 's สำหรับบางคน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