Dizideki her sayının bir dize olarak birleştirildiği anlamına gelen bir diziyi birleştirme yöntemini tanımlarım, daha sonra bu sonuç bir tamsayı yapılır.

[1, 2, 3] -> 123

Sekansta tam olarak bir eleman eksik olan en az 3 ardışık tamsayıdan oluşan her sonlu sekans için ve bu eksik eleman, sekanstaki ilk veya son eleman olmayabilir, kombine sekanstan çıkan tamsayıyı çıktılar. Ben buna "tek başına kayıplı bir tamsayı" diyorum.

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

Bu tek tek kayıplı tamsayılar dizisi, aşağıdaki alt dizilerin bir araya getirilmesidir (bölümler?):

İlk {n, n+2}alt sıra A032607'dir .

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

Bu tamsayılar artan sırada yazdırılmalıdır. İlk 25 kayıplı tamsayı aşağıdadır :

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

İlk 7597 Tek Kayıplı Tam Sayı

Açık olmayan referans uygulamaları. Daha küçük değil, daha hızlı yaptım.

• Ideone
• TIO (en hızlı, daha yüksek limitler)

Kurallar:

• En kısa kod kazanır
• Şunları yapabilirsiniz (hangisini söyleyin):
  • Tek başına kayıplı tam sayıları sonsuza kadar yazdırın
  • Pozitif bir n tamsayısı verildiğinde , ilk n öğeyi bir liste olarak veya virgül veya boşlukla ayrılmış bir dize olarak yazdırın veya döndürün.
• Diliniz izin veriyorsa, özellikle de sonsuza kadar yazdırıyorsanız, keyfi olarak büyük tamsayıları desteklemelisiniz.

Esinlenen / İlgili

Not: OEIS'de bu sekans için henüz bir giriş yoktur.

Başka bir not: Onlara "Tek Kayıplı Tamsayılar" adını verdim, böylece "Çift Kayıplı Tamsayılar", "N-ly Kayıplı Tamsayılar", "(N + 1) -li Kayıplı Tamsayılar" ve "Kayıplı Tamsayılar" "(bunların birliği).

Mathematica, 101 bayt

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

Yaşasın! Bir kere en kısa cevabı aldım!Party[Hard]

Haskell, 131 , 114 , 106 bayt

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

Bu büyüklüğü ile sınırlıdır Int, ancak kolayca değiştirilmesi ile uzatılabilir Intile Integer.

Daha az 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

@Nimi tarafından 8 bayt golf.

Python 3, 136 127 126 122 bayt

kaba kuvvet çözümü, n = 7000 bile denemiyorum (zaten n = 100 için 10s alır)

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]

açıklama

# 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

Sonuçlar

>>> 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 ve @FricativeMelon'a yardımları için teşekkürler

Python 3, 319 , 270 , 251 bayt

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

Bir alır hSTDIN'den girdi olarak ve birinci dizisi basar h, tek başına-kayıplı tamsayı. Ayrıca çok hızlı, sadece birkaç saniye sürüyor h=7000.

Açıklama: Sonsuz zamanımız olsaydı, sadece n,kher şeyi tekrarlayabiliriz ve her çift için n+1,n+2,...,n+k-1( k-1olasılıklar) her birini düşürür ve onlardan tüm (sonsuz sayıda) değer elde edebiliriz, o zaman sekansı artan düzende sıralayabilir ve kısaltabiliriz. helementler. Tabii ki, bunu gerçekten yapamayız, ancak ilk sıralanan höğelerin gelecekteki n,kçiftlerin değerlerini ekleyerek artık değişemeyeceği bir noktaya ulaşabilirsek , sonlu zamanda sadece kısaltabilir ve yapılabiliriz. Herhangi bir n,kçift ​​için, en azından floor(log10(n)+1)*krakamlar, muhtemelen daha fazla. Yani grup değerine göre bu çiftleri sağlar c(n,k)=floor(log10(n)+1)*keğer garanti, c(a,b)<c(n,k)biz işlemek, a,bdaha önce n,k. Listeyi sıraladıysak ve son öğesidrakamlar, ve bir d<c(n,k)sonraki n,kişlemek için durabiliriz, çünkü artık bu kadar çok veya daha az basamakla bir sayı elde edemeyiz, çünkü garantimizle bunu daha önce işlemiş olmalıydık ve bu nedenle hangi rakamlar olursa olsun hesaplamaya son verir, ilk höğeler değişemez, bu yüzden onları geri verebiliriz.

Şimdi sadece belirtilen siparişi garanti eden fonksiyona ihtiyacımız var c(n,k). Her yelde edilebilir için c(n,k), tüm bunları (n,k)işlemeliyiz y=c(n,k). L=floor(log10(n)+1)Bazıları için diyelim n. Bu nedenle y=L*ktutunmalıdır. İle tamsayı olmayan değerleri atlayarak başlayın k=2,L=y/2, sonra yapın . Bütün oluşturmak için fonksiyonu ile başlamak ile ve artırmak 1 ile ve almak zaman tekrar başlatın . Şimdi çift sayımımız var ve durumumuzu tatmin ediyor. Ancak, tüm olası almak gerekir dan yaptığımız, hangi ile tüm tamsayılar numaralandırma tarafından basamağı. Sonra bu çiftlerin her biri için,k=3,L=y/3;k=4,L=y/4...k=y,L=1Lc(n,k)(1,2)y=2yL==1(L,k)nLL(n,k)k-1olası düşmüş öğeler, sonuç olarak elde ettiğimiz kayıplı sayıyı oluşturmalı ve boş başlayan listemize eklemeliyiz. Sonra listeyi sıralıyoruz ve bir sonraki (L,k)çiftte tekrarlıyoruz, daha d<c(n,k)önce belirttiğimiz gibi duruyoruz .

Kod dökümü (biraz modası geçmiş):

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