Saya mendefinisikan metode menggabungkan urutan berarti bahwa setiap angka dalam urutan disatukan sebagai string, maka hasil itu dibuat bilangan bulat.

[1, 2, 3] -> 123

Untuk setiap urutan hingga setidaknya 3 bilangan bulat berturut-turut, kehilangan tepat satu elemen dalam urutan, dan elemen yang hilang ini mungkin bukan elemen pertama atau terakhir dalam urutan, menghasilkan bilangan bulat yang dihasilkan dari urutan gabungan. Saya merujuk ini sebagai "integer lossy tunggal".

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

Urutan bilangan bulat lossy tunggal ini adalah penyatuan dari berikut berikut (partisi?):

Urutan pertama {n, n+2}adalah 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)

Bilangan bulat ini harus dicetak dalam urutan menaik. 25 bilangan bulat lossy tunggal pertama adalah di bawah ini :

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 Integer Rugi Tunggal

Implementasi referensi yang tidak digabungkan. Saya membuatnya menjadi lebih cepat, bukan lebih kecil.

• Ideone
• TIO (batas tercepat, lebih tinggi)

Aturan:

• Kode terpendek menang
• Anda dapat (katakan yang mana):
  • Cetak bilangan bulat tunggal yang hilang selamanya
  • Diberikan bilangan bulat positif n , cetak atau kembalikan elemen n pertama sebagai daftar, atau string yang dibatasi koma atau spasi putih.
• Anda harus mendukung bilangan bulat besar yang sewenang-wenang jika bahasa Anda memungkinkannya, terutama jika Anda mencetak selamanya.

Terinspirasi oleh / Terkait

Catatan: Belum ada entri dalam OEIS untuk urutan ini.

Catatan lain: Saya menamai mereka "Integer Kehilangan Singa" sehingga pada gilirannya akan ada "Integer Kehilangan Kerugian", "Integer Kehilangan N-ly", "(N + 1) Integer Kehilangan-saja", dan "Integer Kehilangan "(penyatuan semua ini).

Mathematica, 101 byte

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

Yay! Sekali ini saya punya jawaban yang paling singkat!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

Ini dibatasi oleh ukuran Int, tetapi dapat dengan mudah diperluas dengan mengganti Intdengan Integer.

Kurang bermain golf:

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 di-golf dengan @nimi.

Python 3, 136 127 126 122 byte

solusi brute force, saya bahkan tidak mencoba n = 7000 (sudah butuh 10s untuk 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]

Penjelasan

# 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

Hasil

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

Terima kasih kepada @ mbomb007 dan @FricativeMelon atas bantuan mereka

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

Mengambil hinput as dari STDIN dan mencetak array hbilangan bulat sing-lossy pertama . Ini sangat cepat juga, hanya membutuhkan beberapa detik h=7000.

Penjelasan: Catat bahwa, jika kita memiliki waktu yang tak terbatas, kita dapat dengan mudah mengulangi semua n,kdan untuk setiap pasangan menjatuhkan masing-masing n+1,n+2,...,n+k-1( k-1kemungkinan), dan mendapatkan semua (tak terhingga banyak) nilai dari itu, maka cukup urutkan urutan dalam urutan naik dan terpotong untuk helemen. Tentu saja, kita tidak bisa benar-benar melakukan itu, tetapi jika kita dapat mencapai titik di mana helemen yang diurutkan pertama tidak lagi dapat berubah dengan menambahkan nilai-nilai dari n,kpasangan masa depan , kita bisa memotongnya dan dilakukan, dalam waktu yang terbatas. Untuk setiap n,kpasangan, ia memiliki setidaknya floor(log10(n)+1)*kdigit, mungkin lebih banyak. Jadi mari kita kelompokkan pasangan ini berdasarkan nilainya c(n,k)=floor(log10(n)+1)*k, di mana kami menjamin bahwa jika c(a,b)<c(n,k), kami memproses a,bsebelumnya n,k. Jika kita memiliki daftar yang diurutkan, dan elemen terakhirnya memilikiddigit, dan d<c(n,k)untuk selanjutnya n,kkita akan memproses, kita dapat berhenti, karena kita tidak bisa lagi mendapatkan nomor dengan angka yang lebih banyak atau lebih sedikit, karena dengan jaminan kita, kita seharusnya sudah memprosesnya, dan oleh karena itu tidak peduli nomor mana yang kita akan berakhir komputasi, helemen pertama tidak bisa berubah, jadi kita bisa mengembalikannya.

Jadi sekarang kita hanya perlu fungsi yang menjamin pesanan yang disebutkan c(n,k). Untuk setiap yang ydapat diperoleh c(n,k), kita harus memproses semua (n,k)itu y=c(n,k). Katakanlah L=floor(log10(n)+1)untuk beberapa n. Karena itu y=L*kharus tahan. Mulai dengan k=2,L=y/2, lalu lakukan k=3,L=y/3;k=4,L=y/4...k=y,L=1, lewati nilai-nilai non-integer dari L. Untuk menghasilkan seluruh c(n,k)fungsi, mulailah (1,2)dengan y=2, dan tambah y1 dan mulai lagi kapan pun Anda dapatkan L==1. Sekarang kami memiliki enumerasi pasangan (L,k), dan itu memenuhi kondisi kami. Namun, kita perlu mengambil semua yang mungkin ndari L, yang kita lakukan dengan menghitung semua bilangan bulat dengan Ldigit. Kemudian untuk masing-masing (n,k)pasangan itu, untuk masing-masing pasangank-1kemungkinan elemen yang dijatuhkan kita harus menghasilkan angka lossy yang kita dapatkan sebagai hasilnya, dan menambahkannya ke daftar kita, yang mulai kosong. Kemudian kami mengurutkan daftar dan mengulangi pada (L,k)pasangan berikutnya , berhenti ketika kami memiliki d<c(n,k)seperti yang dinyatakan sebelumnya.

Rincian kode (agak ketinggalan jaman):

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