Ich definiere die Methode zum Kombinieren einer Sequenz so, dass jede Zahl in der Sequenz als Zeichenfolge verkettet wird und dieses Ergebnis zu einer Ganzzahl gemacht wird.

[1, 2, 3] -> 123

Für jede endliche Folge von mindestens 3 aufeinanderfolgenden ganzen Zahlen, bei denen genau ein Element in der Folge fehlt und dieses fehlende Element möglicherweise nicht das erste oder letzte Element in der Folge ist, geben Sie die ganze Zahl aus, die sich aus der kombinierten Folge ergibt. Ich spreche von einer "einfach verlustbehafteten Ganzzahl".

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

Diese Folge von einfach verlustbehafteten ganzen Zahlen ist die Vereinigung der folgenden Teilfolgen (Partitionen?):

Die erste Untersequenz{n, n+2} ist 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)

Diese ganzen Zahlen müssen in aufsteigender Reihenfolge gedruckt werden. Die ersten 25 einfach verlustbehafteten ganzen Zahlen sind unten :

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

Erste 7597 Singly Lossy Integers

Ungolfed-Referenzimplementierungen. Ich habe es schneller gemacht als kleiner.

• Ideone
• TIO (schnellste, höhere Limits)

Regeln:

• Kürzester Code gewinnt
• Sie können entweder (sagen welche):
  • Drucken Sie die einfach verlustbehafteten ganzen Zahlen für immer
  • Bei einer positiven Ganzzahl n werden die ersten n Elemente als Liste oder als durch Kommas oder Leerzeichen getrennte Zeichenfolge ausgegeben oder zurückgegeben.
• Sie sollten beliebig große Ganzzahlen unterstützen, wenn Ihre Sprache dies zulässt, insbesondere wenn Sie für immer drucken.

Inspiriert von / Verwandte

Hinweis: Für diese Sequenz ist noch kein Eintrag im OEIS vorhanden.

Noch eine Anmerkung: Ich habe sie "Einfach verlustbehaftete Ganzzahlen" genannt, so dass es wiederum "Einfach verlustbehaftete Ganzzahlen", "Einfach verlustbehaftete Ganzzahlen", "(N + 1) verlustbehaftete Ganzzahlen" und "Verlustbehaftete Ganzzahlen" geben kann "(Vereinigung all dieser).

Mathematica, 101 Bytes

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

Yay! Ausnahmsweise habe ich die kürzeste Antwort!Party[Hard]

Haskell, 131 , 114 , 106 Bytes

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

Dies wird durch die Größe begrenzt Int, aber es kann leicht durch den Austausch erweitert werden Intmit Integer.

Weniger golfen:

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 Bytes von @nimi golfen.

Python 3, 136 127 126 122 Bytes

Brute-Force-Lösung, ich versuche nicht einmal n = 7000 (es dauert schon 10s für 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]

Erläuterung

# 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

Ergebnisse

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

Vielen Dank an @ mbomb007 und @FricativeMelon für ihre Hilfe

Python 3, 319 , 270 , 251 Bytes

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

Nimmt eine hals Eingabe von STDIN und druckt ein Array der ersten heinfach verlustbehafteten Ganzzahlen. Es ist auch sehr schnell und dauert nur ein paar Sekunden h=7000.

Erläuterung: Beachten Sie, dass wir, wenn wir unendlich viel Zeit hätten, einfach über alle iterieren n,kund für jedes Paar alle n+1,n+2,...,n+k-1( k-1Möglichkeiten) löschen und alle (unendlich viele) Werte daraus abrufen könnten. Sortieren Sie dann die Reihenfolge in aufsteigender Reihenfolge und kürzen Sie auf hElemente. Natürlich können wir das nicht wirklich tun, aber wenn wir einen Punkt erreichen, an dem sich die ersten sortierten hElemente nicht mehr ändern können, indem n,kwir die Werte zukünftiger Paare addieren , können wir einfach abschneiden und dies in endlicher Zeit tun. Für jedes n,kPaar hat es mindestens floor(log10(n)+1)*kZiffern, möglicherweise mehr. Also lassen Sie c(n,k)=floor(log10(n)+1)*kuns diese Paare nach dem Wert gruppieren , bei dem wir garantieren, dass c(a,b)<c(n,k)wir a,bvorher verarbeiten n,k. Wenn wir die Liste sortiert haben und ihr letztes Element hatdziffern, und d<c(n,k)für die nächste n,kverarbeitung können wir aufhören, da wir mit so vielen oder weniger ziffern keine nummer mehr bekommen können, da wir sie nach unserer garantie dann schon hätten verarbeiten sollen, also egal welche nummern wir würde am Ende Computing, können die ersten hElemente nicht ändern, so können wir sie nur zurückgeben.

Jetzt brauchen wir nur noch die Funktion, die die angegebene Reihenfolge garantiert c(n,k). Für jedes yerhältliche c(n,k)müssen wir alle (n,k)so verarbeiten, dass y=c(n,k). Sagen wir L=floor(log10(n)+1)für einige n. Daher y=L*kmuss halten. Beginnen Sie mit k=2,L=y/2und k=3,L=y/3;k=4,L=y/4...k=y,L=1überspringen Sie dann die nicht ganzzahligen Werte von L. Um die ganze zu erzeugen c(n,k)Funktion, beginnen Sie mit (1,2)mit y=2und erhöhen yum 1 und beginnen wieder , wann immer Sie bekommen L==1. Jetzt haben wir eine Aufzählung von Paaren (L,k), und es erfüllt unsere Bedingung. Allerdings müssen wir alle möglichen abrufen naus L, die wir durch Aufzählen alle ganzen Zahlen mit tun LZiffern. Dann für jedes dieser (n,k)Paare, für jedes derk-1Eventuell ausgelassene Elemente müssen wir die verlustbehaftete Zahl generieren, die wir als Ergebnis erhalten, und sie zu unserer Liste hinzufügen, die leer beginnt. Dann sortieren wir die Liste und wiederholen das nächste (L,k)Paar d<c(n,k).

Code-Aufschlüsselung (etwas veraltet):

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