Definisco il metodo di combinazione di una sequenza per indicare che ogni numero nella sequenza viene concatenato come una stringa, quindi quel risultato viene reso un numero intero.

[1, 2, 3] -> 123

Per ogni sequenza finita di almeno 3 numeri interi consecutivi, mancando esattamente un elemento nella sequenza e questo elemento mancante potrebbe non essere il primo o l'ultimo elemento della sequenza, emette l'intero risultante dalla sequenza combinata. Mi riferisco a questo come a "numeri interi singolarmente in perdita".

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

Questa sequenza di numeri interi con perdita di valore è l'unione delle seguenti sottosequenze (partizioni?):

La prima sottosequenza{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)

Questi numeri interi devono essere stampati in ordine crescente. I primi 25 numeri interi con perdita singola sono i seguenti :

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

Primi 7597 numeri interi con perdita singola

Implementazioni di riferimento non golfate. L'ho fatto per essere più veloce, piuttosto che più piccolo.

• Ideone
• TIO (più veloce, limiti più alti)

Regole:

• Il codice più corto vince
• Puoi (dire quale):
  • Stampa per sempre gli interi singolarmente in perdita
  • Dato un numero intero positivo n , stampa o restituisce i primi n elementi come un elenco o una stringa delimitata da virgole o spazi bianchi.
• Dovresti supportare numeri interi arbitrariamente grandi se la tua lingua lo consente, soprattutto se stai stampando per sempre.

Ispirato da / Correlato

Nota: non esiste ancora una voce nell'OIS per questa sequenza.

Un'altra nota: li ho chiamati "Singly Lossy Integer" in modo che possano esserci a loro volta "Doubly Lossy Integers", "N-ly Lossy Integers", "(N + 1) -ly Lossy Integers" e "Lossy Integers" "(unione di tutti questi).

Mathematica, 101 byte

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

Sìì! Per una volta ho la risposta più breve!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

Questo è limitato dalle dimensioni di Int, ma può essere facilmente esteso sostituendolo Intcon Integer.

Meno 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 giocati da @nimi.

Python 3, 136 127 126 122 byte

soluzione di forza bruta, non provo nemmeno n = 7000 (ci vogliono già 10 s per 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]

Spiegazione

# 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

risultati

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

Grazie a @ mbomb007 e @FricativeMelon per il loro aiuto

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

Prende un hinput da STDIN e stampa una matrice dei primi hnumeri interi con perdita singola. È anche molto veloce, richiede solo pochi secondi h=7000.

Spiegazione: Nota che, se avessimo un tempo infinito, potremmo semplicemente iterare su tutto n,ke per ogni coppia eliminare ciascuna delle n+1,n+2,...,n+k-1( k-1possibilità), e ottenere tutti (infinitamente) valori da quelli, quindi semplicemente ordinare la sequenza in ordine crescente e troncare helementi. Ovviamente, non possiamo effettivamente farlo, ma se riusciamo a raggiungere un punto in cui i primi helementi ordinati non possono più cambiare aggiungendo i valori di eventuali n,kcoppie future , possiamo semplicemente troncare allora ed essere fatti, a tempo finito. Per ogni n,kcoppia, ha almeno floor(log10(n)+1)*kcifre, forse di più. Quindi raggruppiamo queste coppie in base al valore c(n,k)=floor(log10(n)+1)*k, dove garantiamo che c(a,b)<c(n,k), se elaborate in a,bprecedenza n,k. Se abbiamo ordinato l'elenco, e ha l'ultimo elementodcifre, e d<c(n,k)per il prossimo elementi non possono cambiare, quindi possiamo semplicemente restituirli.n,kstiamo per elaborare, possiamo fermarci, dal momento che non possiamo più ottenere un numero con tante o poche cifre, poiché con la nostra garanzia avremmo dovuto già elaborarlo e, quindi, indipendentemente dai numeri che finiremmo per calcolare, il primoh

Quindi ora abbiamo solo bisogno della funzione che garantisca l'ordine dichiarato su c(n,k). Per ogni yottenibile per c(n,k), dobbiamo elaborare tutto (n,k)ciò y=c(n,k). Diciamo L=floor(log10(n)+1)per alcuni n. Pertanto y=L*kdeve tenere. Inizia con k=2,L=y/2, quindi fai k=3,L=y/3;k=4,L=y/4...k=y,L=1, saltando i valori non interi di L. Per generare l'intera c(n,k)funzione, inizia con (1,2)con y=2, e aumentare ydi 1 e ricominciare da capo ogni volta che si ottiene L==1. Ora abbiamo un elenco di coppie (L,k)e soddisfa la nostra condizione. Tuttavia, dobbiamo recuperare tutto il possibilen daL che facciamo enumerando tutti gli interi con Lle cifre. Quindi per ognuna di quelle (n,k)coppie, per ognuna dellek-1possibili elementi rilasciati dobbiamo generare il numero con perdita che otteniamo di conseguenza e aggiungerlo al nostro elenco, che inizia vuoto. Quindi ordiniamo l'elenco e ripetiamo sulla (L,k)coppia successiva , fermandoci quando abbiamo d<c(n,k)come affermato in precedenza.

Analisi del codice (un po 'obsoleta):

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